private static ComplexMatrix GetMatrix(int registerSize, int control1Index, int control2Index, int notIndex)
{
var matrixSize = (int)System.Math.Pow(2, registerSize);
var matrix = new ComplexMatrix(new OrderedPair(matrixSize, matrixSize));
var control1Bit = (int)System.Math.Pow(2, registerSize - control1Index - 1);
var control2Bit = (int)System.Math.Pow(2, registerSize - control2Index - 1);
var notBit = (int)System.Math.Pow(2, registerSize - notIndex - 1);
// Go through each column of the matrix and determine which row it should map to
for (var i = 0; i < matrixSize; i++)
{
// Are the control bits set to 1
if ((i & control1Bit) > 0 && (i & control2Bit) > 0)
{
// Is the not bit set to 1
if ((i & notBit) > 0)
{
matrix[i - notBit][i] = new Complex(1, 0);
}
else
{
matrix[i + notBit][i] = new Complex(1, 0);
}
}
else
{
matrix[i][i] = new Complex(1, 0);
}
}
return matrix;
}
public Qubit(Complex zero, Complex one)
{
if (zero.Modulus * zero.Modulus + one.Modulus * one.Modulus != 1)
throw new QubitException(QubitException.MOD_MESSAGE);
this.qubit = new ComplexMatrix(new Complex[][] { new Complex[] { zero }, new Complex[] { one } });
if (random == null) random = new Random();
}
public void AddQubits(Qubit[] qubits)
{
for (var i = 0; i < qubits.Length; i++)
{
this.matrix = ComplexMatrix.TensorProduct(this.matrix, qubits[i].Matrix);
this.register = new Qubit[this.register.Length + 1];
}
}
static void InvertPhase(Register register, ComplexMatrix fn)
{
register.SetQubitValue(3, true);
var gate = (new IdentityGate(3)).Combine(new HadamardGate())
.Compose(Gate.FromFunction(fn));
register.ApplyGate(gate);
}
public void ApplyGate(Gate gate)
{
this.matrix = gate.Matrix * this.matrix;
for (var i = 0; i < this.register.Length; i++)
{
this.register[i] = null;
}
}
public Register(Qubit[] qubits)
{
this.register = qubits;
this.matrix = this.register[0].Matrix;
for (var i = 1; i < this.register.Length; i++)
{
this.matrix = ComplexMatrix.TensorProduct(this.matrix, this.register[i].Matrix);
}
random = new Random();
}
private static ComplexMatrix GetMatrix(int registerSize)
{
var matrixSize = (int)System.Math.Pow(2, registerSize);
var matrix = new ComplexMatrix(new OrderedPair(matrixSize, matrixSize));
for (var i = 0; i < matrixSize; i++)
{
matrix[i][i] = new Complex(1, 0);
}
return matrix;
}
private static ComplexMatrix GetMatrix(int registerSize, int controlIndex, int flip1Index, int flip2Index)
{
var matrixSize = (int)System.Math.Pow(2, registerSize);
var matrix = new ComplexMatrix(new OrderedPair(matrixSize, matrixSize));
var controlBit = (int)System.Math.Pow(2, registerSize - controlIndex - 1);
var flip1Bit = (int)System.Math.Pow(2, registerSize - flip1Index - 1);
var flip2Bit = (int)System.Math.Pow(2, registerSize - flip2Index - 1);
// Go through each column of the matrix and determine which row it should map to
for (var i = 0; i < matrixSize; i++)
{
// Is the control bit set to 1
if ((i & controlBit) > 0)
{
// Is the first flip bit set to 1
if ((i & flip1Bit) > 0)
{
// Is the second flip bit set to 1
if ((i & flip2Bit) > 0)
{
// The flip bits are the same, so no need to flip
matrix[i][i] = new Complex(1, 0);
}
else
{
matrix[i - flip1Bit + flip2Bit][i] = new Complex(1, 0);
}
}
else
{
// Is the second flip bit set to 1
if ((i & flip2Bit) > 0)
{
matrix[i + flip1Bit - flip2Bit][i] = new Complex(1, 0);
}
else
{
// The flip bits are the same, so no need to flip
matrix[i][i] = new Complex(1, 0);
}
}
}
else
{
matrix[i][i] = new Complex(1, 0);
}
}
return matrix;
}
static void InvertAboutMean(Register register)
{
var minusIPlus2A = new ComplexMatrix(new OrderedPair(8, 8));
for (var m = 0; m < 8; m++)
{
for (var n = 0; n < 8; n++)
{
if (m == n) minusIPlus2A[m][n] = new Complex(-1 + (2 / 8), 0);
else minusIPlus2A[m][n] = new Complex(2 / 8, 0);
}
}
var gate = (new Gate(minusIPlus2A)).Combine(new IdentityGate(1));
register.ApplyGate(gate);
}
public static ComplexMatrix TensorProduct(ComplexMatrix m1, ComplexMatrix m2)
{
var size = new OrderedPair(m1.Size.M * m2.Size.M, m1.Size.N * m2.Size.N);
var result = new ComplexMatrix(size);
for (var m = 0; m < size.M; m++)
{
for (var n = 0; n < size.N; n++)
{
result[m][n] = m1[m / m2.Size.M][n / m2.Size.N] * m2[m % m2.Size.M][n % m2.Size.N];
}
}
return(result);
}
public bool Measure()
{
var zeroBit = qubit[0][0];
var prZero = zeroBit.Modulus * zeroBit.Modulus;
if (random.NextDouble() < prZero)
{
this.qubit = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(1, 0) }, new Complex[] { new Complex(0, 0) } });
return false;
}
else
{
this.qubit = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(0, 0) }, new Complex[] { new Complex(1, 0) } });
return true;
}
}
public static Gate FromFunction(ComplexMatrix function, int deadBits = 0)
{
var logM = System.Math.Round(System.Math.Log(function.Size.M, 2), 10);
var logMRound = System.Math.Round(logM);
var isMFactorOf2 = logM == logMRound;
var logN = System.Math.Round(System.Math.Log(function.Size.N, 2), 10);
var logNRound = System.Math.Round(logN);
var isNFactorOf2 = logN == logNRound;
var deadBitFactor = (int)System.Math.Pow(2, deadBits);
if (!isMFactorOf2 || !isNFactorOf2)
throw new GateConstraintException(GateConstraintException.FUNCTION_MESSAGE);
var matrix = new ComplexMatrix(
new OrderedPair(function.Size.N * function.Size.M * deadBitFactor, function.Size.N * function.Size.M * deadBitFactor));
for (var input = 0; input < function.Size.N; input++)
{
var inputMatrix = new ComplexMatrix(new OrderedPair(function.Size.N, 1));
inputMatrix[input][0] = new Complex(1, 0);
var fnOutput = function * inputMatrix;
var inputBits = input * function.Size.M * deadBitFactor;
for (var control = 0; control < function.Size.M; control++)
{
for (var output = 0; output < fnOutput.Size.M; output++)
{
for (var d = 0; d < deadBitFactor; d++)
{
matrix[inputBits + (2 * d) + (output ^ control)][inputBits + (2 * d) + control] =
fnOutput[output][0];
}
}
}
}
return new Gate(matrix);
}
public static ComplexMatrix operator *(ComplexMatrix m1, ComplexMatrix m2)
{
if (m1.Size.N != m2.Size.M)
{
throw new MatrixSizeException(MatrixSizeException.MULTIPLICATION_MESSAGE);
}
var result = new ComplexMatrix(new OrderedPair(m1.Size.M, m2.Size.N));
for (var m = 0; m < m1.Size.M; m++)
{
for (var n = 0; n < m2.Size.N; n++)
{
for (var i = 0; i < m1.Size.N; i++)
{
result[m][n] += m1[m][i] * m2[i][n];
}
}
}
return(result);
}
public void MatrixScalarMultiplication()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(9, 19), new Complex(-2, -10), new Complex(-9, 7), new Complex(5, 12) },
new Complex[] { new Complex(11, 29), new Complex(-16, -2), new Complex(12, 21), new Complex(24, 3) },
new Complex[] { new Complex(-19, 9), new Complex(31, 12), new Complex(3, 2), new Complex(6, -9) }
});
var result = m2.ScalarProduct(c9);
Assert.AreEqual(expected, result);
}
public static Complex InnerProduct(ComplexMatrix m1, ComplexMatrix m2)
{
return (m1.Adjoint * m2).Trace;
}
public static ComplexMatrix operator *(ComplexMatrix m1, ComplexMatrix m2)
{
if (m1.Size.N != m2.Size.M)
throw new MatrixSizeException(MatrixSizeException.MULTIPLICATION_MESSAGE);
var result = new ComplexMatrix(new OrderedPair(m1.Size.M, m2.Size.N));
for (var m = 0; m < m1.Size.M; m++)
{
for (var n = 0; n < m2.Size.N; n++)
{
for (var i = 0; i < m1.Size.N; i++)
{
result[m][n] += m1[m][i] * m2[i][n];
}
}
}
return result;
}
public void MatrixAddition()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(7, 6), new Complex(2, -3), new Complex(2, 1), new Complex(8, -2) },
new Complex[] { new Complex(10, 4), new Complex(-3, 6), new Complex(4, 4), new Complex(7, -4) },
new Complex[] { new Complex(-2, 6), new Complex(17, 1), new Complex(4, 2), new Complex(-4, -1) }
});
var result = m1 + m2;
Assert.AreEqual(expected, result);
}
public static ComplexMatrix TensorProduct(ComplexMatrix m1, ComplexMatrix m2)
{
var size = new OrderedPair(m1.Size.M * m2.Size.M, m1.Size.N * m2.Size.N);
var result = new ComplexMatrix(size);
for (var m = 0; m < size.M; m++)
{
for (var n = 0; n < size.N; n++)
{
result[m][n] = m1[m / m2.Size.M][n / m2.Size.N] * m2[m % m2.Size.M][n % m2.Size.N];
}
}
return result;
}
static void Main(string[] args)
{
//var deutschMatrix = new ComplexMatrix(new Complex[][] {
// new Complex[] { new Complex(1, 0), new Complex(1, 0) },
// new Complex[] { new Complex(0, 0), new Complex(0, 0) }
//});
//var gate = ((new HadamardGate()).Combine(new HadamardGate()))
// .Compose(Gate.FromFunction(deutschMatrix))
// .Compose((new HadamardGate()).Combine(new IdentityGate(1)));
//var register = new Register(new Qubit[] { new Qubit(false), new Qubit(true) });
//register.ApplyGate(gate);
//var result = register.Measure(0) ? "Balanced" : "Constant";
//Console.WriteLine(deutschMatrix);
//Console.WriteLine(result);
//Console.WriteLine();
//var deutschJozsaMatrix = new ComplexMatrix(new Complex[][] {
// new Complex[] { new Complex(0, 0), new Complex(1, 0), new Complex(0, 0), new Complex(1, 0), new Complex(0, 0), new Complex(1, 0), new Complex(0, 0), new Complex(1, 0) },
// new Complex[] { new Complex(1, 0), new Complex(0, 0), new Complex(1, 0), new Complex(0, 0), new Complex(1, 0), new Complex(0, 0), new Complex(1, 0), new Complex(0, 0) }
//});
//var gate = ((new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()))
// .Compose(Gate.FromFunction(deutschJozsaMatrix))
// .Compose((new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new IdentityGate(1)));
//var register = new Register(new Qubit[] { new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(true) });
//register.ApplyGate(gate);
//var bitArray = register.Measure();
//var topBits = 0;
//topBits += bitArray[0] ? 4 : 0;
//topBits += bitArray[1] ? 2 : 0;
//topBits += bitArray[2] ? 1 : 0;
//var result = "Constant";
//if (topBits != 0) result = "Balanced";
//Console.WriteLine(deutschJozsaMatrix);
//Console.WriteLine(topBits);
//Console.WriteLine(result);
//Console.WriteLine();
var needle = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(1, 0), new Complex(1, 0), new Complex(1, 0), new Complex(1, 0), new Complex(1, 0), new Complex(1, 0), new Complex(0, 0), new Complex(1, 0) },
new Complex[] { new Complex(0, 0), new Complex(0, 0), new Complex(0, 0), new Complex(0, 0), new Complex(0, 0), new Complex(0, 0), new Complex(1, 0), new Complex(0, 0) }
});
var register = new Register(new Qubit[] { new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(true), new Qubit(true), new Qubit(true) });
var superpose = (new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new IdentityGate(3));
register.ApplyGate(superpose);
// Invert phase, invert about mean Sqrt(2^N) times (N = 3)
var minusIPlus2A = new ComplexMatrix(new OrderedPair(8, 8));
for (var m = 0; m < 8; m++)
{
for (var n = 0; n < 8; n++)
{
if (m == n) minusIPlus2A[m][n] = new Complex(-1 + (2 / 8), 0);
else minusIPlus2A[m][n] = new Complex(2 / 8, 0);
}
}
var phaseInvertGate = (new IdentityGate(3)).Combine(new HadamardGate()).Combine(new IdentityGate(2))
.Compose((Gate.FromFunction(needle)).Combine(new IdentityGate(2)));
register.ApplyGate(phaseInvertGate);
var invertAboutMeanGate = (new Gate(minusIPlus2A)).Combine(new IdentityGate(3));
register.ApplyGate(invertAboutMeanGate);
phaseInvertGate = (new IdentityGate(4)).Combine(new HadamardGate()).Combine(new IdentityGate(1))
.Compose((Gate.FromFunction(needle, 1)).Combine(new IdentityGate(1)));
register.ApplyGate(phaseInvertGate);
invertAboutMeanGate = (new Gate(minusIPlus2A)).Combine(new IdentityGate(3));
register.ApplyGate(invertAboutMeanGate);
phaseInvertGate = (new IdentityGate(5)).Combine(new HadamardGate())
.Compose((Gate.FromFunction(needle, 2)));
register.ApplyGate(phaseInvertGate);
invertAboutMeanGate = (new Gate(minusIPlus2A)).Combine(new IdentityGate(3));
register.ApplyGate(invertAboutMeanGate);
var result = register.Measure();
//var modFn = new ComplexMatrix(new OrderedPair(4, 16));
//var a = 3;
//for (var x = 0; x < modFn.Size.N; x++)
//{
// modFn[(int)System.Math.Pow(a, x) % 4][x] = new Complex(1, 0);
//}
//var register = new Register(new Qubit[] { new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false) });
//var gate = ((new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new IdentityGate(2)))
// .Compose(Gate.FromFunction(modFn));
//var modResult = 0;
//register.ApplyGate(gate);
//modResult += register.Measure(4) ? 2 : 0;
//modResult += register.Measure(5) ? 1 : 0;
//var unity = new Complex(1, 0);
//var mthRoot = unity.Root(16)[15];
//var fourier = new ComplexMatrix(new OrderedPair(16, 16));
//for (var i = 0; i < 16; i++)
//{
// for (var j = 0; j < 16; j++)
// {
// if (i == 0 || j == 0) fourier[i][j] = new Complex(1, 0) / 4;
// else fourier[i][j] = mthRoot.Pow(i * j) / 4;
// }
//}
//var fourierGate = (new Gate(fourier)).Combine(new IdentityGate(2));
//register.ApplyGate(fourierGate);
//var measurement = register.Measure();
//var result = 0;
//result += measurement[3] ? 1 : 0;
//result += measurement[2] ? 2 : 0;
//result += measurement[1] ? 4 : 0;
//result += measurement[0] ? 8 : 0;
//var modFn = new ComplexMatrix(new OrderedPair(8, 64));
//var a = 3;
//for (var x = 0; x < modFn.Size.N; x++)
//{
// var mod = (int)System.Math.Pow(a, x) % 6;
// if (mod < 0) mod += 6;
// modFn[mod][x] = new Complex(1, 0);
//}
//var register = new Register(new Qubit[] { new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false), new Qubit(false) });
//var gate = ((new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new HadamardGate()).Combine(new IdentityGate(3)))
// .Compose(Gate.FromFunction(modFn));
//var modResult = 0;
//register.ApplyGate(gate);
//modResult += register.Measure(6) ? 4 : 0;
//modResult += register.Measure(7) ? 2 : 0;
//modResult += register.Measure(8) ? 1 : 0;
//var unity = new Complex(1, 0);
//var mthRoot = unity.Root(64)[63];
//var fourier = new ComplexMatrix(new OrderedPair(64, 64));
//for (var i = 0; i < 64; i++)
//{
// for (var j = 0; j < 64; j++)
// {
// if (i == 0 || j == 0) fourier[i][j] = new Complex(1, 0) / 8;
// else fourier[i][j] = mthRoot.Pow(i * j) / 8;
// }
//}
//var fourierGate = (new Gate(fourier)).Combine(new IdentityGate(3));
//register.ApplyGate(fourierGate);
//var measurement = register.Measure();
//var result = 0;
//result += measurement[5] ? 1 : 0;
//result += measurement[4] ? 2 : 0;
//result += measurement[3] ? 4 : 0;
//result += measurement[2] ? 8 : 0;
//result += measurement[1] ? 16 : 0;
//result += measurement[0] ? 32 : 0;
//var divisor = 16; // x / 2^m = lambda / period (r)
//var period = divisor / GCD(result, divisor);
//var potentialFactor1 = GCD((int)System.Math.Pow(3, period) - 1, 4);
//var potentialFactor2 = GCD((int)System.Math.Pow(3, period) + 1, 4);
Console.Write("Press enter to exit.");
Console.ReadLine();
}
public void MatrixConjugate()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(5, -3), new Complex(-2, 2), new Complex(-1, -3), new Complex(3, -2) },
new Complex[] { new Complex(7, -5), new Complex(-4, -2), new Complex(6, -3), new Complex(6, 3) },
new Complex[] { new Complex(-3, -5), new Complex(9, 2), new Complex(1, 0), new Complex(0, 3) }
});
var result = m2.Conjugate;
Assert.AreEqual(expected, result);
}
public void MatrixInverse()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(-2, -3), new Complex(-4, 1), new Complex(-3, 2), new Complex(-5, 4) },
new Complex[] { new Complex(-3, 1), new Complex(-1, -4), new Complex(2, -1), new Complex(-1, 1) },
new Complex[] { new Complex(-1, -1), new Complex(-8, -3), new Complex(-3, -2), new Complex(4, -2) }
});
var result = m1.Inverse;
Assert.AreEqual(expected, result);
}
public void MatrixTranspose()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(5, 3), new Complex(7, 5), new Complex(-3, 5) },
new Complex[] { new Complex(-2, -2), new Complex(-4, 2), new Complex(9, -2) },
new Complex[] { new Complex(-1, 3), new Complex(6, 3), new Complex(1, 0) },
new Complex[] { new Complex(3, 2), new Complex(6, -3), new Complex(0, -3) }
});
var result = m2.Transpose;
Assert.AreEqual(expected, result);
}
public void MatrixMultiplication()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(6, 43), new Complex(56, -27), new Complex(-20, 16) },
new Complex[] { new Complex(94, 48), new Complex(34, -72), new Complex(11, 56) },
new Complex[] { new Complex(52, -11), new Complex(11, 64), new Complex(2, -37) }
});
var result = m2 * m3;
Assert.AreEqual(expected, result);
}
public static Complex InnerProduct(ComplexMatrix m1, ComplexMatrix m2)
{
return((m1.Adjoint * m2).Trace);
}
public void MatrixSubtraction()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(-3, 0), new Complex(6, 1), new Complex(4, -5), new Complex(2, -6) },
new Complex[] { new Complex(-4, -6), new Complex(5, 2), new Complex(-8, -2), new Complex(-5, 2) },
new Complex[] { new Complex(4, -4), new Complex(-1, 5), new Complex(2, 2), new Complex(-4, 5) }
});
var result = m1 - m2;
Assert.AreEqual(expected, result);
}
public void MatrixTensorProduct()
{
var expected = new ComplexMatrix(new Complex[][] {
new Complex[] { new Complex(0, 0), new Complex(0, 0), new Complex(-7, 9), new Complex(4, 19) },
new Complex[] { new Complex(0, 0), new Complex(0, 0), new Complex(-10, -2), new Complex(9, 7) },
new Complex[] { new Complex(-7, 9), new Complex(4, 19), new Complex(-12, 4), new Complex(-8, 20) },
new Complex[] { new Complex(-10, -2), new Complex(9, 7), new Complex(-8, -8), new Complex(4, 12) }
});
Assert.AreEqual(expected, ComplexMatrix.TensorProduct(m6, m8));
}
public Gate(ComplexMatrix matrix)
{
if (!matrix.IsUnitary) throw new GateConstraintException(GateConstraintException.UNITARY_MESSAGE);
this.matrix = matrix;
}
