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 IQuantumState Transform(IQuantumState input)
{
if (input.Dimension != 2 * InnerTransform.Dimension)
{
throw new ArgumentException(nameof(input));
}
var firstHalf = new Complex[Dimension / 2];
var secHalf = new Complex[Dimension / 2];
for (long i = 0; i < Dimension; i++)
{
// first half of vector is just copied over as an identity
if (i < Dimension / 2)
{
firstHalf[i] = input.GetAmplitude(new ComputationalBasis(i, NumQubits));
}
else
{
secHalf[i - (Dimension / 2)] = input.GetAmplitude(new ComputationalBasis(i, NumQubits));
}
}
var transformedSecHalf = InnerTransform.Transform(new MultiQubit(secHalf));
return(new MultiQubit(firstHalf.Concat(transformedSecHalf).ToArray()));
}
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>");
}
//EXECUTION
protected override void InternalExecution()
{
int size = 100;
IList list = new ArrayList();
IQuantumState newState;
IQuantumOperator randomizer = QuantumOperatorFactory.generateRandomizeOperator();
TesterLog("Generating " + size + " QuantumSimpleStates of 3 levels and initializing to random....");
for (int i = 0; i < size; i++)
{
newState = QuantumStateFactory.generateStateSimple(3);
randomizer.Evaluate(newState);
list.Add(newState);
}
TesterLog("");
TesterLog("Showing all of them");
for (int i = 0; i < size; i++)
{
newState = (IQuantumState)list[i];
TesterLog(newState.generateQuantumDebugger().FullDebug);
}
TesterLog("");
TesterLog("Getting a composed state of all of them");
IQuantumState[] array = new IQuantumState[list.Count];
list.CopyTo(array,0);
IQuantumState composed = QuantumStateFactory.generateStateComposed(array);
TesterLog(composed.generateQuantumDebugger().FullDebug);
}
public override void Explore(IInformationState state, string description)
{
State = ((IQuantumState)state);
this.Text = description;
Start();
}
public IDictionary <Register, long> Simulate(IQuantumState input)
{
DateTime start = DateTime.UtcNow;
var res = transform.Transform(input);
var ret = new Dictionary <Register, long>();
foreach (var reg in regs)
{
double[] probs = res.GetDistribution(reg);
double randomDouble = randomSource.NextDouble();
double accum = 0;
for (long regValue = 0; regValue < probs.LongLength; regValue++)
{
accum += probs[regValue];
if (accum > randomDouble)
{
ret[reg] = regValue;
break;
}
}
}
GatesProcessed += transform.NumGates;
Console.WriteLine($"Time elapsed: {DateTime.UtcNow - start}");
Console.WriteLine($"Gates processed: {transform.NumGates}");
return(ret);
}
public static string Print(this IQuantumState state, params Register[] registers)
{
var test = state.ToArray().Where(b => b.Magnitude > ComplexExt.Precision);
StringBuilder sb = new StringBuilder();
for (long i = 0; i < state.Dimension; i++)
{
var basis = new ComputationalBasis(i, state.NumQubits());
var amp = state.GetAmplitude(basis);
if (amp.Magnitude < ComplexExt.Precision)
{
continue;
}
sb.Append($"+{(amp.Imaginary == 0 ? amp.Real.ToString("F2") : amp.ToString("F2"))}");
var labels = basis.GetLabels();
foreach (var register in registers)
{
var registerLabels = new List <bool>();
foreach (var index in register.QubitIndexes)
{
registerLabels.Add(labels[index]);
}
long regValue = ComputationalBasis.FromLabels(registerLabels.ToArray()).AmpIndex;
sb.Append($"|{regValue}>");
}
}
return(sb.ToString());
}
public override void Evaluate(IQuantumState state)
{
IQuantumStateDebugger debuggerData = state.generateQuantumDebugger();
IQuantumStateDebugger debuggerElement = ReferenceBasis.getState(ReferenceElement).generateQuantumDebugger();
debuggerData.setVectorInternal(debuggerElement.getVectorInternal());
}
public override void Evaluate(IQuantumState state)
{
IQuantumStateDebugger debugger = state.generateQuantumDebugger();
IComplexMatrix vector = debugger.getVectorInternal();
vector.Randomize();
debugger.setVectorInternal(vector);
}
/// <summary>
/// The probabilities of each possible register value indexed by that value.
/// </summary>
public static double[] GetDistribution(this IQuantumState state, Register reg)
{
int regSize = reg.QubitIndexes.Count();
long maxRegValue = (long)Math.Pow(2, regSize);
// probabilities indexed by register value
double[] regProbabilities = new double[maxRegValue];
// go through every probability
for (long i = 0; i < state.Dimension; i++)
{
var basis = new ComputationalBasis(i, state.NumQubits());
var amp = state.GetAmplitude(basis);
if (amp.Magnitude < ComplexExt.Precision)
{
continue;
}
var labels = basis.GetLabels();
var registerLabels = new List <bool>();
foreach (var index in reg.QubitIndexes)
{
registerLabels.Add(labels[index]);
}
long regValue = ComputationalBasis.FromLabels(registerLabels.ToArray()).AmpIndex;
regProbabilities[regValue] += amp.Magnitude * amp.Magnitude;
}
return(regProbabilities);
}
public virtual void Explore(IQuantumState state, string description)
{
IQuantumStateDebugger debugger = state.generateQuantumDebugger();
int count = debugger.getNumLevels();
Show();
}
// returns the index of the measured state into basis
// the state is altered
// successive measuerments are the same;
public override void Evaluate(IQuantumState state)
{
double[] probabilities = generateProbabilities(state, ReferenceBasis);
int selected = selectPosition(probabilities);
updateState(state, ReferenceBasis, selected);
MeasuredElement = selected;
}
public IQuantumState Transform(IQuantumState input)
{
if (input.Dimension != 2)
{
throw new ArgumentException(nameof(input));
}
return(Transform(new Qubit(input.GetAmplitude("0"), input.GetAmplitude("1"))));
}
public virtual void Explore(IQuantumState state, string description)
{
textBox.Text = state.generateQuantumDebugger().FullDebug;
Text += ": " + description;
Show();
}
public override void Evaluate(IQuantumState state)
{
if (Configuration.DelayEnabled == false) { return; }
if (Configuration.DelayTicks != 0)
{
System.Threading.Thread.Sleep(Configuration.DelayTicks);
}
}
// INTERNAL STATE
public override void AssociateState(IQuantumState state)
{
if (state != null)
{
if (state.Debugger.getNumLevels() != (int)InformationArity.Binary)
{ throw new DatatypeException(); }
}
setInternalState( state );
}
// INTERNAL STATE
public override void AssociateState(IQuantumState state)
{
if (state != null)
{
if (state.generateQuantumDebugger().getNumLevels() != (int)InformationArity.Binary)
{ throw new ExceptionDataError(); }
}
setInternalState( state );
}
public override void Evaluate(IQuantumState state)
{
if (EffectiveDelayTicks != 0)
{
long startWait = System.DateTime.UtcNow.Ticks;
while (System.DateTime.UtcNow.Ticks - startWait < EffectiveDelayTicks)
{
System.Windows.Forms.Application.DoEvents();
}
}
}
public static IQuantumStateCollection generateAutomatedStateCollection(int numLevels)
{
IQuantumState[] states = new IQuantumState[numLevels];
for (int i = 0; i < numLevels; i++)
{
states[i] = generateStateSimple(numLevels);
OrtoNormalize(states[i], i);
}
return generateStateCollection(states);
}
// CONSTRUCTOR
public QuStateDebugger(IQuantumState state)
: base()
{
if (state is AbstractQuantumState)
{
_abstractState = (AbstractQuantumState)state;
}
else
{
throw new ExceptionQuantumDebugger();
};
}
// CONSTRUCTOR
public QuantumStateDebugger(IQuantumState state)
: base()
{
if (state is QuantumStateAbstract)
{
_abstractState = (QuantumStateAbstract)state;
}
else
{
throw new QuantumStateException();
};
}
public IQuantumState[] ExportAsArray()
{
int count = countObjects();
IQuantumState[] result = new IQuantumState[count];
for (int i = 0; i < count; i++)
{
result[i] = (IQuantumState)getObject(i);
}
return result;
}
public IQuantumState Transform(IQuantumState input)
{
if (input.Dimension != Dimension)
{
throw new ArgumentException(nameof(input.Dimension));
}
DenseVector inVec = DenseVector.OfArray(input.ToArray());
var res = matrix * inVec;
return(new MultiQubit(res.ToArray()));
}
public override void Evaluate(IQuantumState state)
{
if (Configuration.DelayEnabled == false) { return; }
if (Configuration.DelayTicks != 0)
{
long startWait = System.DateTime.UtcNow.Ticks;
while (System.DateTime.UtcNow.Ticks - startWait < Configuration.DelayTicks)
{
System.Windows.Forms.Application.DoEvents();
}
}
}
// override public void Evaluate(IQuantumState state)
// {
// if (EffectiveNoiseFactor != 0)
// {
// IQuantumStateDebugger debugger = state.generateQuantumDebugger();
// IComplexMatrix stateVector = debugger.getVectorInternal();
// IComplexMatrix noiseVector = generateNoiseVector(stateVector.countTotalElements());
// IComplexMatrix tempVector = FactoryComplexMatrix.Operations.Add(stateVector, noiseVector);
// IComplexMatrix noiseMatrix = generateNoiseMatrix(tempVector.countTotalElements());
// IComplexMatrix resultVector = FactoryComplexMatrix.Operations.Multiplication(noiseMatrix, stateVector);
// debugger.setVectorInternal(resultVector);
// }
// }
public override void Evaluate(IQuantumState state)
{
if (EffectiveNoiseFactor != 0)
{
IQuantumStateDebugger debugger = state.generateQuantumDebugger();
IComplexMatrix stateVector = debugger.getVectorInternal();
IComplexMatrix noiseVector = generateNoiseVector(stateVector.countTotalElements());
IComplexMatrix tempVector = FactoryComplexMatrix.Operations.Add(stateVector, noiseVector);
IComplexMatrix noiseMatrix = generateNoiseMatrix(tempVector.countTotalElements());
IComplexMatrix resultVector = FactoryComplexMatrix.Operations.Multiplication(noiseMatrix, stateVector);
debugger.setVectorInternal(resultVector);
}
}
public override void Evaluate(IQuantumState state)
{
if (Configuration.NoiseEnabled == false) { return; }
if (Configuration.NoiseFactor != 0)
{
IQuantumStateDebugger debugger = state.Debugger;
IComplexMatrix stateVector = debugger.getVectorInternal();
IComplexMatrix noiseVector = generateNoiseVector(stateVector.countTotalElements());
IComplexMatrix tempVector = ComplexMatrixFactory.Operations.Add(stateVector, noiseVector);
IComplexMatrix noiseMatrix = generateNoiseMatrix(tempVector.countTotalElements());
IComplexMatrix resultVector = ComplexMatrixFactory.Operations.Multiplication(noiseMatrix, stateVector);
debugger.setVectorInternal(resultVector);
}
}
public override void Evaluate(IQuantumState state)
{
if (Configuration.NoiseEnabled == false) { return; }
if (Configuration.NoiseFactor != 0)
{
IQuantumStateDebugger debugger = state.Debugger;
IComplexMatrix stateVector = debugger.getVectorInternal();
IComplexMatrix noiseMatrix = generateNoiseMatrix(stateVector.countTotalElements());
IComplexMatrix resultVector = ComplexMatrixFactory.Operations.Multiplication(noiseMatrix, stateVector);
debugger.setVectorInternal(resultVector);
if (Configuration.EffectiveLogEnabled)
{
LoggerFactory.Default.Log(ID, "stateVector", stateVector.AsString());
LoggerFactory.Default.Log(ID, "noiseMatrix", noiseMatrix.AsString());
LoggerFactory.Default.Log(ID, "resultVector", resultVector.AsString());
}
}
}
public IQuantumState Transform(IQuantumState input)
{
if (transform.Dimension > input.Dimension)
{
throw new ArgumentException(nameof(transform.Dimension));
}
var newAmps = new Complex[Dimension];
// foreach basis vector in the state
for (long i = 0; i < Dimension; i++)
{
bool[] basis = new ComputationalBasis(i, NumQubits).GetLabels();
Complex origAmp = input.GetAmplitude(basis);
// apply the subroutine to part of that basis
IQuantumState res = transform.Transform(
new MultiQubit(
applyToQubitIndexes
.Select(index => basis[index] ? Qubit.ClassicOne : Qubit.ClassicZero)
.ToArray()));
// redistribute the result to every possible basis
for (long j = 0; j < transform.Dimension; j++)
{
bool[] subRoutineBasis = new ComputationalBasis(j, transform.NumQubits).GetLabels();
Complex amp = res.GetAmplitude(subRoutineBasis);
for (int indexIndex = 0; indexIndex < transform.NumQubits; indexIndex++)
{
int qubitIndex = applyToQubitIndexes[indexIndex];
basis[qubitIndex] = subRoutineBasis[indexIndex];
}
long ampIndex = ComputationalBasis.FromLabels(basis).AmpIndex;
newAmps[ampIndex] += origAmp * amp;
}
}
// weirder
return(new MultiQubit(newAmps));
}
private double[] generateProbabilities(IQuantumState state, IQuantumBasis basis)
{
IQuantumStateDebugger stateDebugger = state.Debugger;
IQuantumBasisDebugger basisDebugger = basis.Debugger;
IComplexMatrix matrix = basisDebugger.getMatrix();
IComplexMatrix vector = stateDebugger.getVectorInternal();
IComplexMatrix limit = ComplexMatrixFactory.Operations.Multiplication(matrix, vector);
// Si el vector "limit" esta normalizado,
// la suma de todas sus componentes a la norma, deben dar 1
// ==> probablidades
IComplexMatrix normalized = ComplexMatrixFactory.Operations.Normalize(limit);
IComplexNumber[] tempComplex = normalized.extractAsArray();
int count = tempComplex.Length;
double[] result = new double[count];
for (int k = 0; k < count; k++)
{
result[k] = ComplexNumberFactory.Operations.PoweredNorm(tempComplex[k]);
}
if (Configuration.EffectiveLogEnabled)
{ LoggerFactory.Default.Log("Measurament Probabilities Distribution",ArrayTools.ExplodeArrayAsString(result)); }
return result;
//IQuantumStateDebugger debugger = state.Debugger;
//IComplexMatrix vector = debugger.getVectorNormalized();
//int count = vector.countTotalElements();
//double[] result = new double[count];
//IComplexNumber element;
//for (int i = 0; i < count; i++)
//{
// element = vector.getElement(i, 0);
// result[i] = FactoryComplexNumber.Operations.PoweredNorm(element);
//}
//DefaultLogger.Instance.Log("Measurament Probabilities Distribution"+ArrayTools.ExplodeArrayAsString(result));
//return result;
}
protected override void PropagateOnQuantumReceive(IStation station, IQuantumState state)
{
base.PropagateOnQuantumReceive(station, state);
}
protected void removeState(IQuantumState state)
{
_collection.removeObject(state);
//checkNumLevels();
}
protected void addState(IQuantumState state)
{
_collection.addObject(state);
//state.Debugger.setInternalState(this);
//checkNumLevels();
}
public IQuantumState Transform(IQuantumState input)
=> transforms.Aggregate(input, (accum, next) =>
{
return(next.Transform(accum));
});
public IQuantumState Transform(IQuantumState input) => input;
public void transmitQuantum(IProtocolAgent agent, IQuantumState state)
{
TesterLog("QUANTUM TRANSMISSION " + agent.AgentName);
TesterLog(state.generateQuantumDebugger().FullDebug);
}
public static string Print(this IQuantumState state) => state.Print(
Enumerable.Range(0, state.NumQubits())
.Select(i => new Register
{
QubitIndexes = new[] { i }
}).ToArray());
public static int NumQubits(this IQuantumState state) => (int)Math.Log(state.Dimension, 2);
public void receiveQuantum(IProtocolAgent agent, IQuantumState state)
{
TesterLog("QUANTUM RECEPTION " + agent.AgentName);
TesterLog(state.generateQuantumDebugger().FullDebug);
}
protected virtual void PropagateOnQuantumTransmit(IChannelStation station, IQuantumState state)
{
_counterTransmitedQuantum++;
if (OnQuantumTransmit != null)
{ OnQuantumTransmit(this, state); };
}
protected virtual void PropagateOnQuantumReceive(IChannelStation station, IQuantumState state)
{
_counterReceivedQuantum++;
if (OnQuantumReceive != null)
{ OnQuantumReceive(this, state); };
}
public void Send(IQuantumState state)
{
Station.QuantumTransmitSynchronous(state);
}
private void updateState(IQuantumState state, IQuantumBasis basis, int selected)
{
IQuantumState baseState = basis.getState(selected);
IComplexMatrix coefficients = baseState.generateQuantumDebugger().getVectorInternal();
state.generateQuantumDebugger().setVectorInternal(coefficients);
}
private void GENE_SlaveProcessQuantumKeyData(IProtocolAgent agent, IQuantumState state)
{
int receivedPos = AgentSlave.counterReceivedQuantum - 1;
BB84Log("BB84 GENE STEP 1", receivedPos,"Slave State Received", state.Debugger.ShortDebug);
// get the bit
IQuantumBit quantumBit = QuantumDatatypeFactory.generateBit(false);
quantumBit.AssociateState(state);
bool usedBasis = RandomnessAlgorithmFactory.GetSingleBinary();
bool decodedBit = QuantumDatatypeFactory.decodeBitByBasis(quantumBit,usedBasis);
BB84Log("BB84 GENE STEP 1", receivedPos,"Slave conversion into Bit", decodedBit.ToString());
// store 'usedBasis' and 'decodedBit'
GENE_slaveUsedBasisCollection.Add(usedBasis);
GENE_slaveDecodedBitCollection.Add(decodedBit);
}
