public void ToffoliMeasure()
{
var sim = new ToffoliSimulator();
var measure = sim.Get <Intrinsic.M>();
var allocate = sim.Get <Intrinsic.Allocate>();
var release = sim.Get <Intrinsic.Release>();
var qubits = allocate.Apply(1);
Assert.Single(qubits);
var q = qubits[0];
var result = measure.Apply(q);
Assert.Equal(Result.Zero, result);
sim.State[q.Id] = true;
result = measure.Apply(q);
Assert.Equal(Result.One, result);
sim.State[q.Id] = false; // Make it safe to release
release.Apply(qubits);
sim.CheckNoQubitLeak();
}
public void RecursionFail1Test()
{
ToffoliSimulator sim = new ToffoliSimulator();
{
StackTraceCollector sc = new StackTraceCollector(sim);
ICallable op = sim.Get <ICallable, RecursionFail1>();
try
{
QVoid res = op.Apply <QVoid>(QVoid.Instance);
}
catch (ExecutionFailException)
{
StackFrame[] stackFrames = sc.CallStack;
Assert.Equal(4, stackFrames.Length);
Assert.Equal(namespacePrefix + "RecursionFail", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "RecursionFail", stackFrames[1].Callable.FullName);
Assert.Equal(namespacePrefix + "RecursionFail", stackFrames[2].Callable.FullName);
Assert.Equal(namespacePrefix + "RecursionFail1", stackFrames[3].Callable.FullName);
Assert.Equal(OperationFunctor.Body, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[1].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[2].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[3].Callable.Variant);
Assert.Equal(70, stackFrames[0].FailedLineNumber);
Assert.Equal(66, stackFrames[1].FailedLineNumber);
Assert.Equal(66, stackFrames[2].FailedLineNumber);
Assert.Equal(75, stackFrames[3].FailedLineNumber);
}
}
}
public void ToffoliConstructor()
{
var subject = new ToffoliSimulator();
Assert.Equal((int)ToffoliSimulator.DEFAULT_QUBIT_COUNT, subject.State.Length);
Assert.Equal("Toffoli Simulator", subject.Name);
}
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}");
}
}
static DriverParameters()
{
var qsim = new ToffoliSimulator();
DriverParameters.IsTestable = IsMinimizeDepthCostMetric.Run(qsim).Result;
DriverParameters.MinimizeDepthCostMetric = IsMinimizeDepthCostMetric.Run(qsim).Result;
DriverParameters.MinimizeTCostMetric = IsMinimizeTCostMetric.Run(qsim).Result;
DriverParameters.MinimizeWidthCostMetric = IsMinimizeWidthCostMetric.Run(qsim).Result;
}
public void AllGoodTest()
{
ToffoliSimulator sim = new ToffoliSimulator();
QVoid res = sim.Execute <AllGood1, QVoid, QVoid>(QVoid.Instance);
StackFrame[] stackFrames = sim.CallStack;
Assert.Null(stackFrames);
}
public void TestTarget(TestOperation op)
{
var sim = new ToffoliSimulator();
// OnLog defines action(s) performed when Q# test calls function Message
sim.OnLog += (msg) => { this.output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
op.TestOperationRunner(sim);
}
static DriverParameters()
{
// Turn off IsTestable to run the resource estimator
Microsoft.Quantum.Crypto.Basics.IsTestable.Testable = false;
DriverParameters.IsTestable = false;
var qsim = new ToffoliSimulator();
DriverParameters.MinimizeDepthCostMetric = IsMinimizeDepthCostMetric.Run(qsim).Result;
DriverParameters.MinimizeTCostMetric = IsMinimizeTCostMetric.Run(qsim).Result;
DriverParameters.MinimizeWidthCostMetric = IsMinimizeWidthCostMetric.Run(qsim).Result;
}
public void DivideByZeroTest()
{
ToffoliSimulator sim = new ToffoliSimulator();
try
{
sim.Execute <DivideBy0, QVoid, long>(QVoid.Instance);
}
catch (Exception)
{
StackFrame[] stackFrames = sim.CallStack;
Assert.Single(stackFrames);
Assert.Equal(namespacePrefix + "DivideBy0", stackFrames[0].Callable.FullName);
}
}
static void Main(string[] args)
{
var sim = new ToffoliSimulator();
var inputs1 = new long[] { 3, 5, 3, 4, 5 };
var inputs2 = new long[] { 5, 4, 6, 4, 1 };
var modulus = 7;
int numBits = 4;
var res = CustomModAdd.Run(sim, new QArray <long>(inputs1), new QArray <long>(inputs2),
modulus, numBits).Result;
for (int i = 0; i < res.Length; ++i)
{
System.Console.WriteLine($"{inputs1[i]} + {inputs2[i]} " +
$"mod {modulus} = {res[i]}.");
}
}
public void TestTarget(TestOperation op)
{
Console.WriteLine(op.className);
if (op.className.Contains("ToffoliSim"))
{
var sim = new ToffoliSimulator();
sim.OnLog += (msg) => { output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
op.TestOperationRunner(sim);
}
else
{
using (var sim = new QuantumSimulator()) {
sim.OnLog += (msg) => { output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
op.TestOperationRunner(sim);
}
}
}
/// <summary>
/// Simulates a function/operation using the ToffoliSimulator as target machine.
/// It expects a single input: the name of the function/operation to simulate.
/// </summary>
public async Task <ExecutionResult> RunAsync(string input, IChannel channel)
{
var(name, args) = ParseInput(input);
var symbol = SymbolResolver.Resolve(name) as IQSharpSymbol;
if (symbol == null)
{
throw new InvalidOperationException($"Invalid operation name: {name}");
}
var qsim = new ToffoliSimulator();
qsim.DisableLogToConsole();
qsim.OnLog += channel.Stdout;
var value = await symbol.Operation.RunAsync(qsim, args);
return(value.ToExecutionResult());
}
static void Main(string[] args)
{
// using (var qsim = new QuantumSimulator())
// {
// //HelloQ.Run(qsim, int.MaxValue, int.MaxValue).Wait();
// TooManyQubits.Run(qsim).Wait();
// }
var tsim = new ToffoliSimulator(qubitCount: 500000);
TooManyQubits.Run(tsim).Wait();
var estimator = new ResourcesEstimator();
TeleportClassicalMessage.Run(estimator, false).Wait();
var data = estimator.Data;
Console.WriteLine(estimator.ToTSV());
}
/// <summary>
/// Simulates a function/operation using the ToffoliSimulator as target machine.
/// It expects a single input: the name of the function/operation to simulate.
/// </summary>
public async Task <ExecutionResult> RunAsync(string input, IChannel channel)
{
var inputParameters = ParseInputParameters(input, firstParameterInferredName: ParameterNameOperationName);
var name = inputParameters.DecodeParameter <string>(ParameterNameOperationName);
var symbol = SymbolResolver.Resolve(name) as IQSharpSymbol;
if (symbol == null)
{
throw new InvalidOperationException($"Invalid operation name: {name}");
}
var qsim = new ToffoliSimulator().WithStackTraceDisplay(channel);
qsim.DisableLogToConsole();
qsim.OnLog += channel.Stdout;
var value = await symbol.Operation.RunAsync(qsim, inputParameters);
return(value.ToExecutionResult());
}
public void ToffoliX()
{
var sim = new ToffoliSimulator();
var x = sim.Get <Intrinsic.X>();
OperationsTestHelper.applyTestShell(sim, x, (q) =>
{
var measure = sim.Get <Intrinsic.M>();
var set = sim.Get <SetQubit>();
set.Apply((Result.Zero, q));
x.Apply(q);
var result = measure.Apply(q);
Assert.Equal(Result.One, result);
x.Apply(q);
result = measure.Apply(q);
Assert.Equal(Result.Zero, result);
x.Apply(q); // The test helper is going to apply another X before releasing
});
public void ErrorLogTest()
{
ToffoliSimulator sim = new ToffoliSimulator();
var logs = new List <string>();
sim.OnLog += (msg) => logs.Add(msg);
try
{
QVoid res = sim.Execute <AlwaysFail4, QVoid, QVoid>(QVoid.Instance);
}
catch (ExecutionFailException)
{
Assert.Equal(7, logs.Count);
Assert.StartsWith("Unhandled exception. Microsoft.Quantum.Simulation.Core.ExecutionFailException: Always fail", logs[0]);
Assert.StartsWith(" ---> Microsoft.Quantum.Simulation.Simulators.Tests.Circuits.AlwaysFail", logs[1]);
Assert.StartsWith(" at Microsoft.Quantum.Simulation.Simulators.Tests.Circuits.AlwaysFail1 on", logs[2]);
Assert.StartsWith(" at Microsoft.Quantum.Simulation.Simulators.Tests.Circuits.AlwaysFail2 on", logs[3]);
Assert.StartsWith(" at Microsoft.Quantum.Simulation.Simulators.Tests.Circuits.AlwaysFail3 on", logs[4]);
Assert.StartsWith(" at Microsoft.Quantum.Simulation.Simulators.Tests.Circuits.AlwaysFail4 on", logs[5]);
Assert.Equal("", logs[6]);
}
}
static void Main(string[] args)
{
var sim = new ToffoliSimulator();
var evaluationPoints = new QArray <double>(
new double[] { 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6 }
);
var polynomialCoefficients = new QArray <double>(
new double[] { 0.9992759725166501, -0.16566707016968898,
0.007958079331694682, -0.0001450780334861007 }
);
var odd = true;
var even = false;
Debug.Assert(!(odd && even));
System.Console.Write($"Evaluating P(x) = {polynomialCoefficients[0]}");
if (odd)
{
System.Console.Write("*x");
}
for (int d = 1; d < polynomialCoefficients.Length; ++d)
{
System.Console.Write($" + {polynomialCoefficients[d]}*" +
$"x^{d + (odd ? d+1 : 0) + (even ? d : 0)}");
}
System.Console.Write(".\n");
int pointPos = 3;
int numBits = 64;
var res = EvaluatePolynomial.Run(sim, polynomialCoefficients,
evaluationPoints, numBits, pointPos,
odd, even).Result;
for (int i = 0; i < res.Length; ++i)
{
System.Console.WriteLine($"P({evaluationPoints[i]}) = {res[i]}. " +
$"[sin(x) = {System.Math.Sin(evaluationPoints[i])}]");
}
}
public void CanSimulateWithAlternativeSimulator()
{
var sim = new ToffoliSimulator();
TestQuantumSwap.Run(sim).Wait();
}
public void PartialFail1Test()
{
ToffoliSimulator sim = new ToffoliSimulator();
{
try
{
QVoid res = PartialFail1.Run(sim).Result;
}
catch (AggregateException ex)
{
Assert.True(ex.InnerException is ExecutionFailException);
StackFrame[] stackFrames = sim.CallStack;
Assert.Equal(3, stackFrames.Length);
Assert.Equal(namespacePrefix + "AlwaysFail", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "PartialFail", stackFrames[1].Callable.FullName);
Assert.Equal(namespacePrefix + "PartialFail1", stackFrames[2].Callable.FullName);
Assert.Equal(OperationFunctor.Body, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[1].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[2].Callable.Variant);
Assert.Equal(7, stackFrames[0].FailedLineNumber);
Assert.Equal(33, stackFrames[1].FailedLineNumber);
Assert.Equal(38, stackFrames[2].FailedLineNumber);
}
}
{
try
{
QVoid res = PartialAdjFail1.Run(sim).Result;
}
catch (AggregateException ex)
{
Assert.True(ex.InnerException is ExecutionFailException);
StackFrame[] stackFrames = sim.CallStack;
Assert.Equal(3, stackFrames.Length);
Assert.Equal(namespacePrefix + "AlwaysFail", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "PartialFail", stackFrames[1].Callable.FullName);
Assert.Equal(namespacePrefix + "PartialAdjFail1", stackFrames[2].Callable.FullName);
Assert.Equal(OperationFunctor.Adjoint, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Adjoint, stackFrames[1].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[2].Callable.Variant);
Assert.Equal(6, stackFrames[0].FailedLineNumber);
Assert.Equal(32, stackFrames[1].FailedLineNumber);
Assert.Equal(43, stackFrames[2].FailedLineNumber);
}
}
{
try
{
QVoid res = PartialCtlFail1.Run(sim).Result;
}
catch (AggregateException ex)
{
Assert.True(ex.InnerException is ExecutionFailException);
StackFrame[] stackFrames = sim.CallStack;
Assert.Equal(3, stackFrames.Length);
Assert.Equal(namespacePrefix + "AlwaysFail", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "PartialFail", stackFrames[1].Callable.FullName);
Assert.Equal(namespacePrefix + "PartialCtlFail1", stackFrames[2].Callable.FullName);
Assert.Equal(OperationFunctor.Controlled, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Controlled, stackFrames[1].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[2].Callable.Variant);
Assert.Equal(6, stackFrames[0].FailedLineNumber);
Assert.Equal(32, stackFrames[1].FailedLineNumber);
Assert.Equal(48, stackFrames[2].FailedLineNumber);
}
}
}
static void Main(string[] args)
{
var rng = new Random(5);
// Binary integers of the form 1XXX0000000...
var cases = new List <int>();
for (var i = 8; i <= 2048; i <<= 1)
{
for (var j = 0; j < 8; j++)
{
cases.Add(i + (i >> 3) * j);
}
}
// Header column.
Console.WriteLine($"{String.Join(", ", cases)}");
var methods = new[] {
"window",
"legacy",
"karatsuba"
};
var columns = new List <String>();
columns.Add("n");
foreach (var method in methods)
{
columns.Add(method + " " + "toffolis");
columns.Add(method + " " + "qubits");
columns.Add(method + " " + "depth");
}
Console.WriteLine(String.Join(", ", columns));
// Collect data.
foreach (var n in cases)
{
var tofCounts = new double[methods.Length];
var qubitCounts = new double[methods.Length];
var depthCounts = new double[methods.Length];
var reps = Math.Max(1, Math.Min(10, 128 / n));
for (int r = 0; r < reps; r++)
{
for (int i = 0; i < methods.Length; i++)
{
var a = rng.NextBigInt(2 * n);
var b = rng.NextBigInt(n);
var c = rng.NextBigInt(n);
var tof_sim = new ToffoliSimulator();
var tof_output = RunPlusEqualProductMethod.Run(tof_sim, a, b, c, methods[i]).Result;
var config = new QCTraceSimulatorConfiguration();
config.usePrimitiveOperationsCounter = true;
config.useWidthCounter = true;
config.useDepthCounter = true;
var trace_sim = new QCTraceSimulator(config);
var trace_output = RunPlusEqualProductMethod.Run(trace_sim, a, b, c, methods[i]).Result;
if (tof_output != a + b * c || trace_output != tof_output)
{
throw new ArithmeticException($"Wrong result using {methods[i]}. {a}+{b}*{c} == {a+b*c} != {tof_output} or {trace_output}.");
}
tofCounts[i] += trace_sim.GetMetric <RunPlusEqualProductMethod>(PrimitiveOperationsGroupsNames.T) / 7;
qubitCounts[i] += trace_sim.GetMetric <RunPlusEqualProductMethod>(MetricsNames.WidthCounter.ExtraWidth);
depthCounts[i] += trace_sim.GetMetric <RunPlusEqualProductMethod>(MetricsNames.DepthCounter.Depth);
}
}
// Output row of results.
var data = new List <double>();
data.Add(n);
for (var i = 0; i < methods.Length; i++)
{
data.Add(tofCounts[i] / reps);
data.Add(qubitCounts[i] / reps);
data.Add(depthCounts[i] / reps);
}
Console.WriteLine(String.Join(", ", data));
}
}
