// Checks only signed, windowed point addition for which there are fixed parameters.
public static void EstimateFixedEllipticCurveArithmetic(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
var localControl = isControlled;
var localGates = allGates;
Thread fixedThread = new Thread(() => BasicResourceTest <FixedEllipticCurveSignedWindowedPointAdditionEstimator>(
FixedEllipticCurveSignedWindowedPointAdditionEstimator.Run,
testSizes,
false,
directory + "Fixed-modulus-signed",
localGates,
true));
fixedThread.Start();
allGates = !allGates;
}
}
public static void EstimateLookup(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
for (int i = 0; i < 2; i++)
{
var localControl = isControlled;
var localGates = allGates;
Thread lookupThread = new Thread(() => BasicResourceTest <LookUpEstimator>(
LookUpEstimator.Run,
testSizes,
localControl,
directory + "Lookup",
localGates,
true));
lookupThread.Start();
isControlled = !isControlled;
}
allGates = !allGates;
}
}
// Estimates how large an optimal window should be, by iterating through
// all possible window sizes and checking total cost.
// This is an extremely costly estimate to run.
public static void EstimatePointAdditionWindowSizes(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
// Guesses
int[] minWindowSizes = { 14, 15, 15, 15, 16, 16, 16 };
int[] maxWindowSizes = { 18, 18, 18, 18, 20, 20, 20 };
System.IO.Directory.CreateDirectory(directory);
bool allGates = false;
bool isControlled = false;
var localControl = isControlled;
var localGates = allGates;
Thread lowWidthThread = new Thread(() => ParameterizedResourceTest <EllipticCurveWindowedPointAdditionLowWidthWindowTest>(
EllipticCurveWindowedPointAdditionLowWidthWindowTest.Run,
testSizes,
localControl,
true,
true,
directory + "Point-addition-windowed-low-width",
localGates,
minWindowSizes,
maxWindowSizes));
lowWidthThread.Start();
Thread highWidthThread = new Thread(() => ParameterizedResourceTest <EllipticCurveWindowedPointAdditionWindowTest>(
EllipticCurveWindowedPointAdditionWindowTest.Run,
testSizes,
localControl,
true,
true,
directory + "Point-addition-windowed",
localGates,
minWindowSizes,
maxWindowSizes));
highWidthThread.Start();
Thread signedThread = new Thread(() => ParameterizedResourceTest <EllipticCurveSignedWindowedPointAdditionWindowTest>(
EllipticCurveSignedWindowedPointAdditionWindowTest.Run,
testSizes,
localControl,
true,
true,
directory + "Point-addition-windowed-signed",
localGates,
minWindowSizes,
maxWindowSizes));
signedThread.Start();
}
// Estimates window sizes for modular arithmetic
// See ReadMe
public static void EstimateModularMultiplicationWindowSizes(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
// Construct window size maximum and minimum values
// Idea: Minimum value is 0 (no windowing), maximum value is the full
// size, or a value which is too large to reasonably simulate
int[] minWindowSizes = new int[testSizes.Length];
int[] maxWindowSizes = new int[testSizes.Length];
for (int i = 0; i < testSizes.Length; i++)
{
minWindowSizes[i] = 0;
maxWindowSizes[i] = Math.Min(testSizes[i], 23); // 2^23 should take about 2 hours
}
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
for (int i = 0; i < 2; i++)
{
var localControl = isControlled;
var localGates = allGates;
Thread multiplyThread = new Thread(() => ParameterizedResourceTestSingleThreaded <MontgomeryWindowedMultiplicationWindowTest>(
MontgomeryWindowedMultiplicationWindowTest.Run,
testSizes,
localControl,
false,
directory + "Modular-multiplication-windowed",
localGates,
minWindowSizes,
maxWindowSizes));
multiplyThread.Start();
isControlled = !isControlled;
}
allGates = !allGates;
}
}
// Estimates cost to look up points for a number of window sizes
// if the points have a specific bitlength.
public static void EstimatePointLookups(int[] testSizes, string directory)
{
var maxWindowSize = 10;
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
// Construct window size maximum and minimum values
// Idea: Minimum value is 1, maximum value is the full
// size, or a value which is too large to reasonably simulate
int[] minWindowSizes = new int[testSizes.Length];
int[] maxWindowSizes = new int[testSizes.Length];
for (int i = 0; i < testSizes.Length; i++)
{
minWindowSizes[i] = 1;
maxWindowSizes[i] = Math.Min(testSizes[i], maxWindowSize); // 2^23 should take about 2 hours
}
System.IO.Directory.CreateDirectory(directory);
// Loops over whether it counts all all-gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
// Creates a new thread for each operation being estimated
var localControl = isControlled;
var localGates = allGates;
Thread lookupThread = new Thread(() => ParameterizedResourceTest <PointLookUpEstimator>(
PointLookUpEstimator.Run,
testSizes,
localControl,
false,
true,
directory + "Point-lookup",
localGates,
minWindowSizes,
maxWindowSizes));
lookupThread.Start();
allGates = !allGates;
}
}
// Estimates modular addition-like operations, which can be reasonable
// estimated for bit sizes over 500
public static void EstimateCheapModularArithmetic(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
for (int i = 0; i < 2; i++)
{
var localControl = isControlled;
var localGates = allGates;
Thread doubleThread = new Thread(() => BasicResourceTest <ModularDblEstimator>(
ModularDblEstimator.Run,
testSizes,
localControl,
directory + "Modular-double",
localGates,
false));
doubleThread.Start();
Thread additionThread = new Thread(() => BasicResourceTest <ModularAdditionEstimator>(
ModularAdditionEstimator.Run,
testSizes,
localControl,
directory + "Modular-addition",
localGates,
false));
additionThread.Start();
isControlled = !isControlled;
}
allGates = !allGates;
}
}
// Checks only signed, windowed point addition.
// Others could be enabled
public static void EstimateEllipticCurveArithmetic(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
var localControl = isControlled;
var localGates = allGates;
// Constant point addition is controlled, the others are not,
// because in Shor's algorithm they do not need to be.
// Thread nonWindowedThread = new Thread(() => BasicResourceTest<EllipticCurveConstantPointAdditionEstimator>(
// EllipticCurveConstantPointAdditionEstimator.Run,
// testSizes,
// true,
// directory + "Constant-point-addition",
// localGates,
// true));
// nonWindowedThread.Start();
//
// Thread windowedThread = new Thread(() => BasicResourceTest<EllipticCurveWindowedPointAdditionEstimator>(
// EllipticCurveWindowedPointAdditionEstimator.Run,
// testSizes,
// false,
// directory + "Windowed-point-addition",
// localGates,
// true));
// windowedThread.Start();
//
// Thread lowWidthThread = new Thread(() => BasicResourceTest<EllipticCurveWindowedPointAdditionLowWidthEstimator>(
// EllipticCurveWindowedPointAdditionLowWidthEstimator.Run,
// testSizes,
// false,
// directory + "Windowed-point-addition-low-width",
// localGates,
// true));
// lowWidthThread.Start();
Thread signedThread = new Thread(() => BasicResourceTest <EllipticCurveSignedWindowedPointAdditionEstimator>(
EllipticCurveSignedWindowedPointAdditionEstimator.Run,
testSizes,
false,
directory + "Windowed-point-addition-signed",
localGates,
true));
signedThread.Start();
// Thread fixedThread = new Thread(() => BasicResourceTest<FixedEllipticCurveSignedWindowedPointAdditionEstimator>(
// FixedEllipticCurveSignedWindowedPointAdditionEstimator.Run,
// testSizes,
// false,
// directory + "Fixed-modulus-signed",
// localGates,
// true));
// fixedThread.Start();
allGates = !allGates;
}
}
// "Expensive" modular operations, including square, multiplication, inversion
// Does not check controlled vs. not controlled because the extra cost is so small,
// and the operations are so costly to estimate.
public static void EstimateExpensiveModularArithmetic(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
var localControl = isControlled;
var localGates = allGates;
Thread multiplyThread = new Thread(() => BasicResourceTest <MontgomeryMultiplicationEstimator>(
MontgomeryMultiplicationEstimator.Run,
testSizes,
localControl,
directory + "Modular-multiplication",
localGates,
true));
multiplyThread.Start();
// This is run as a comparison to the windowed version
Thread multipyNoWindowsThread = new Thread(() => BasicResourceTest <NonWindowedMontgomeryMultiplicationEstimator>(
NonWindowedMontgomeryMultiplicationEstimator.Run,
testSizes,
localControl,
directory + "Modular-multiplication-no-windows",
localGates,
true));
multipyNoWindowsThread.Start();
Thread squareThread = new Thread(() => BasicResourceTest <MontgomerySquareEstimator>(
MontgomerySquareEstimator.Run,
testSizes,
localControl,
directory + "Modular-squaring",
localGates,
true));
squareThread.Start();
Thread invertThread = new Thread(() => BasicResourceTest <MontgomeryInversionEstimator>(
MontgomeryInversionEstimator.Run,
testSizes,
localControl,
directory + "Modular-Inversion",
localGates,
true));
invertThread.Start();
Thread divideThread = new Thread(() => BasicResourceTest <ModularDivisionEstimator>(
ModularDivisionEstimator.Run,
testSizes,
localControl,
directory + "Modular-division",
localGates,
true));
divideThread.Start();
allGates = !allGates;
}
}
public static void EstimateArithmetic(int[] testSizes, string directory)
{
// Writes global parameters (cost metric, testable gates) to terminal
DriverParameters.Print();
System.IO.Directory.CreateDirectory(directory);
// Loops over controlled/not and whether it counts all gates
bool allGates = false;
bool isControlled = false;
for (int j = 0; j < 2; j++)
{
for (int i = 0; i < 2; i++)
{
// Creates a new thread for each operation being estimated
var localControl = isControlled;
var localGates = allGates;
// Thread onesThread = new Thread(() => BasicResourceTest<CheckIfAllOneEstimator>(
// CheckIfAllOneEstimator.Run,
// testSizes,
// localControl,
// directory + "AllOnes",
// localGates,
// false));
// onesThread.Start();
Thread additionThread = new Thread(() => BasicResourceTest <AdditionEstimator>(
AdditionEstimator.Run,
testSizes,
localControl,
directory + "Addition",
localGates,
false));
additionThread.Start();
Thread additionNoCarryThread = new Thread(() => BasicResourceTest <AdditionNoCarryEstimator>(
AdditionNoCarryEstimator.Run,
testSizes,
localControl,
directory + "Addition-no-carry",
localGates,
false));
additionNoCarryThread.Start();
Thread constantAdditionThread = new Thread(() => BasicResourceTest <ConstantAdditionEstimator>(
ConstantAdditionEstimator.Run,
testSizes,
localControl,
directory + "Constant-addition",
localGates,
false));
constantAdditionThread.Start();
Thread greaterThanThread = new Thread(() => BasicResourceTest <GreaterThanEstimator>(
GreaterThanEstimator.Run,
testSizes,
localControl,
directory + "Greater-than",
localGates,
false));
greaterThanThread.Start();
isControlled = !isControlled;
}
allGates = !allGates;
}
}
