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;
}
