void MultiControilledXWidthExample()
{
var config = new QCTraceSimulatorConfiguration();
config.UseWidthCounter = true;
config.CallStackDepthLimit = 2;
var sim = new QCTraceSimulator(config);
int totalNumberOfQubits = 5;
var res = MultiControlledXDriver.Run(sim, totalNumberOfQubits).Result;
double allocatedQubits =
sim.GetMetric <Intrinsic.X, MultiControlledXDriver>(
MetricsNames.WidthCounter.ExtraWidth,
functor: OperationFunctor.Controlled);
double inputWidth =
sim.GetMetric <Intrinsic.X, MultiControlledXDriver>(
MetricsNames.WidthCounter.InputWidth,
functor: OperationFunctor.Controlled);
string csvSummary = sim.ToCSV()[MetricsCountersNames.widthCounter];
// above code is an example used in the documentation
Assert.Equal(totalNumberOfQubits, inputWidth);
Assert.Equal(totalNumberOfQubits - 3, allocatedQubits);
Debug.WriteLine(csvSummary);
output.WriteLine(csvSummary);
}
public void TracerCoreConstructor()
{
QCTraceSimulatorConfiguration tracerCoreConfiguration = new QCTraceSimulatorConfiguration();
tracerCoreConfiguration.UsePrimitiveOperationsCounter = true;
QCTraceSimulator tracerCore = new QCTraceSimulator(tracerCoreConfiguration);
}
/// <summary>
/// Creates the four Bell (maximally entangled two-qubit) states and measures the correlations
/// between the two qubits.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
using (var quantumSimulator = new QuantumSimulator())
{
QCTraceSimulator traceSimulator = CreateTraceSimulator();
IOperationFactory simulator;
if (useTraceSimulator)
{
simulator = traceSimulator;
}
else
{
simulator = quantumSimulator;
}
Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("Puts two qubits in a Bell (maximally entangled) state, measuring " +
"the first then checking if it correlates with the second. The Bell state is " +
"created by applying a Hadamard gate to the first qubit then a CNOT to them both " +
"using the first as a control.");
Console.WriteLine();
var initialValues = new[]
public void GetPrimitiveOperations()
{
QCTraceSimulator tracerCore = new QCTraceSimulator();
var measureOp = tracerCore.Get <Intrinsic.Measure, Intrinsic.Measure>();
Assert.NotNull(measureOp);
var assertOp = tracerCore.Get <Intrinsic.Assert, Intrinsic.Assert>();
Assert.NotNull(assertOp);
var assertProb = tracerCore.Get <Intrinsic.AssertProb, Intrinsic.AssertProb>();
Assert.NotNull(assertProb);
var allocOp = tracerCore.Get <Intrinsic.Allocate, Intrinsic.Allocate>();
Assert.NotNull(allocOp);
var releaseOp = tracerCore.Get <Intrinsic.Release, Intrinsic.Release>();
Assert.NotNull(releaseOp);
var borrowOp = tracerCore.Get <Intrinsic.Borrow, Intrinsic.Borrow>();
Assert.NotNull(borrowOp);
var returnOp = tracerCore.Get <Intrinsic.Return, Intrinsic.Return>();
Assert.NotNull(returnOp);
}
void CCNOTGateCountExample()
{
var config = new QCTraceSimulatorConfiguration();
config.UsePrimitiveOperationsCounter = true;
QCTraceSimulator sim = new QCTraceSimulator(config);
QVoid res;
res = CCNOTDriver.Run(sim).Result;
res = CCNOTDriver.Run(sim).Result;
double tCount = sim.GetMetric <Intrinsic.CCNOT, CCNOTDriver>(PrimitiveOperationsGroupsNames.T);
double tCountAll = sim.GetMetric <CCNOTDriver>(PrimitiveOperationsGroupsNames.T);
double cxCount = sim.GetMetric <Intrinsic.CCNOT, CCNOTDriver>(PrimitiveOperationsGroupsNames.CNOT);
string csvSummary = sim.ToCSV()[MetricsCountersNames.primitiveOperationsCounter];
// above code is an example used in the documentation
Assert.Equal(7.0, sim.GetMetricStatistic <Intrinsic.CCNOT, CCNOTDriver>(PrimitiveOperationsGroupsNames.T, MomentsStatistic.Statistics.Average));
Assert.Equal(7.0, tCount);
Assert.Equal(8.0, sim.GetMetricStatistic <CCNOTDriver>(PrimitiveOperationsGroupsNames.T, MomentsStatistic.Statistics.Average));
Assert.Equal(0.0, sim.GetMetricStatistic <CCNOTDriver>(PrimitiveOperationsGroupsNames.T, MomentsStatistic.Statistics.Variance));
Assert.Equal(8.0, tCountAll);
Assert.Equal(10.0, cxCount);
Debug.WriteLine(csvSummary);
output.WriteLine(csvSummary);
}
void TCountTest()
{
var config = new QCTraceSimulatorConfiguration();
config.UsePrimitiveOperationsCounter = true;
config.CallStackDepthLimit = 2;
QCTraceSimulator sim = new QCTraceSimulator(config);
var res = TCountOneGatesTest.Run(sim).Result;
var res2 = TCountZeroGatesTest.Run(sim).Result;
var tcount = PrimitiveOperationsGroupsNames.T;
string csvSummary = sim.ToCSV()[MetricsCountersNames.primitiveOperationsCounter];
output.WriteLine(csvSummary);
Assert.Equal(Double.NaN, sim.GetMetricStatistic <Intrinsic.T, TCountOneGatesTest>(
PrimitiveOperationsGroupsNames.T, MomentsStatistic.Statistics.Variance));
Assert.Equal(1, sim.GetMetric <Intrinsic.T, TCountOneGatesTest>(tcount,
functor: OperationFunctor.Adjoint));
Assert.Equal(1, sim.GetMetric <Intrinsic.T, TCountOneGatesTest>(tcount));
Assert.Equal(1, sim.GetMetric <Intrinsic.RFrac, TCountOneGatesTest>(tcount));
Assert.Equal(1, sim.GetMetric <Intrinsic.ExpFrac, TCountOneGatesTest>(tcount));
Assert.Equal(1, sim.GetMetric <Intrinsic.R1Frac, TCountOneGatesTest>(tcount));
Assert.Equal(0, sim.GetMetric <Intrinsic.S, TCountZeroGatesTest>(tcount,
functor: OperationFunctor.Adjoint));
Assert.Equal(0, sim.GetMetric <Intrinsic.S, TCountZeroGatesTest>(tcount));
Assert.Equal(0, sim.GetMetric <Intrinsic.RFrac, TCountZeroGatesTest>(tcount));
Assert.Equal(0, sim.GetMetric <Intrinsic.ExpFrac, TCountZeroGatesTest>(tcount));
Assert.Equal(0, sim.GetMetric <Intrinsic.R1Frac, TCountZeroGatesTest>(tcount));
}
public void RunTest(Action <QCTraceSimulator> test)
{
// Set gate times (AKA depth) to match expected physical implementation. Defaults to T = 1.0, all else 0.0
// More info: https://docs.microsoft.com/en-us/quantum/quantum-computer-trace-simulator-depth-counter?view=qsharp-preview
var gateTimes = new Dictionary <PrimitiveOperationsGroups, double>
{
[PrimitiveOperationsGroups.Measure] = 2.0,
[PrimitiveOperationsGroups.T] = 1.0,
[PrimitiveOperationsGroups.R] = 0.0,
[PrimitiveOperationsGroups.QubitClifford] = 0.0,
[PrimitiveOperationsGroups.CNOT] = 0.0,
};
// Set config for trace simulator
// More info: https://docs.microsoft.com/en-us/quantum/quantum-computer-trace-simulator-1?view=qsharp-preview
var config = new QCTraceSimulatorConfiguration
{
usePrimitiveOperationsCounter = true, // Counts the number of primitive executions used by every operation invoked in a quantum program
useWidthCounter = true, // Counts the number of qubits allocated and borrowed by each operation
useDepthCounter = true, // Gathers counts of the depth of every operation in the program (depth represents the number of time steps required to complete the program)
gateTimes = gateTimes, // Set custom gate times for depth counter
useDistinctInputsChecker = true, // Prevents bugs e.g. using the same qubit as control and target in a CNOT gate
useInvalidatedQubitsUseChecker = true, // Detects e.g. usage of the qubits of a mutable Qubit[] after the qubits have been released
throwOnUnconstraintMeasurement = true // Will fail if there is at least one measurement not annotated using AssertProb or ForceMeasure
};
var sim = new QCTraceSimulator(config);
sim.OnLog += (msg) => { output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
test(sim);
}
public void ControlledSWAPMetricsTest()
{
// Get an instance of the appropriately configured QCTraceSimulator
QCTraceSimulator sim = MetricCalculationUtils.GetSimulatorForMetricsCalculation();
// Run tests against trace simulator to collect metrics
var result = ControlledSWAPTest.Run(sim).Result;
// Let us check that number of T gates in all the circuits is as expected
string Tcount = PrimitiveOperationsGroupsNames.T;
Assert.Equal(7, sim.GetMetric <ControlledSWAP1, CollectMetrics>(Tcount));
Assert.Equal(7, sim.GetMetric <ControlledSWAPUsingCCNOT, CollectMetrics>(Tcount));
// Let us check the number of CNOT gates
Assert.Equal(8, sim.GetMetric <ControlledSWAP1, CollectMetrics>(
PrimitiveOperationsGroupsNames.CNOT));
// Number of single qubit Clifford gates
Assert.Equal(2, sim.GetMetric <ControlledSWAP1, CollectMetrics>(
PrimitiveOperationsGroupsNames.QubitClifford));
// And T depth
Assert.Equal(4, sim.GetMetric <ControlledSWAP1, CollectMetrics>(
MetricsNames.DepthCounter.Depth));
}
private static void SingleResourceTestNoCost <TypeQop>(
RunParameterizedQop runner,
ReaderWriterLock locker,
int n,
int m,
bool isControlled,
string filename,
bool full_depth)
{
QCTraceSimulator estimator = GetTraceSimulator(full_depth); // construct simulator object
// we must generate a new simulator in each round, to clear previous estimates
var res = runner(estimator, n, isControlled, m).Result; // run test
// Get results
// Create string of a row of parameters
string thisCircuitCosts = DisplayCSV.CSV(estimator.ToCSV(), typeof(TypeQop).FullName, false, string.Empty, false, string.Empty);
// add the row to the string of the csv
thisCircuitCosts += $"{n}, {m}";
try
{
locker.AcquireWriterLock(int.MaxValue); // absurd timeout value
System.IO.File.AppendAllText(filename, thisCircuitCosts);
}
finally
{
locker.ReleaseWriterLock();
}
}
public void TracerVerifyPrimitivesCompleteness()
{
QCTraceSimulator tracerCore = new QCTraceSimulator();
var ops =
from op in typeof(Intrinsic.X).Assembly.GetExportedTypes()
where op.IsSubclassOf(typeof(AbstractCallable))
where !op.IsNested
select op;
var missing = new List <Type>();
foreach (var op in ops)
{
try
{
var i = tracerCore.GetInstance(op);
Assert.NotNull(i);
}
catch (Exception)
{
missing.Add(op);
}
}
Assert.Empty(missing);
}
static void Main(string[] args)
{
var rng = new Random(5);
var collectTofCount = true;
var collectQubitCount = true;
var useSchoolbook = false;
var cases = new[] {
32,
64, 96,
128, 128 + 32,
256, 256 + 32,
512, 512 + 32,
1024, 1024 + 32,
2048, 2048 + 32,
4096, 4096 + 32
};
foreach (var i in cases)
{
var a = rng.NextBigInt(i);
var b = rng.NextBigInt(i);
var tof_sim = new ToffoliSimulator();
var config = new QCTraceSimulatorConfiguration();
config.usePrimitiveOperationsCounter = collectTofCount;
config.useWidthCounter = collectQubitCount;
var trace_sim = new QCTraceSimulator(config);
BigInteger result = 0, result2 = 0;
if (useSchoolbook)
{
result = RunSchoolbookMultiplicationCircuit.Run(tof_sim, a, b).Result;
result2 = RunSchoolbookMultiplicationCircuit.Run(trace_sim, a, b).Result;
}
else
{
result = RunKaratsubaMultiplicationCircuit.Run(tof_sim, a, b).Result;
result2 = RunKaratsubaMultiplicationCircuit.Run(trace_sim, a, b).Result;
}
if (result != a * b || result2 != result)
{
throw new ArithmeticException($"Wrong result. {a}*{b} != {result}, {result==result2}.");
}
double tofCount, qubitCount;
if (useSchoolbook)
{
tofCount = collectTofCount ? trace_sim.GetMetric <RunSchoolbookMultiplicationCircuit>(PrimitiveOperationsGroupsNames.T) / 7 : -1;
qubitCount = collectQubitCount ? trace_sim.GetMetric <RunSchoolbookMultiplicationCircuit>(MetricsNames.WidthCounter.ExtraWidth) : -1;
}
else
{
tofCount = collectTofCount ? trace_sim.GetMetric <RunKaratsubaMultiplicationCircuit>(PrimitiveOperationsGroupsNames.T) / 7 : -1;
qubitCount = collectQubitCount ? trace_sim.GetMetric <RunKaratsubaMultiplicationCircuit>(MetricsNames.WidthCounter.ExtraWidth) : -1;
}
Console.WriteLine($"{i},{tofCount},{qubitCount}");
}
}
public void UseReleasedQubitsTests()
{
QCTraceSimulator sim = new QCTraceSimulator(new QCTraceSimulatorConfiguration()
{
UseInvalidatedQubitsUseChecker = true
});
Assert.Throws <InvalidatedQubitsUseCheckerException>(GetTest <UseReleasedQubitTest>(sim));
}
public void PQRSTermFromGeneralHamiltonianTest()
{
var generalHamiltonian = new FermionHamiltonian(nOrbitals: 2, nElectrons: 1);
generalHamiltonian.AddFermionTerm(PQRSTermType, new Int64[] { 0, 1, 3, 2 }, 2.0);
var jwEvolutionSetData = JordanWignerEncoding.Create(generalHamiltonian);
var termData = jwEvolutionSetData.Terms;
var qsim = new QCTraceSimulator(TraceConfig.config);
RunOptimizedBlockEncoding.Run(qsim, generalHamiltonian.NOrbitals * 2, termData, targetError).Wait();
}
void TDepthTest()
{
var config = new QCTraceSimulatorConfiguration();
config.UseDepthCounter = true;
config.CallStackDepthLimit = 1;
QCTraceSimulator sim = new QCTraceSimulator(config);
var res = TDepthOne.Run(sim).Result;
string csvSummary = sim.ToCSV()[MetricsCountersNames.depthCounter];
Assert.Equal(1, sim.GetMetric <TDepthOne>(MetricsNames.DepthCounter.Depth));
}
public void PQRSTermFromLiquidOrbitalTest()
{
string orbitals = "0,1,0,1=1.0";
var generalHamiltonian = LoadData.LoadFromLiquid(orbitals);
generalHamiltonian.NElectrons = 1L;
var jwEvolutionSetData = JordanWignerEncoding.Create(generalHamiltonian);
var termData = jwEvolutionSetData.Terms;
var qsim = new QCTraceSimulator(TraceConfig.config);
RunOptimizedBlockEncoding.Run(qsim, generalHamiltonian.NOrbitals * 2, termData, targetError).Wait();
}
public void PPTermFromGeneralHamiltonianTest()
{
var generalHamiltonian = new FermionHamiltonian(nOrbitals: 1, nElectrons: 1);
generalHamiltonian.AddFermionTerm(PPTermType, new Int64[] { 0, 0 }, 1.0);
generalHamiltonian.AddFermionTerm(PPTermType, new Int64[] { 1, 1 }, -1.0);
var jwEvolutionSetData = JordanWignerEncoding.Create(generalHamiltonian);
var identityCoefficient = jwEvolutionSetData.energyOffset;
var termData = jwEvolutionSetData.Terms;
var qsim = new QCTraceSimulator(TraceConfig.config);
RunOptimizedBlockEncoding.Run(qsim, generalHamiltonian.NOrbitals * 2, termData, targetError).Wait();
}
public void DistinctQubitsTests()
{
QCTraceSimulator sim = new QCTraceSimulator(new QCTraceSimulatorConfiguration()
{
UseDistinctInputsChecker = true
});
Assert.Throws <DistinctInputsCheckerException>(GetTest <DisctinctQubitTest>(sim));
Assert.Throws <DistinctInputsCheckerException>(GetTest <DisctinctQubitCapturedTest>(sim));
Assert.Throws <DistinctInputsCheckerException>(GetTest <DisctinctQubitCaptured2Test>(sim));
Assert.Throws <DistinctInputsCheckerException>(GetTest <DisctinctQubitCaptured3Test>(sim));
Assert.Throws <DistinctInputsCheckerException>(GetTest <DisctinctQubitCaptured4Test>(sim));
}
static void Main(string[] args)
{
var config = new QCTraceSimulatorConfiguration();
config.throwOnUnconstraintMeasurement = false;
config.useInvalidatedQubitsUseChecker = true;
QCTraceSimulator qsim = new QCTraceSimulator(config);
var res = CheckForReleasedQubit.Run(qsim).Result;
}
static void Main(string[] args)
{
var config = new QCTraceSimulatorConfiguration();
config.throwOnUnconstraintMeasurement = false;
config.useDistinctInputsChecker = true;
QCTraceSimulator qsim = new QCTraceSimulator(config);
var res = CheckDistinctInputs.Run(qsim).Result;
}
public void TwoCNOTs()
{
QCTraceSimulator sim = GetTraceSimForMetrics();
GetTest <TwoCNOTsTest>(sim)();
void AssertEqualMetric(double value, string metric)
{
Assert.Equal(value, sim.GetMetric <TwoCNOTsTest>(metric));
}
AssertEqualMetric(2, DepthCounter.Metrics.Depth);
AssertEqualMetric(2, PrimitiveOperationsGroupsNames.CNOT);
AssertEqualMetric(3, WidthCounter.Metrics.ExtraWidth);
AssertEqualMetric(0, DepthCounter.Metrics.StartTimeDifference);
}
void CatStateTestCore <TCatState>(int powerOfTwo) where TCatState : AbstractCallable, ICallable <long, QVoid>
{
Debug.Assert(powerOfTwo > 0);
double CXTime = 5;
double HTime = 1;
QCTraceSimulatorConfiguration traceSimCfg = new QCTraceSimulatorConfiguration();
traceSimCfg.UsePrimitiveOperationsCounter = true;
traceSimCfg.UseDepthCounter = true;
traceSimCfg.UseWidthCounter = true;
traceSimCfg.TraceGateTimes[PrimitiveOperationsGroups.CNOT] = CXTime;
traceSimCfg.TraceGateTimes[PrimitiveOperationsGroups.QubitClifford] = HTime;
QCTraceSimulator traceSim = new QCTraceSimulator(traceSimCfg);
output.WriteLine(string.Empty);
output.WriteLine($"Starting cat state preparation on {1u << powerOfTwo} qubits");
var stopwatch = new Stopwatch();
stopwatch.Start();
traceSim.Run <TCatState, long, QVoid>(powerOfTwo).Wait();
stopwatch.Stop();
double cxCount = traceSim.GetMetric <TCatState>(PrimitiveOperationsGroupsNames.CNOT);
Assert.Equal((1 << powerOfTwo) - 1, (long)cxCount);
double depth = traceSim.GetMetric <TCatState>(DepthCounter.Metrics.Depth);
Assert.Equal(HTime + powerOfTwo * CXTime, depth);
void AssertEqualMetric(double value, string metric)
{
Assert.Equal(value, traceSim.GetMetric <TCatState>(metric));
}
AssertEqualMetric(1u << powerOfTwo, WidthCounter.Metrics.ExtraWidth);
AssertEqualMetric(0, WidthCounter.Metrics.BorrowedWith);
AssertEqualMetric(0, WidthCounter.Metrics.InputWidth);
AssertEqualMetric(0, WidthCounter.Metrics.ReturnWidth);
output.WriteLine($"Calculation of metrics took: {stopwatch.ElapsedMilliseconds} ms");
output.WriteLine($"The depth is: {depth} given depth of CNOT was {CXTime} and depth of H was {HTime}");
output.WriteLine($"Number of CNOTs used is {cxCount}");
}
public void RepeatUntilSuccessCircuitsMetricsTest()
{
// Get an instance of the appropriately configured QCTraceSimulator
QCTraceSimulator sim = MetricCalculationUtils.GetSimulatorForMetricsCalculation();
// Run tests against trace simulator to collect metrics
var result = RepeatUntilSuccessCircuitsTest.Run(sim).Result;
string TCount = PrimitiveOperationsGroupsNames.T;
string extraQubits = MetricsNames.WidthCounter.ExtraWidth;
string min = StatisticsNames.Min;
string max = StatisticsNames.Max;
string avg = StatisticsNames.Average;
// Let us check how many ancillas we used
// 4 for Nielsen & Chuang
// version because we used CCNOT3 which itself required 2 ancillas
Assert.Equal(4, sim.GetMetric <ExpIZArcTan2NC, caller>(extraQubits));
// 2 for Paetznick & Svore version
Assert.Equal(2, sim.GetMetric <ExpIZArcTan2PS, caller>(extraQubits));
// One trial of ExpIZArcTan2NC requires at least 8 T gates
Assert.True(8 <= sim.GetMetricStatistic <ExpIZArcTan2NC, caller>(TCount, min));
// One trial of ExpIZArcTan2NC requires at least 3 T gates
Assert.True(3 <= sim.GetMetricStatistic <ExpIZArcTan2PS, caller>(TCount, min));
// The rest of the statistical information we print into test output
// For ExpIZArcTan2NC:
output.WriteLine($"Statistics collected for{nameof(ExpIZArcTan2NC)}");
output.WriteLine($"Average number of T-gates:" +
$" {sim.GetMetricStatistic<ExpIZArcTan2NC, caller>(TCount, avg)}");
output.WriteLine($"Minimal number of T-gates: " +
$"{sim.GetMetricStatistic<ExpIZArcTan2NC, caller>(TCount, min)}");
output.WriteLine($"Maximal number of T-gates: " +
$"{sim.GetMetricStatistic<ExpIZArcTan2NC, caller>(TCount, max)}");
// And for ExpIZArcTan2PS
output.WriteLine($"Statistics collected for{nameof(ExpIZArcTan2PS)}");
output.WriteLine($"Average number of T-gates:" +
$" {sim.GetMetricStatistic<ExpIZArcTan2PS, caller>(TCount, avg)}");
output.WriteLine($"Minimal number of T-gates: " +
$"{sim.GetMetricStatistic<ExpIZArcTan2PS, caller>(TCount, min)}");
output.WriteLine($"Maximal number of T-gates: " +
$"{sim.GetMetricStatistic<ExpIZArcTan2PS, caller>(TCount, max)}");
}
public static void WriteResultsToFolder(
this QCTraceSimulator sim,
string outputFolder,
string baseName
)
{
var gateStats = sim.ToCSV();
foreach (var x in gateStats)
{
System.IO.File.WriteAllLines(
System.IO.Path.Join(
outputFolder,
$"{baseName}.{x.Key}.csv"
), new string[] { x.Value }
);
}
}
static void Main(string[] args)
{
var config = new QCTraceSimulatorConfiguration();
config.useDepthCounter = true;
QCTraceSimulator qsim = new QCTraceSimulator(config);
var res = ExecuteCCNOTGate.Run(qsim).Result;
double tDepthAll = qsim.GetMetric <ExecuteCCNOTGate>(DepthCounter.Metrics.Depth);
System.Console.WriteLine(tDepthAll);
}
static void Main(string[] args)
{
var config = new QCTraceSimulatorConfiguration();
config.throwOnUnconstraintMeasurement = false;
config.usePrimitiveOperationsCounter = true;
QCTraceSimulator qsim = new QCTraceSimulator(config);
var res = PrimitiveOperationsChecker.Run(qsim).Result;
double tCountAll = qsim.GetMetric <PrimitiveOperationsChecker>(PrimitiveOperationsGroupsNames.T);
System.Console.WriteLine(tCountAll);
}
static void Main(string[] args)
{
var config = new QCTraceSimulatorConfiguration();
config.throwOnUnconstraintMeasurement = false;
config.useWidthCounter = true;
QCTraceSimulator qsim = new QCTraceSimulator(config);
int totalQubits = 5;
var res = GetWidthCounter.Run(qsim, totalQubits).Result;
string csvSummary = qsim.ToCSV()[MetricsCountersNames.widthCounter];
System.Console.WriteLine(csvSummary);
}
void CCNOTDepthCountExample()
{
var config = new QCTraceSimulatorConfiguration();
config.UseDepthCounter = true;
config.CallStackDepthLimit = 2;
QCTraceSimulator sim = new QCTraceSimulator(config);
var res = CCNOTDriver.Run(sim).Result;
double tDepth = sim.GetMetric <Intrinsic.CCNOT, CCNOTDriver>(MetricsNames.DepthCounter.Depth);
double tDepthAll = sim.GetMetric <CCNOTDriver>(MetricsNames.DepthCounter.Depth);
string csvSummary = sim.ToCSV()[MetricsCountersNames.depthCounter];
// above code is an example used in the documentation
Assert.Equal(5.0, tDepth);
Assert.Equal(6.0, tDepthAll);
Debug.WriteLine(csvSummary);
output.WriteLine(csvSummary);
}
private static void SingleTwoArgResourceTest <TypeQop>(
RunTwoArgQop runner,
ReaderWriterLock locker,
int n,
int[] ms,
bool isControlled,
string filename,
bool full_depth)
{
// Iterate through values of the second parameter
foreach (int m in ms)
{
QCTraceSimulator estimator = GetTraceSimulator(full_depth); // construct simulator object
// we must generate a new simulator in each round, to clear previous estimates
var res = runner(estimator, n, m, isControlled).Result; // run test
// Get results
var roundDepth = estimator.GetMetric <TypeQop>(MetricsNames.DepthCounter.Depth);
var roundTGates = estimator.GetMetric <TypeQop>(PrimitiveOperationsGroupsNames.T);
// Create string of a row of parameters
string thisCircuitCosts = DisplayCSV.CSV(estimator.ToCSV(), typeof(TypeQop).FullName, false, string.Empty, false, string.Empty);
// add the row to the string of the csv
thisCircuitCosts += $"{n}, {m}";
try
{
locker.AcquireWriterLock(int.MaxValue); // absurd timeout value
System.IO.File.AppendAllText(filename, thisCircuitCosts);
}
finally
{
locker.ReleaseWriterLock();
}
}
}
[InlineData(2017L)] // numberOfControlQubits = 4,5,2017
public void MultiControlledNOTMetricsTest(long numberOfControlQubits)
{
// Get an instance of the appropriately configured QCTraceSimulator
QCTraceSimulator sim = MetricCalculationUtils.GetSimulatorForMetricsCalculation();
// Run tests against trace simulator to collect metrics
var result =
MultiControlledNotWithDirtyQubitsMetrics.Run(sim, numberOfControlQubits).Result;
string borrowedQubits = MetricsNames.WidthCounter.BorrowedWith;
string allocatedQubits = MetricsNames.WidthCounter.ExtraWidth;
// Get the number of qubits borrowed by the MultiControlledXBorrow
double numBorowed1 =
sim.GetMetric <MultiControlledXBorrow, MultiControlledNotWithDirtyQubitsMetrics>(
borrowedQubits);
// Get the number of qubits allocated by the MultiControlledXBorrow
double numAllocated1 =
sim.GetMetric <MultiControlledXBorrow, MultiControlledNotWithDirtyQubitsMetrics>(
allocatedQubits);
Assert.Equal(numberOfControlQubits - 2, numBorowed1);
Assert.Equal(0, numAllocated1);
// Get the number of qubits borrowed by the MultiControlledXClean
double numBorowed2 =
sim.GetMetric <MultiControlledXClean, MultiControlledNotWithDirtyQubitsMetrics>(
borrowedQubits);
// Get the number of qubits allocated by the MultiControlledXClean
double numAllocated2 =
sim.GetMetric <MultiControlledXClean, MultiControlledNotWithDirtyQubitsMetrics>(
allocatedQubits);
Assert.Equal(numberOfControlQubits - 2, numAllocated2);
Assert.Equal(0, numBorowed2);
}
public static void ProcessSim <Qop>(QCTraceSimulator sim, string comment = "", bool full_depth = false, string suffix = "")
{
if (!full_depth)
{
DisplayCSV.CSV(sim.ToCSV(), typeof(Qop).FullName, false, comment, false, suffix);
}
else
{
// full depth only
var depthEngine = new FileHelperAsyncEngine <DepthCounterCSV>();
using (depthEngine.BeginReadString(sim.ToCSV()[MetricsCountersNames.depthCounter]))
{
// The engine is IEnumerable
foreach (DepthCounterCSV cust in depthEngine)
{
if (cust.Name == typeof(Qop).FullName)
{
Console.Write($"{cust.DepthAverage}");
}
}
}
}
}
