public static long Calculate(long x, long n) { int l = n.BitsCeiling(); int t = OrderFindingTransform.GetPercision(n); var regs = OrderFindingTransform.Registers(t, l).ToArray(); IUnitaryTransform orderfinder = OrderFindingTransform.Get(x, n, t); var regTwo = MultiQubit.BasisVector(1, l); var regOne = new MultiQubit(Enumerable.Range(0, t).Select(i => Qubit.ClassicZero).ToArray()); var input = new MultiQubit(regOne, regTwo); long denom = (long)Math.Pow(2, t); while (true) { QuantumSim sim = new QuantumSim(orderfinder, regs); IDictionary <Register, long> res = sim.Simulate(input); long regValue = res.First().Value; // can't do anything if we get zero, cant reduce if (regValue == 0) { continue; } foreach (var(_, rCandidate) in FractionHelpers.GetContinuedFractionSequence(regValue, denom)) { if ((long)Math.Pow(x, rCandidate) % n == 1) { return(rCandidate); } } } }
public void PhaseHadamarTest() { long x = 2; long n = 3; int l = n.BitsCeiling(); int t = l;// OrderFindingTransform.GetPercision(n); var regs = OrderFindingTransform.Registers(t, l).ToArray(); IUnitaryTransform orderfinder = PhaseEstimator.GetPhaseHadamar(t, l); var regTwo = MultiQubit.BasisVector(1, l); var regOne = new MultiQubit(Enumerable.Range(0, t).Select(i => Qubit.ClassicZero).ToArray()); var input = new MultiQubit(regOne, regTwo); IQuantumState res = orderfinder.Transform(input); string inputStr = input.Print(regs); inputStr.Should().Be("+1.00|0>|1>"); string outStr = res.Print(regs); // first reg is unchanged, second reg is maximally mixed outStr.Should().Be("+0.50|0>|1>+0.50|1>|1>+0.50|2>|1>+0.50|3>|1>"); }
public void OrderFindTest() { long x = 2; long n = 3; int r = 2; // 2 ^ 2 = 3 + 1 int l = n.BitsCeiling(); int t = OrderFindingTransform.GetPercision(n); var regs = OrderFindingTransform.Registers(t, l).ToArray(); IUnitaryTransform orderfinder = OrderFindingTransform.Get(x, n, t); var regTwo = MultiQubit.BasisVector(1, l); var regOne = new MultiQubit(Enumerable.Range(0, t).Select(i => Qubit.ClassicZero).ToArray()); var input = new MultiQubit(regOne, regTwo); IQuantumState res = orderfinder.Transform(input); string inputStr = input.Print(regs); inputStr.Should().Be("+1.00|0>|1>"); string outStr = res.Print(regs); // all first register options evenly divide 2^t and reduce to fractiosn // with a denominator of r = 2 // in this case 0 and 32 over 2^6 equal 0 and 1/2 // therefore answer is 2 outStr.Should().Be("+0.50|0>|1>+0.50|0>|2>+0.50|32>|1>+-0.50|32>|2>"); }
public void OrderStartTest() { long x = 2; long n = 3; int l = n.BitsCeiling(); int t = l;// OrderFindingTransform.GetPercision(n); var regs = OrderFindingTransform.Registers(t, l).ToArray(); IUnitaryTransform orderfinder = OrderFindingTransform.GetStart(x, n, t); var regTwo = MultiQubit.BasisVector(1, l); var regOne = new MultiQubit(Enumerable.Range(0, t).Select(i => Qubit.ClassicZero).ToArray()); var input = new MultiQubit(regOne, regTwo); IQuantumState res = orderfinder.Transform(input); string inputStr = input.Print(regs); inputStr.Should().Be("+1.00|0>|1>"); string outStr = res.Print(regs); outStr.Should().Be("+0.50|0>|1>+0.50|1>|2>+0.50|2>|1>+0.50|3>|2>"); }
public CompositeTransform ApplyControlled(IUnitaryTransform g, int controlIndex, int[] targetIndexes, long exp = 1) { IUnitaryTransform newTrans = new PartialTransform( Dimension, new CTransform(g), new[] { controlIndex }.Concat(targetIndexes).ToArray()); return(new CompositeTransform(transforms.Add(newTrans.Pow(exp)))); }
/// <summary> /// First u.NumQubits qubits are the eigenvector, the rest is t register in /// significance descending order /// </summary> public static IUnitaryTransform GatePhaseEstimator(IUnitaryTransform u, int t) { long totalDimension = u.Dimension * (long)Math.Pow(2, t); // dimension of tensor product multiplies var phaseEstimator = GatePhaseEstimatorStart(u, t); // finally apply inverse qft to the t register return(phaseEstimator.Apply( new PartialTransform( totalDimension, // phase trans assumes fourier does not do the swap and scales Fourier.FourierTransform(t, false, true).Inverse(), Enumerable.Range(0, t).ToArray()))); }
public PartialTransform(long dimension, IUnitaryTransform transform, int[] applyToQubitIndexes) { if (transform.Dimension != (long)Math.Pow(2, applyToQubitIndexes.Length)) { throw new ArgumentException(); } if (!Dimension.IsPowerTwo()) { throw new ArgumentException(); } this.transform = transform; this.applyToQubitIndexes = applyToQubitIndexes; Dimension = dimension; NumQubits = (int)Math.Log(Dimension, 2); }
public static CompositeTransform GatePhaseEstimatorStart(IUnitaryTransform u, int t) { var phaseEstimator = GetPhaseHadamar(t, u.NumQubits); foreach (int ti in Enumerable.Range(0, t)) { // apply u 2^(ti) times long j = (long)Math.Pow(2, ti); phaseEstimator = phaseEstimator.ApplyControlled( u, t - 1 - ti, Enumerable.Range(t, u.NumQubits).ToArray(), j); } return(phaseEstimator); }
public void OrderFindSimTest() { long x = 2; long n = 3; int r = 2; // 2 ^ 2 = 3 + 1 int l = n.BitsCeiling(); int t = OrderFindingTransform.GetPercision(n); var regs = OrderFindingTransform.Registers(t, l).ToArray(); IUnitaryTransform orderfinder = OrderFindingTransform.Get(x, n, t); var regTwo = MultiQubit.BasisVector(1, l); var regOne = new MultiQubit(Enumerable.Range(0, t).Select(i => Qubit.ClassicZero).ToArray()); var input = new MultiQubit(regOne, regTwo); var sim = new QuantumSim(orderfinder, regs); var res = sim.Simulate(input); res.First().Value.Should().BeOneOf(0, 32); }
public QuantumSim(IUnitaryTransform transform, params Register[] regs) { this.transform = transform; this.regs = regs; }
public IUnitaryTransform Pow(long exponent) { IUnitaryTransform wtf = this; return(new CompositeTransform(LongExt.Range(0, exponent).Select(exp => wtf).ToArray())); }
public CompositeTransform ApplyControlled(IUnitaryTransform g, int controlIndex, int targetIndex, long exp = 1) => ApplyControlled(g, controlIndex, new[] { targetIndex }, exp);
public CompositeTransform Apply(IUnitaryTransform g, int[] qubitIndexes, long exp = 1) { IUnitaryTransform newTrans = new PartialTransform(Dimension, g, qubitIndexes); return(new CompositeTransform(transforms.Add(newTrans.Pow(exp)))); }
public CompositeTransform Apply(IUnitaryTransform transform, long exp = 1) => new CompositeTransform(transforms.Add(transform.Pow(exp)));
public int NumGates => InnerTransform.NumGates; // i think this is considered a basic gate public CTransform(IUnitaryTransform innerTransform) { InnerTransform = innerTransform; }