public void QrackSimVerifyPrimitivesCompleteness()
{
using (var sim = new QrackSimulator())
{
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 = sim.GetInstance(op);
Assert.NotNull(i);
}
catch (Exception)
{
missing.Add(op);
}
}
Assert.Empty(missing);
}
}
public void QrackSimConstructor()
{
using (var subject = new QrackSimulator())
{
Assert.Equal("Qrack Simulator", subject.Name);
}
}
public void Swap()
{
var q1 = new FreeQubit(0);
var q2 = new FreeQubit(1);
var op = new QrackSimulator().Get <Intrinsic.SWAP>();
var args = op.__DataIn__((q1, q2));
var expected = new RuntimeMetadata()
{
Label = "SWAP",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
q1, q2
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void QrackSimTestTarget(TestOperation op)
{
using (var sim = new QrackSimulator(throwOnReleasingQubitsNotInZeroState: true))
{
op.TestOperationRunner(sim);
}
}
public void OperationAsArgument()
{
var q = new FreeQubit(0);
var opArg = new QrackSimulator().Get <Circuits.HOp>();
var op = new QrackSimulator().Get <Circuits.WrapperOp>();
var args = op.__DataIn__((opArg, q));
var expected = new RuntimeMetadata()
{
Label = "WrapperOp",
FormattedNonQubitArgs = "(HOp)",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
q
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void ControlledCCNOT()
{
Qubit control1 = new FreeQubit(0);
Qubit control2 = new FreeQubit(1);
Qubit control3 = new FreeQubit(2);
Qubit target = new FreeQubit(3);
IQArray <Qubit> controls = new QArray <Qubit>(new[] { control1 });
var op = new QrackSimulator().Get <Intrinsic.CCNOT>().Controlled;
var args = op.__DataIn__((controls, (control2, control3, target)));
var expected = new RuntimeMetadata()
{
Label = "X",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = true,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
control1, control2, control3
},
Targets = new List <Qubit>()
{
target
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void FooUDTOp()
{
Qubit target = new FreeQubit(0);
var op = new QrackSimulator().Get <Tests.Circuits.FooUDTOp>();
var args = op.__DataIn__(new Circuits.FooUDT(("bar", (target, 2.1))));
var expected = new RuntimeMetadata()
{
Label = "FooUDTOp",
FormattedNonQubitArgs = "(\"bar\", (" + 2.1 + "))",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
target
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void CNOT()
{
var control = new FreeQubit(1);
var target = new FreeQubit(0);
var op = new QrackSimulator().Get <Intrinsic.CNOT>();
var args = op.__DataIn__((control, target));
var expected = new RuntimeMetadata()
{
Label = "X",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = true,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
control
},
Targets = new List <Qubit>()
{
target
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void AdjointAdjointH()
{
Qubit target = new FreeQubit(0);
var op = new QrackSimulator().Get <Intrinsic.H>().Adjoint.Adjoint;
var args = op.__DataIn__(target);
var expected = new RuntimeMetadata()
{
Label = "H",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
target
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void PartialRy()
{
var target = new FreeQubit(0);
var op = new QrackSimulator().Get <Intrinsic.Ry>().Partial((double d) =>
new ValueTuple <double, Qubit>(d, target));
var args = op.__DataIn__(2.1);
var expected = new RuntimeMetadata()
{
Label = "Ry",
FormattedNonQubitArgs = "(" + 2.1 + ")",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
target
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void ControlledAdjointAdjointH()
{
IQArray <Qubit> controls = new QArray <Qubit>(new[] { new FreeQubit(0) });
Qubit target = new FreeQubit(1);
var op1 = new QrackSimulator().Get <Intrinsic.H>().Controlled.Adjoint.Adjoint;
var op2 = new QrackSimulator().Get <Intrinsic.H>().Adjoint.Controlled.Adjoint;
var op3 = new QrackSimulator().Get <Intrinsic.H>().Adjoint.Adjoint.Controlled;
var args = op1.__DataIn__((controls, target));
var expected = new RuntimeMetadata()
{
Label = "H",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = true,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = controls,
Targets = new List <Qubit>()
{
target
},
};
Assert.Equal(op1.GetRuntimeMetadata(args), expected);
Assert.Equal(op2.GetRuntimeMetadata(args), expected);
Assert.Equal(op3.GetRuntimeMetadata(args), expected);
}
public void AllocateQubit2Test()
{
using var sim = new QrackSimulator();
try
{
IgnorableAssert.Disable();
QVoid res = sim.Execute <AllocateQubit2, QVoid, QVoid>(QVoid.Instance);
}
catch (ExecutionFailException)
{
var stackFrames = sim.CallStack;
// Make sure that the call stack isn't null before proceeding.
Assert.NotNull(stackFrames);
// The following assumes that Assert is on Q# stack.
Assert.Equal(2, stackFrames !.Length);
Assert.Equal("Microsoft.Quantum.Diagnostics.AssertMeasurementProbability", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "AllocateQubit2", stackFrames[1].Callable.FullName);
Assert.Equal(OperationFunctor.Body, stackFrames[0].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[1].Callable.Variant);
Assert.Equal(94, stackFrames[1].FailedLineNumber);
}
finally
{
IgnorableAssert.Enable();
}
}
public async Task ReallocateQubitInGroundStateTest()
{
var sim = new QrackSimulator();
var allocate = sim.Get<Intrinsic.Allocate>();
var release = sim.Get<Intrinsic.Release>();
var q1 = allocate.Apply(1);
var q1Id = q1[0].Id;
var gate = sim.Get<Intrinsic.X>();
var measure = sim.Get<Intrinsic.M>();
gate.Apply(q1[0]);
var result1 = measure.Apply(q1[0]);
//Check X operation
Assert.Equal(result1, Result.One);
release.Apply(q1[0]);
var q2 = allocate.Apply(1);
var q2Id = q2[0].Id;
//Assert reallocated qubit has the same id as the one released
Assert.Equal(q1Id, q2Id);
var result2 = measure.Apply(q2[0]);
//Assert reallocated qubit has is initialized in state |0>
Assert.Equal(result2, Result.Zero);
}
public void PartialUDT()
{
var target = new FreeQubit(0);
var op = new QrackSimulator().Get <ICallable <(String, (Qubit, Double)), Circuits.FooUDT> >(typeof(Circuits.FooUDT))
.Partial <double>((double d) => (("bar", (target, d))));
var args = new QTuple <double>(2.1);
var expected = new RuntimeMetadata()
{
Label = "FooUDT",
FormattedNonQubitArgs = "(\"bar\", (" + 2.1 + "))",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public async Task MeasuredQubitReleaseTest()
{
var sim = new QrackSimulator();
//should not throw an exception, as Measured qubits are allowed to be released, and the release aspect is handled in the C++ code
await ReleaseMeasuredQubitCheck.Run(sim);
}
public void DuplicateQubitArgs()
{
var q = new FreeQubit(0);
var op = new QrackSimulator().Get <Circuits.TwoQubitOp>();
var args = op.__DataIn__((q, q));
var expected = new RuntimeMetadata()
{
Label = "TwoQubitOp",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
q
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void MResetZ()
{
var measureQubit = new FreeQubit(0);
var op = new QrackSimulator().Get <Measurement.MResetZ>();
var args = op.__DataIn__(measureQubit);
var expected = new RuntimeMetadata()
{
Label = "MResetZ",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = true,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
measureQubit
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void AlwaysFail4Test()
{
using (var sim = new QrackSimulator())
{
try
{
QVoid res = AlwaysFail4.Run(sim).Result;
}
catch (AggregateException ex)
{
Assert.True(ex.InnerException is ExecutionFailException);
StackFrame[] stackFrames = sim.CallStack;
Assert.Equal(5, stackFrames.Length);
Assert.Equal(namespacePrefix + "AlwaysFail", stackFrames[0].Callable.FullName);
Assert.Equal(namespacePrefix + "AlwaysFail1", stackFrames[1].Callable.FullName);
Assert.Equal(namespacePrefix + "AlwaysFail2", stackFrames[2].Callable.FullName);
Assert.Equal(namespacePrefix + "AlwaysFail3", stackFrames[3].Callable.FullName);
Assert.Equal(namespacePrefix + "AlwaysFail4", stackFrames[4].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(OperationFunctor.Adjoint, stackFrames[3].Callable.Variant);
Assert.Equal(OperationFunctor.Body, stackFrames[4].Callable.Variant);
Assert.Equal(14, stackFrames[2].FailedLineNumber);
Assert.Equal(21, stackFrames[4].FailedLineNumber);
// For Adjoint and Controlled we expect failedLineNumber to be equal to declarationStartLineNumber
Assert.Equal(stackFrames[0].DeclarationStartLineNumber, stackFrames[0].FailedLineNumber);
Assert.Equal(stackFrames[1].DeclarationStartLineNumber, stackFrames[1].FailedLineNumber);
Assert.Equal(stackFrames[3].DeclarationStartLineNumber, stackFrames[3].FailedLineNumber);
for (int i = 0; i < stackFrames.Length; ++i)
{
Assert.StartsWith(@"https://github.com/", stackFrames[i].GetURLFromPDB());
Assert.EndsWith($"#L{stackFrames[i].FailedLineNumber}", stackFrames[i].GetURLFromPDB());
}
StringBuilder builder = new StringBuilder();
builder.Append("13 ".PadLeft(PortablePDBEmbeddedFilesCache.lineNumberPaddingWidth));
builder.AppendLine(" operation AlwaysFail2() : Unit is Adj + Ctl {");
builder.Append("14 ".PadLeft(PortablePDBEmbeddedFilesCache.lineNumberPaddingWidth) + PortablePDBEmbeddedFilesCache.lineMarkPrefix);
builder.AppendLine(" Controlled AlwaysFail1(new Qubit[0],());");
builder.Append("15 ".PadLeft(PortablePDBEmbeddedFilesCache.lineNumberPaddingWidth));
builder.AppendLine(" }");
Assert.Equal(builder.ToString(), stackFrames[2].GetOperationSourceFromPDB());
for (int i = 0; i < stackFrames.Length; ++i)
{
output.WriteLine($"operation:{stackFrames[i].Callable.FullName}");
output.WriteLine(stackFrames[i].GetOperationSourceFromPDB());
}
}
}
}
//[OperationDriver(TestCasePrefix = "QrackSim:", TestNamespace = "Microsoft.Quantum.Simulation.TestSuite.VeryLong")]
private void QrackSimTestTargetVeryLong(TestOperation op)
{
using (var sim = new QrackSimulator(throwOnReleasingQubitsNotInZeroState: true))
{
sim.OnLog += (msg) => { output.WriteLine(msg); };
op.TestOperationRunner(sim);
}
}
public void OperationTypes()
{
var op = new QrackSimulator().Get <Intrinsic.H>();
Assert.Equal("H", op.GetNonQubitArgumentsAsString());
var op2 = new QrackSimulator().Get <Intrinsic.CNOT>();
Assert.Equal("CNOT", op2.GetNonQubitArgumentsAsString());
}
public void TupleTypes()
{
Assert.Equal("(1, 2)", (1, 2).GetNonQubitArgumentsAsString());
Assert.Equal("(\"foo\", \"bar\")", ("foo", "bar").GetNonQubitArgumentsAsString());
Assert.Equal("(\"foo\", \"bar\", \"\")", ("foo", "bar", "").GetNonQubitArgumentsAsString());
Assert.Equal("(\"foo\", (\"bar\", \"car\"))", ("foo", ("bar", "car")).GetNonQubitArgumentsAsString());
Assert.Equal("((\"foo\"), (\"bar\", \"car\"))", (("foo", new FreeQubit(0)), ("bar", "car")).GetNonQubitArgumentsAsString());
var op = new QrackSimulator().Get <Intrinsic.H>();
var opTuple = new QTuple <(ICallable, string)>((op, "foo"));
Assert.Equal("(H, \"foo\")", opTuple.GetNonQubitArgumentsAsString());
var qtuple = new QTuple <(Qubit, string)>((new FreeQubit(0), "foo"));
Assert.Equal("(\"foo\")", qtuple.GetNonQubitArgumentsAsString());
}
public void QrackSimTestTargetFailures(TestOperation op)
{
using (var sim = new QrackSimulator(throwOnReleasingQubitsNotInZeroState: true))
{
sim.OnLog += (msg) => { output.WriteLine(msg); };
Action action = () => op.TestOperationRunner(sim);
bool hasThrown = false;
try
{
action.IgnoreDebugAssert();
}
catch (ExecutionFailException)
{
hasThrown = true;
}
Assert.True(hasThrown, "The operation was known to throw. It does not throw anymore. Congratulations ! You fixed the bug.");
}
}
public void QrackSimX()
{
using (var sim = new QrackSimulator(throwOnReleasingQubitsNotInZeroState: false))
{
var x = sim.Get <Intrinsic.X>();
var measure = sim.Get <Intrinsic.M>();
var set = sim.Get <Measurement.SetToBasisState>();
var ctrlX = x.__ControlledBody__.AsAction();
OperationsTestHelper.ctrlTestShell(sim, ctrlX, (enabled, ctrls, q) =>
{
set.Apply((Result.Zero, q));
var result = measure.Apply(q);
var expected = Result.Zero;
Assert.Equal(expected, result);
x.__ControlledBody__((ctrls, q));
result = measure.Apply(q);
expected = (enabled) ? Result.One : Result.Zero;
Assert.Equal(expected, result);
});
public void ResetAll()
{
IQArray <Qubit> targets = new QArray <Qubit>(new[] { new FreeQubit(0) });
var op = new QrackSimulator().Get <Intrinsic.ResetAll>();
var args = op.__DataIn__(targets);
var expected = new RuntimeMetadata()
{
Label = "ResetAll",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = true,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = targets,
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void NestedOperation()
{
var op = new QrackSimulator().Get <Circuits.NestedOp>();
var args = op.__DataIn__(QVoid.Instance);
var expected = new RuntimeMetadata()
{
Label = "NestedOp",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public void QArrayArgs()
{
var op = new QrackSimulator().Get <Circuits.BoolArrayOp>();
IQArray <Boolean> bits = new QArray <Boolean>(new bool[] { false, true });
var args = op.__DataIn__(bits);
var expected = new RuntimeMetadata()
{
Label = "BoolArrayOp",
FormattedNonQubitArgs = "[False, True]",
IsAdjoint = false,
IsControlled = false,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = new List <Qubit>()
{
},
Targets = new List <Qubit>()
{
},
};
Assert.Equal(op.GetRuntimeMetadata(args), expected);
}
public async Task MeasuredMultipleQubitsReleaseTest()
{
var sim = new QrackSimulator();
await Assert.ThrowsAsync<ReleasedQubitsAreNotInZeroState>(() => ReleaseMeasureMultipleQubitCheck.Run(sim));
}
public async Task ZeroStateQubitReleaseTest()
{
var sim = new QrackSimulator();
await Assert.ThrowsAsync<ReleasedQubitsAreNotInZeroState>(() => UsingQubitCheck.Run(sim));
}
