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 Reset()
{
var target = new FreeQubit(0);
var op = new QuantumSimulator().Get <Intrinsic.Reset>();
var args = op.__dataIn(target);
var expected = new RuntimeMetadata()
{
Label = "Reset",
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 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 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 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 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 ControlledCNOT()
{
IQArray <Qubit> controls = new QArray <Qubit>(new[] { new FreeQubit(0) });
Qubit control = new FreeQubit(1);
Qubit target = new FreeQubit(2);
var op = new QuantumSimulator().Get <Intrinsic.CNOT>().Controlled;
var args = op.__dataIn((controls, (control, target)));
var expected = new RuntimeMetadata()
{
Label = "X",
FormattedNonQubitArgs = "",
IsAdjoint = false,
IsControlled = true,
IsMeasurement = false,
IsComposite = false,
Children = null,
Controls = controls.Append(control),
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 StartUDTDataIn()
{
Helper.RunWithMultipleSimulators((s) =>
{
var basic = new UDT1(s.Get <Basic>());
var q1 = new FreeQubit(1);
var q2 = new FreeQubit(2);
var q3 = new FreeQubit(3);
var expected = (1L, q1, (q2, q3), Result.One);
var m1 = new Func <(Qubit, Qubit), (Int64, Qubit, (Qubit, Qubit), Result)>((_arg1) => (1L, q1, (_arg1.Item1, _arg1.Item2), Result.One));
var m2 = new Func <Qubit, (Qubit, Qubit)>((_arg2) => (_arg2, q3));
var p1 = ((Basic)basic.Data).Partial(m1);
var p2 = p1.Partial(m2);
AssertTuple(expected, p1.__dataIn((q2, q3)).Value);
AssertTuple(expected, p2.__dataIn((q2)).Value);
Assert.Equal(new Qubit[] { q1, q2, q3 }, p1.__dataIn((q2, q3)).Qubits);
Assert.Equal(new Qubit[] { q1, q2, q3 }, p2.__dataIn(q2).Qubits);
Assert.Null(((IApplyData)basic).Qubits);
Assert.Equal(new Qubit[] { q1, null, null }, ((IApplyData)p1).Qubits);
Assert.Equal(new Qubit[] { q1, null, q3 }, ((IApplyData)p2).Qubits);
});
}
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 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 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 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 ToStringTests()
{
Helper.RunWithMultipleSimulators((qsim) =>
{
var _ = AbstractCallable._;
var dump = qsim.Get <ICallable>(typeof(Microsoft.Quantum.Extensions.Diagnostics.DumpMachine <>));
var trace = qsim.Get <IUnitary>(typeof(Circuits.Generics.Trace <>));
var x = qsim.Get <Intrinsic.X>();
var q2 = new FreeQubit(2) as Qubit;
var Q = new Q(q2);
var Qs = new QArray <Qubit>(q2);
var qs = new Qs(Qs);
var udtOp = new U3(x);
var udtQ = new Q(q2);
var t1 = new QTuple <(long, Range, (Qubit, IUnitary))>((1L, new Range(10, -2, 4), (q2, x)));
var t4 = new T4((3L, (1.1, false, Result.One)));
var t5 = new T5((Pauli.PauliX, Qs, qs, Q));
var d_1 = dump.Partial(_);
var d_2 = d_1.Partial(_);
var x_1 = x.Partial(new Func <Qubit, Qubit>(q => q));
var x_2 = x_1.Partial(new Func <Qubit, Qubit>(q => q));
var x_3 = x.Partial <OperationPartial <Qubit, Qubit, QVoid> >(_);
var t_1 = trace.Adjoint.Partial(_);
var t_2 = t_1.Controlled.Partial(_);
Assert.Equal("()", QVoid.Instance.ToString());
Assert.Equal("_", _.ToString());
Assert.Equal("U3(X)", udtOp.ToString());
Assert.Equal("q:2", q2.ToString());
Assert.Equal("Q(q:2)", udtQ.ToString());
Assert.Equal("(1, 10..-2..4, (q:2, X))", t1.ToString());
Assert.Equal("T4((3, (1.1, False, One)))", t4.ToString());
Assert.Equal("T5((PauliX, [q:2], Qs([q:2]), Q(q:2)))", t5.ToString());
Assert.Equal("X", x.ToString());
Assert.Equal("(Adjoint X)", x.Adjoint.ToString());
Assert.Equal("(Controlled X)", x.Controlled.ToString());
Assert.Equal("(Adjoint (Controlled X))", x.Controlled.Adjoint.ToString());
Assert.Equal("(Controlled (Adjoint X))", x.Adjoint.Controlled.ToString());
Assert.Equal("X{_}", x_1.ToString());
Assert.Equal("(Adjoint X{_})", x_1.Adjoint.ToString());
Assert.Equal("X{_}{_}", x_2.ToString());
Assert.Equal("X{_}", x_3.ToString());
Assert.Equal("DumpMachine", dump.ToString());
Assert.Equal("DumpMachine{_}", d_1.ToString());
Assert.Equal("DumpMachine{_}{_}", d_2.ToString());
Assert.Equal("Trace", trace.ToString());
Assert.Equal("(Adjoint Trace)", trace.Adjoint.ToString());
Assert.Equal("(Controlled Trace)", trace.Controlled.ToString());
Assert.Equal("(Adjoint (Controlled Trace))", trace.Controlled.Adjoint.ToString());
Assert.Equal("(Adjoint Trace){_}", t_1.ToString());
Assert.Equal("(Adjoint (Controlled (Adjoint Trace){_}){_})", t_2.Adjoint.ToString());
});
}
public void StartOperationCalls()
{
Helper.RunWithMultipleSimulators((s) =>
{
var tracker = new StartTracker(s);
StartOperationTest.Run(s).Wait();
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
var q3 = new FreeQubit(3) as Qubit;
Assert.Equal(1, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.StartOperationTest"));
var allVariantsBody = 3;
var allVariantsAdjoint = 2;
var allVariantsCtrl = 2;
var allVariantsAdjointCtrl = 1;
var allVariants = allVariantsBody + allVariantsAdjoint + allVariantsCtrl + allVariantsAdjointCtrl;
Assert.Equal(allVariants, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.AllVariants"));
Assert.Equal(allVariantsBody, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.AllVariants", OperationFunctor.Body));
Assert.Equal(allVariantsAdjoint, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.AllVariants", OperationFunctor.Adjoint));
Assert.Equal(allVariantsCtrl, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.AllVariants", OperationFunctor.Controlled));
Assert.Equal(allVariantsAdjointCtrl, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.AllVariants", OperationFunctor.ControlledAdjoint));
var basicBody = 9;
var basicAdjoint = 7;
var basicCtrl = 9;
var basicCtrlAdjoint = 7;
var basic = basicBody + basicAdjoint + basicCtrl + basicCtrlAdjoint;
Assert.Equal(basic, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic"));
Assert.Equal(basicBody, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Body));
Assert.Equal(basicAdjoint, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Adjoint));
Assert.Equal(basicCtrl, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Controlled));
Assert.Equal(basicCtrlAdjoint, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.ControlledAdjoint));
var data1 = (0L, q1, (q2, q3), Result.One);
Assert.Equal(3, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Body, data1));
Assert.Equal(3, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Adjoint, data1));
var data2 = (1L, q1, (q2, q3), Result.Zero);
Assert.Equal(6, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Body, data2));
Assert.Equal(4, tracker.GetNumberOfCalls("Microsoft.Quantum.Tests.StartOperation.Basic", OperationFunctor.Adjoint, data2));
Assert.Equal(basic * 4, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.X"));
Assert.Equal(basicBody * 4, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.X", OperationFunctor.Body));
Assert.Equal(basicAdjoint * 4, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.X", OperationFunctor.Adjoint));
Assert.Equal(basicCtrl * 4, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.X", OperationFunctor.Controlled));
Assert.Equal(basicCtrlAdjoint * 4, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.X", OperationFunctor.ControlledAdjoint));
});
}
public void ApplyToEachUdt()
{
Helper.RunWithMultipleSimulators((s) =>
{
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
TestApplyToEachUdt.Run(s).Wait();
var tracer = s.GetTracer <Qubit>();
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Controlled, q0));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Controlled, q1));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Controlled, q2));
});
}
public void QubitTypes()
{
var q = new FreeQubit(0);
Assert.Null(q.GetNonQubitArgumentsAsString());
var qs = new QArray <Qubit>(new[] { new FreeQubit(0) });
Assert.Null(qs.GetNonQubitArgumentsAsString());
qs = new QArray <Qubit>(new[] { new FreeQubit(0), new FreeQubit(1) });
Assert.Null(qs.GetNonQubitArgumentsAsString());
var qtuple = new QTuple <Qubit>(q);
Assert.Null(qtuple.GetNonQubitArgumentsAsString());
}
public void QSharpTypeTests()
{
Helper.RunWithMultipleSimulators((qsim) =>
{
var _ = AbstractCallable._;
var x = qsim.Get <Intrinsic.X>();
var q2 = new FreeQubit(2) as Qubit;
var Q = new Q(q2);
var Qs = new QArray <Qubit>(q2);
var qs = new Qs(Qs);
var udtOp = new U3(x);
var udtQ = new Q(q2);
var t4 = new T4((3L, (1.1, false, Result.One)));
var t5 = new T5((Pauli.PauliX, Qs, qs, Q));
var plain = qsim.Get <BPlain1>();
var adj = qsim.Get <BAdj1>();
var ctrl = qsim.Get <BCtrl1>();
var mapper = qsim.Get <Circuits.ClosedType.Map>();
Assert.Equal("()", typeof(QVoid).QSharpType());
Assert.Equal("_", _.GetType().QSharpType());
Assert.Equal("U3", udtOp.GetType().QSharpType());
Assert.Equal("Qubit => () : Adjoint, Controlled", udtOp.Data.GetType().QSharpType());
Assert.Equal("Qubit", q2.GetType().QSharpType());
Assert.Equal("Q", udtQ.GetType().QSharpType());
Assert.Equal("Qubit", udtQ.Data.GetType().QSharpType());
Assert.Equal("T4", t4.GetType().QSharpType());
Assert.Equal("(Int,(Double,Boolean,Result))", t4.Data.GetType().QSharpType());
Assert.Equal("T5", t5.GetType().QSharpType());
Assert.Equal("(Pauli,Qubit[],Qs,Q)", t5.Data.GetType().QSharpType());
Assert.Equal("Qubit => () : Adjoint, Controlled", x.GetType().QSharpType());
Assert.Equal("Qubit => () : Adjoint, Controlled", x.Adjoint.GetType().QSharpType());
Assert.Equal("(Qubit[],Qubit) => () : Adjoint, Controlled", x.Controlled.GetType().QSharpType());
Assert.Equal("(Qubit[],Qubit) => () : Adjoint, Controlled", x.Controlled.Adjoint.GetType().QSharpType());
Assert.Equal("(Int,Qubit,Callable) => ()", plain.GetType().QSharpType());
Assert.Equal("(Int,(Qubit,Qubit,Qubit[]),Adjointable) => () : Adjoint", adj.GetType().QSharpType());
Assert.Equal("(Int,Qs,Controllable) => () : Controlled", ctrl.GetType().QSharpType());
Assert.Equal("(Callable,Result[]) => String[]", mapper.GetType().QSharpType());
});
}
public void ControlledBitString()
{
Helper.RunWithMultipleSimulators((s) =>
{
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
TestControlledBitString.Run(s).Wait();
var tracer = s.GetTracer <long>();
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, 0));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, 1));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Body, 2));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Adjoint, 0));
Assert.Equal(0, tracer.Log.GetNumberOfCalls(OperationFunctor.Adjoint, 1));
Assert.Equal(1, tracer.Log.GetNumberOfCalls(OperationFunctor.Adjoint, 2));
var stracer = s.GetTracer <string>();
Assert.Equal(1, stracer.Log.GetNumberOfCalls(OperationFunctor.Controlled, "ok"));
});
}
public void UdtData()
{
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
var q3 = new FreeQubit(3) as Qubit;
var q4 = new FreeQubit(4) as Qubit;
var q5 = new FreeQubit(5) as Qubit;
var q6 = new FreeQubit(6) as Qubit;
var op = new Op1(null) as IUnitary;
var f1 = new F1(null);
var qubits = new QArray <Qubit>(q2, q4, q6);
var dataA = (1L, Pauli.PauliY, q1, (q4, 3L, q5));
var dataB = ((1L, 2L), (q6, (3L, (q4, q6)), 3.5));
var dataC = (q5, new TupleB(dataB));
var dataD = new QArray <Qubit>(q1, q2, q3, q4, q6);
var dataE = (4L, (IQArray <Qubit>)qubits);
var dataF = op;
var dataG = (q3, new TupleF(dataF), new TupleC(dataC), new TupleD(dataD));
var dataQ = ((1L, 2L), (q1, (3L, (q2, q3)), 3.5));
var dataH = (new TupleD(dataD), new TupleG(dataG));
var dataI = f1;
AssertOneData(dataQ, typeof(QTuple <((Int64, Int64), (Qubit, (Int64, (Qubit, Qubit)), Double))>));
AssertOneData(((ICallable)null), typeof(QTuple <ICallable>));
AssertOneData(q3, typeof(Q));
AssertOneData(dataA, typeof(TupleA));
AssertOneData(dataB, typeof(TupleB));
AssertOneData(dataC, typeof(TupleC));
AssertOneData(dataD, typeof(TupleD));
AssertOneData(dataE, typeof(TupleE));
AssertOneData(dataF, typeof(TupleF));
AssertOneData(dataG, typeof(TupleG));
AssertOneData(dataH, typeof(TupleH));
AssertOneData(dataI, typeof(TupleI));
}
public void EmptyOperation()
{
var measureQubit = new FreeQubit(0);
var op = new QrackSimulator().Get <Circuits.Empty>();
var args = op.__DataIn__(QVoid.Instance);
var expected = new RuntimeMetadata()
{
Label = "Empty",
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 Borrowing()
{
OperationsTestHelper.RunWithMultipleSimulators((s) =>
{
var tracker = new StartTracker(s);
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
var q3 = new FreeQubit(3) as Qubit;
var q4 = new FreeQubit(4) as Qubit;
var q5 = new FreeQubit(5) as Qubit;
var q6 = new FreeQubit(6) as Qubit;
var q7 = new FreeQubit(7) as Qubit;
var q8 = new FreeQubit(8) as Qubit;
BorrowingTest.Run(s).Wait();
var tracer = OperationsTestHelper.GetTracer <(long, Qubit)>(s);
var testOne = new Action <int, OperationFunctor, (int, Qubit)>((int callsCount, OperationFunctor variant, (int, Qubit)info) =>
{
var(available, q) = info;
Assert.Equal(callsCount, tracer.Log.GetNumberOfCalls(variant, (available, q)));
});
var testOneBody = new Action <int, (int, Qubit)>((callsCount, info) => testOne(callsCount, OperationFunctor.Body, info));
var testOneAdjoint = new Action <int, (int, Qubit)>((callsCount, info) => testOne(callsCount, OperationFunctor.Adjoint, info));
var testOneCtrl = new Action <int, (int, Qubit)>((callsCount, info) => testOne(callsCount, OperationFunctor.Controlled, info));
var testOneCtrlAdj = new Action <int, (int, Qubit)>((callsCount, info) => testOne(callsCount, OperationFunctor.ControlledAdjoint, info));
testOneBody(6, (0, q5));
testOneBody(6, (0, q6));
testOneBody(1, (1, q0));
testOneBody(1, (1, q1));
testOneBody(1, (1, q4));
testOneBody(1, (1, q5));
testOneBody(2, (1, q6));
testOneBody(2, (2, q2));
testOneBody(2, (2, q3));
testOneBody(1, (3, q0));
testOneBody(1, (3, q1));
testOneBody(1, (3, q2));
testOneBody(3, (3, q3));
testOneBody(2, (4, q0));
testOneBody(1, (4, q1));
testOneBody(3, (4, q2));
testOneBody(5, (5, q0));
testOneBody(5, (5, q1));
testOneAdjoint(3, (0, q5));
testOneAdjoint(3, (0, q6));
testOneAdjoint(1, (1, q0));
testOneAdjoint(1, (1, q1));
testOneAdjoint(1, (1, q4));
testOneAdjoint(2, (1, q5));
testOneAdjoint(1, (1, q6));
testOneAdjoint(2, (2, q2));
testOneAdjoint(2, (2, q3));
testOneAdjoint(1, (3, q2));
testOneAdjoint(1, (3, q3));
testOneAdjoint(1, (4, q0));
testOneAdjoint(1, (4, q1));
testOneAdjoint(2, (4, q2));
testOneAdjoint(2, (5, q0));
testOneAdjoint(2, (5, q1));
testOneCtrl(3, (0, q7));
testOneCtrl(3, (0, q8));
testOneCtrl(1, (1, q0));
testOneCtrl(1, (1, q1));
testOneCtrl(1, (1, q4));
testOneCtrl(1, (1, q5));
testOneCtrl(1, (1, q6));
testOneCtrl(0, (2, q0));
testOneCtrl(0, (2, q1));
testOneCtrl(2, (2, q2));
testOneCtrl(2, (2, q3));
testOneCtrl(1, (3, q2));
testOneCtrl(1, (3, q3));
testOneCtrl(1, (4, q0));
testOneCtrl(1, (4, q1));
testOneCtrl(2, (4, q2));
testOneCtrl(3, (5, q0));
testOneCtrl(3, (5, q1));
testOneCtrlAdj(3, (0, q7));
testOneCtrlAdj(3, (0, q8));
testOneCtrlAdj(1, (1, q4));
testOneCtrlAdj(1, (1, q7));
testOneCtrlAdj(2, (2, q2));
testOneCtrlAdj(2, (2, q3));
testOneCtrlAdj(1, (3, q2));
testOneCtrlAdj(1, (3, q3));
testOneCtrlAdj(1, (4, q0));
testOneCtrlAdj(1, (4, q1));
testOneCtrlAdj(2, (4, q2));
testOneCtrlAdj(2, (5, q0));
testOneCtrlAdj(2, (5, q1));
Assert.Equal(20, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.SWAP", OperationFunctor.Body));
Assert.Equal(11, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.SWAP", OperationFunctor.Adjoint));
Assert.Equal(16, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.SWAP", OperationFunctor.Controlled));
Assert.Equal(13, tracker.GetNumberOfCalls("Microsoft.Quantum.Intrinsic.SWAP", OperationFunctor.ControlledAdjoint));
});
public void TupleBasicConstructor()
{
var AssertQubitsCount = new Action <int, IApplyData>((count, t) =>
{
var qubits = t.Qubits;
if (count == 0)
{
Assert.True(qubits == null || qubits?.Where(q => q != null).Count() == 0);
}
else
{
Assert.Equal(count, qubits?.Where(q => q != null).Count());
}
});
var q0 = new FreeQubit(0) as Qubit;
var q1 = new FreeQubit(1) as Qubit;
var q2 = new FreeQubit(2) as Qubit;
{
var actual = new Q(q0);
Assert.Equal(q0, ((IApplyData)actual).Value);
AssertQubitsCount(1, actual);
}
{
var actual = new I(32L);
Assert.Equal(32L, ((IApplyData)actual).Value);
AssertQubitsCount(0, actual);
}
{
var data = (2L, Pauli.PauliY, q1, (q0, -7L, null as Qubit));
var actual = new TupleA(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(2, actual);
}
{
var data = (q1, new TupleB(((2L, 3L), (q1, (4L, (q0, q2)), 3.0))));
var actual = new TupleC(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(4, actual);
}
{
var data = new QArray <Qubit>(q1, q2, q0, q0, q1);
var actual = new TupleD(data);
Assert.Equal((IQArray <Qubit>)data, ((IApplyData)actual).Value);
AssertQubitsCount(5, actual);
}
{
var data = (5L, new QArray <Qubit>(q1, q2, q0));
var actual = new TupleE(data);
Assert.Equal((data.Item1, (IQArray <Qubit>)data.Item2), ((IApplyData)actual).Value);
AssertQubitsCount(3, actual);
}
{
var data = new UnitaryNoOp <(TupleA, TupleD)>();
var actual = new TupleF(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(0, actual);
}
{
var op = new UnitaryNoOp <(TupleA, TupleD)>();
var mapper = new Func <(TupleA, TupleD), (IQArray <Qubit>, (TupleA, TupleD))>((_arg) => (new QArray <Qubit>(q1, q2), _arg));
var data = op.Controlled.Partial(mapper);
var actual = new TupleF(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(2, actual);
}
{
var data = (new TupleD(new QArray <Qubit>(q1, q2, q0)), new TupleG());
var actual = new TupleH(data);
Assert.Equal(data, ((IApplyData)actual).Value);
AssertQubitsCount(3, actual);
}
{
var data = new QArray <(Int64, Qubit)>((1L, q1));
var actual = new TupleJ(data);
Assert.Equal((IQArray <(Int64, Qubit)>)data, ((IApplyData)actual).Value);
AssertQubitsCount(1, actual);
}
}
