static public void TestMethod()
{
var matrixArray = new Matrix[2];
Complex[,] array0 = { { 0.5, 0.5 },
{ 0.5, 0.5 } };
matrixArray[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 = { { 0.5, -0.5 },
{ -0.5, 0.5 } };
matrixArray[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var measureMatrixH = new MeasureMatrixH(matrixArray);
Console.WriteLine("Measurement matrix 0");
Console.WriteLine(measureMatrixH.Value[0].ToComplexString());
Console.WriteLine("Measurement matrix 1");
Console.WriteLine(measureMatrixH.Value[1].ToComplexString());
int count_0 = 0, count_1 = 0;
for (var i = 0; i < 100000; i++)
{
var pureDensityOperator = new DensityOperator(new QBit(false), new QBitBra(false));
switch (pureDensityOperator.MeasuHResultIndex(measureMatrixH))
{
case 0:
count_0++;
break;
case 1:
count_1++;
break;
}
}
Console.WriteLine($"count_0 = {count_0}");
Console.WriteLine($"count_1 = {count_1}");
}
static public void TestMethod()
{
var matrixArray = new Matrix[2];
Complex[,] array0 = { { 1, 0 },
{ 0, 0 } };
matrixArray[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 = { { 0, 0 },
{ 0, 1 } };
matrixArray[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var superOperator = new SuperOperator(matrixArray);
Complex[,] array2 = { { 0.5, 0.5 },
{ 0.5, 0.5 } };
var pureDensityOperator = new DensityOperator((Matrix)Matrix.Build.DenseOfArray(array2));
SuperMatrixTrans(pureDensityOperator, superOperator);
Console.WriteLine($"pureDensityOperator = {pureDensityOperator.Value.ToComplexString()}");
}
static public void TestMethodUnitary2(int loopCount)
{
int count;
var countNumber = new SortedDictionary <int, int>();
//array2 is a pure state |+><+|
Complex[,] array2 = { { 0.5, 0.5 },
{ 0.5, 0.5 } }; //can be concentrated to assembly
for (var i = 0; i < loopCount; i++)
{
var rou = new DensityOperator((Matrix)Matrix.Build.DenseOfArray(array2));
count = 0;
rou.UnitaryTransH(HGate.Value);
qwhile(rou, MeasureMatrixZeroOne, 1,
() =>
{
rou.UnitaryTransH(HGate.Value);
count++;
if (count > 1000)
{
return(CWHILEFLOW.BREAK);
}
return(CWHILEFLOW.CONTINUE);
}
);
if (countNumber.ContainsKey(count))
{
countNumber[count]++;
}
else
{
countNumber[count] = 1;
}
}
foreach (var pair in countNumber)
{
Console.WriteLine($"{pair.Key} is {pair.Value}");
}
}
static public int TestMethod(int totalLength, int sampleLength)
{
//初始化部分，zeroOneMeasure是个MeasureMatrixH类型，里面有两个元素{1 0;0 0}, {0 0;0 1}
//plusminusMeasure是个MeasureMatrixH类型，里面有两个元素{1/2 1/2;1/2 1/2}, {1/2 -1/2;-1/2 1/2}
var matrixArray0 = new Matrix[2];
Complex[,] array0 =
{
{ 1, 0 },
{ 0, 0 }
};
matrixArray0[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 =
{
{ 0, 0 },
{ 0, 1 }
};
matrixArray0[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var zeroOneMeasure = new MeasureMatrixH(matrixArray0);
var matrixArray1 = new Matrix[2];
Complex[,] array2 =
{
{ 0.5, 0.5 },
{ 0.5, 0.5 }
};
matrixArray1[0] = (Matrix)Matrix.Build.DenseOfArray(array2);
Complex[,] array3 =
{
{ 0.5, -0.5 },
{ -0.5, 0.5 }
};
matrixArray1[1] = (Matrix)Matrix.Build.DenseOfArray(array3);
var plusminusMeasure = new MeasureMatrixH(matrixArray1);
//-------------Alice----------------------
//Debug Console.Write("Input Array Length:");
//Debug var arrayLengthStr = Console.ReadLine();
int arrayLength = totalLength;
//-------------------------check length----------------
int checkLengthPercent = sampleLength;
var RandomGen = new CryptoRandomSource();
//生成一个rawKeyArray[10],是bool数组类型,每一个item,从0,1这两个中选择
//Produce raw key array 0,1
var rawKeyArray = new byte[arrayLength];
//生成一个basisRawArray[10]，是bool数组类型,每一个item,从0,1这两个中选择
//0表示0,1基，1表示{+,-}基
var basisRawArray = new byte[arrayLength];
//生成一个ketEncArray[10]是ket数组类型.每一位由rawKeyArray和basisRawArray共同决定。
//if basisRawArray里面的值是0，rawKeyArray里面的值是0，则 ketEncArray里面的值是ket(0)
//if basisRawArray里面的值是0，rawKeyArray里面的值是1，则 ketEncArray里面的值是ket(1)
// if basisRawArray里面的值是1，rawKeyArray里面的值是0，则 ketEncArray里面的值是ket(1/Sqrt(2),1/Sqrt(2))
// if basisRawArray里面的值是1，rawKeyArray里面的值是1，则 ketEncArray里面的值是ket(1/Sqrt(2),-1/Sqrt(2))
var ketEncArray = new Ket[arrayLength];
var complexArray = new Complex[2];
for (var i = 0; i < arrayLength; i++)
{
rawKeyArray[i] = (byte)RandomGen.Next(2);
basisRawArray[i] = (byte)RandomGen.Next(2);
if (basisRawArray[i] == 0 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1, 0);
complexArray[1] = new Complex(0, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 0 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(0, 0);
complexArray[1] = new Complex(1, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(-1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
}
// -----------alice end---------------------
////--------------Quantum Channel begins, ignoring EVE ----------
var densityopEncArray = new DensityOperator[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
densityopEncArray[i] = new DensityOperator(ketEncArray[i], new Bra(ketEncArray[i]));
}
QuantumChannelProcess(densityopEncArray);
//---------------Quantum Channel End-------Eve end---------------------
//---------------------Bob begin--------------------
//Bob 生成一个measureRawArray，是bool数组类型随机{0,1}------------
var measureRawArray = new byte[arrayLength];
//生成结果数组 resultMeasureArray,是bool数组类型，其中的值由 measureRawArray和 densityopEncArray共同决定
// foreach item in densityopEncArray
//if measureRawArray[index]=0则用 zeroOneMeasure 作为调用的参数传递到 densityopEncArray的本位,ket[index].MeasuHResultIndex(zeroOneMeasure )
//if measureRawArray[index]=1则用 plusminusMeasure 作为调用的参数传递到 densityopEncArray的本位,ket[index].MeasuHResultIndex(plusminusMeasure )
var resultMeasureArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
measureRawArray[i] = (byte)RandomGen.Next(2);
if (measureRawArray[i] == 0)
{
if (densityopEncArray[i].MeasuHResultIndex(zeroOneMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
else
{
if (densityopEncArray[i].MeasuHResultIndex(plusminusMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
}
// ---------------------Bob end--------------------
//--------------公共信道广播不做--------
//--------------公共信道结束----------
// --------------ALice begin---------------
//生成应答数组,correctBroadArray,bool数组类型。
//foreach item in measureRawArray
//if measureRawArray[index]== basisRawArray[index], correctBroadArray[index]==1. else correctBroadArray[index]==0
var correctBroadArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
if (measureRawArray[i] == basisRawArray[i])
{
correctBroadArray[i] = 1;
}
}
// 生成finalAliceKey数组是bool数组类型，
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(rawKeyArray[index]),即把 correctBroadArray[index]==1的那些位置的 rawKeyArray[index]取出来放一起finalAliceKey。
var finalAliceKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalAliceKeyList.Add(rawKeyArray[i]);
}
}
var finalAliceKey = finalAliceKeyList.ToArray();
//------------Alice end--------------------
//------------公共信道开始-----------------------
//-----------公共信道结束------------------------
//--------------Bob开始-------------------------
//生成finalBobKey数组是bool数组类型
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(resultMeasureArray[index]),即把 correctBroadArray[index]==1的那些位置的 resultMeasureArray[index]取出来放一起存到finalBobKey。
var finalBobKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalBobKeyList.Add(resultMeasureArray[i]);
}
}
var finalBobKey = finalBobKeyList.ToArray();
//----------------Bob结束----------------------
//Check start
//Check the alice and bob's length is equal
var check = true;
if (finalAliceKey.Length != finalBobKey.Length)
{
check = false;
}
if (check)
{
// Console.WriteLine("Length: Success");
}
else
{
//Console.WriteLine("Length: Failed");
}
//Sampling start
var samplingLength = (checkLengthPercent * finalAliceKey.Length) / 100;
//Console.WriteLine($"Sampling {samplingLength} bits");
var samplingAliceKey = new List <byte>(finalAliceKey);
var samplingBobKey = new List <byte>(finalBobKey);
var samplingAliceKeySample = new List <byte>();
var samplingBobKeySample = new List <byte>();
for (var i = 0; i < samplingLength; i++)
{
var position = RandomGen.Next(samplingAliceKey.Count); //shuffle here, sample from agreement key and then delete it
samplingAliceKeySample.Add(samplingAliceKey[position]);
samplingAliceKey.RemoveAt(position);
samplingBobKeySample.Add(samplingBobKey[position]);
samplingBobKey.RemoveAt(position);
}
for (var i = 0; i < samplingLength; i++)
{
if (samplingAliceKeySample[i] != samplingBobKeySample[i])
{
check = false;
}
}
if (check)
{
//Console.WriteLine("Sampling process: Success");
return(1); //Add success times here
}
else
{
//Console.WriteLine("Sampling process: Failed");
return(0);
}
}
static public void TestMethod()
{
//Initilization，zeroOneMeasureis a MeasureMatrixH class. {1 0;0 0}, {0 0;0 1}
//plusminusMeasure is MeasureMatrixH class，{1/2 1/2;1/2 1/2}, {1/2 -1/2;-1/2 1/2}
var matrixArray0 = new Matrix[2];
Complex[,] array0 =
{
{ 1, 0 },
{ 0, 0 }
};
matrixArray0[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 =
{
{ 0, 0 },
{ 0, 1 }
};
matrixArray0[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var zeroOneMeasure = new MeasureMatrixH(matrixArray0);
var matrixArray1 = new Matrix[2];
Complex[,] array2 =
{
{ 0.5, 0.5 },
{ 0.5, 0.5 }
};
matrixArray1[0] = (Matrix)Matrix.Build.DenseOfArray(array2);
Complex[,] array3 =
{
{ 0.5, -0.5 },
{ -0.5, 0.5 }
};
matrixArray1[1] = (Matrix)Matrix.Build.DenseOfArray(array3);
var plusminusMeasure = new MeasureMatrixH(matrixArray1);
//-------------Alice----------------------
Console.Write("Input Array Length:");
var arrayLengthStr = Console.ReadLine();
int arrayLength;
if (!int.TryParse(arrayLengthStr, out arrayLength))
{
Console.WriteLine("Must input integer, use default(10)");
arrayLength = 10;
}
var RandomGen = new CryptoRandomSource();
//Produce raw key array 0,1
var rawKeyArray = new byte[arrayLength];
//0 is {|0>,|1>}，1 is {|+>,|->} basis.
var basisRawArray = new byte[arrayLength];
//Every KetEncArray is decided by rawKeyArray and basisRawArray
//if basisRawArray is 0，rawKeyArray is 0，then ketEncArray is ket(0)
//if basisRawArray is 0，rawKeyArray is 1，then ketEncArray is ket(1)
// if basisRawArray is 1，rawKeyArray is 0，then ketEncArray is ket(1/Sqrt(2),1/Sqrt(2))
// if basisRawArray is 1，rawKeyArray is 1，then ketEncArray ket(1/Sqrt(2),-1/Sqrt(2))
var ketEncArray = new Ket[arrayLength];
var complexArray = new Complex[2];
for (var i = 0; i < arrayLength; i++)
{
rawKeyArray[i] = (byte)RandomGen.Next(2);
basisRawArray[i] = (byte)RandomGen.Next(2);
if (basisRawArray[i] == 0 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1, 0);
complexArray[1] = new Complex(0, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 0 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(0, 0);
complexArray[1] = new Complex(1, 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 0)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
else if (basisRawArray[i] == 1 && rawKeyArray[i] == 1)
{
complexArray[0] = new Complex(1 / Sqrt(2), 0);
complexArray[1] = new Complex(-1 / Sqrt(2), 0);
ketEncArray[i] = new Ket(complexArray);
}
}
// -----------alice end---------------------
////--------------Quantum Channel begins, ignoring EVE ----------
var densityopEncArray = new DensityOperator[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
densityopEncArray[i] = new DensityOperator(ketEncArray[i], new Bra(ketEncArray[i]));
}
QuantumChannelProcess(densityopEncArray);
//---------------Quantum Channel End-------Eve end---------------------
//---------------------Bob begin--------------------
//Bob produces measureRawArray，randomly {0,1}------------
var measureRawArray = new byte[arrayLength];
// resultMeasureArray is bool array. The value is decided by measureRawArray and ketEncArray.
// foreach item in ketEncArray
//if measureRawArray[index]=0 then zeroOneMeasure would be transferred to ketEncArray ,ket[index].MeasuHResultIndex(zeroOneMeasure )
//if measureRawArray[index]=1 then plusminusMeasure would be transferred to ketEncArray,ket[index].MeasuHResultIndex(plusminusMeasure )
var resultMeasureArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
measureRawArray[i] = (byte)RandomGen.Next(2);
if (measureRawArray[i] == 0)
{
if (densityopEncArray[i].MeasuHResultIndex(zeroOneMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
else
{
if (densityopEncArray[i].MeasuHResultIndex(plusminusMeasure) != 0)
{
resultMeasureArray[i] = 1;
}
}
}
// ---------------------Bob end--------------------
// --------------ALice begin---------------
//Produce answer array,correctBroadArray,bool array class.
//foreach item in measureRawArray
//if measureRawArray[index]== basisRawArray[index], correctBroadArray[index]==1. else correctBroadArray[index]==0
var correctBroadArray = new byte[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
if (measureRawArray[i] == basisRawArray[i])
{
correctBroadArray[i] = 1;
}
}
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(rawKeyArray[index]),i.e. correctBroadArray[index]==1 position rawKeyArray[index]is taken out and storage into finalAliceKey.
var finalAliceKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalAliceKeyList.Add(rawKeyArray[i]);
}
}
var finalAliceKey = finalAliceKeyList.ToArray();
//------------Alice end--------------------
//--------------Bob begins-------------------------
//Produce finalBobKey array is bool array
// foreach item in correctBroadArray
// if correctBroadArray[index]==1 , push(resultMeasureArray[index]),i.e. correctBroadArray[index]==1 position, resultMeasureArray[index] is taken out and storage into finalBobKey.
var finalBobKeyList = new List <byte>();
for (var i = 0; i < arrayLength; i++)
{
if (correctBroadArray[i] != 0)
{
finalBobKeyList.Add(resultMeasureArray[i]);
}
}
var finalBobKey = finalBobKeyList.ToArray();
//----------------Bob END----------------------
//Check Begin
//check finalAliceKey is equal to finalBobKey
bool check = true;
if (finalAliceKey.Length != finalBobKey.Length)
{
check = false;
}
for (var i = 0; i < finalAliceKey.Length; i++)
{
if (finalAliceKey[i] != finalBobKey[i])
{
check = false;
}
}
//if (check)
//{
// Console.WriteLine("Success");
//}
//else
//{
// Console.WriteLine("Failed");
//}
////check end
Console.WriteLine($"zeroOneMeasure:\n{zeroOneMeasure.Value[0].ToComplexString()}\n{zeroOneMeasure.Value[1].ToComplexString()}");
Console.WriteLine($"plusMinusMeasure:\n{plusminusMeasure.Value[0].ToComplexString()}\n{plusminusMeasure.Value[1].ToComplexString()}");
Console.Write("rawKeyArray\t");
foreach (var b in rawKeyArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("basisRawArray\t");
foreach (var b in basisRawArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.WriteLine();
Console.Write("measureRawArray\t\t");
foreach (var b in measureRawArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("resultMeasureArray\t");
foreach (var b in resultMeasureArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("correctBroadArray\t");
foreach (var b in correctBroadArray)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("finalAliceKey\t\t");
foreach (var b in finalAliceKey)
{
Console.Write(b);
}
Console.WriteLine();
Console.Write("finalBobKey\t\t");
foreach (var b in finalBobKey)
{
Console.Write(b);
}
if (check)
{
Console.WriteLine("\nThe protocol: Success");
}
else
{
Console.WriteLine("\nThe protocol: Failed");
}
//check end
Console.WriteLine();
}
static public void TestMethod(int loopCount)
{
// E0,E1 for Kraus Opearator
// E0= (|0><0| + |1><1|)/sqrt(2),E1= (|0><1|)/sqrt(2)
var matrixArrayE = new Matrix[2];
Complex[,] array0 = { { 1, 0 },
{ 0, 1 / Sqrt(2) } };
matrixArrayE[0] = (Matrix)Matrix.Build.DenseOfArray(array0);
Complex[,] array1 = { { 0, 1 / Sqrt(2) },
{ 0, 0 } };
matrixArrayE[1] = (Matrix)Matrix.Build.DenseOfArray(array1);
var superE = new SuperOperator(matrixArrayE);
//rou for main state, it is a pure state|+><+|
Complex[,] array2 = { { 0.5, 0.5 },
{ 0.5, 0.5 } };
//var pureDensityOperator = new PureDensityOperator((Matrix)Matrix.Build.DenseOfArray(array2));
int count;
var countNumber = new SortedDictionary <int, int>();
for (var i = 0; i < loopCount; i++)
{
var rou = new DensityOperator((Matrix)Matrix.Build.DenseOfArray(array2));
count = 0;
SuperMatrixTrans(rou, superE);
qwhile(rou, MeasureMatrixZeroOne, 1,
() =>
{
rou.UnitaryTransH(HGate.Value);
count++;
if (count > 1000)
{
return(CWHILEFLOW.BREAK);
}
return(CWHILEFLOW.CONTINUE);
}
);
if (countNumber.ContainsKey(count))
{
countNumber[count]++;
}
else
{
countNumber[count] = 1;
}
}
foreach (var pair in countNumber)
{
Console.WriteLine($"{pair.Key} is {pair.Value}");
}
// Console.WriteLine($"pureDensityOperator = {rou.Value}");
}
