Skip to content
This repository was archived by the owner on Jan 12, 2024. It is now read-only.

Cleaning up the classical control in the tracer #354

Merged
swernli merged 1 commit into from
Aug 21, 2020
Merged

Cleaning up the classical control in the tracer #354

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
72 changes: 8 additions & 64 deletions src/Simulation/Simulators/QCTraceSimulator/Circuits/ClassicalControl.qs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,93 +7,37 @@ namespace Microsoft.Quantum.Simulation.Simulators.QCTraceSimulators.Circuits

// Private helper operations.
operation ApplyIfElseIntrinsic(measurementResult : Result, onResultZeroOp : (Unit => Unit) , onResultOneOp : (Unit => Unit)) : Unit {
body (...) {
Interface_ApplyIfElse(measurementResult, onResultZeroOp, onResultOneOp);
}
Interface_ApplyIfElse(measurementResult, onResultZeroOp, onResultOneOp);
}

operation ApplyIfElseIntrinsicA(measurementResult : Result, onResultZeroOp : (Unit => Unit is Adj) , onResultOneOp : (Unit => Unit is Adj)) : Unit is Adj {
body (...) {
Interface_ApplyIfElse(measurementResult, onResultZeroOp, onResultOneOp);
}

adjoint (...) {
Interface_ApplyIfElseA(measurementResult, onResultZeroOp, onResultOneOp);
}
Interface_ApplyIfElseA(measurementResult, onResultZeroOp, onResultOneOp);
}

operation ApplyIfElseIntrinsicC(measurementResult : Result, onResultZeroOp : (Unit => Unit is Ctl) , onResultOneOp : (Unit => Unit is Ctl)) : Unit is Ctl {
body (...) {
Interface_ApplyIfElse(measurementResult, onResultZeroOp, onResultOneOp);
}

controlled (ctrls, ...) {
Interface_ApplyIfElseC(ctrls, measurementResult, onResultZeroOp, onResultOneOp);
}
Interface_ApplyIfElseC(measurementResult, onResultZeroOp, onResultOneOp);
}

operation ApplyIfElseIntrinsicCA(measurementResult : Result, onResultZeroOp : (Unit => Unit is Ctl + Adj) , onResultOneOp : (Unit => Unit is Ctl + Adj)) : Unit is Ctl + Adj {
body (...) {
Interface_ApplyIfElse(measurementResult, onResultZeroOp, onResultOneOp);
}

adjoint (...) {
Interface_ApplyIfElseA(measurementResult, onResultZeroOp, onResultOneOp);
}

controlled (ctrls, ...) {
Interface_ApplyIfElseC(ctrls, measurementResult, onResultZeroOp, onResultOneOp);
}

controlled adjoint (ctrls, ...) {
Interface_ApplyIfElseCA(ctrls, measurementResult, onResultZeroOp, onResultOneOp);
}
Interface_ApplyIfElseCA(measurementResult, onResultZeroOp, onResultOneOp);
}


// Private helper operations.
operation ApplyConditionallyIntrinsic(measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit) , onNonEqualOp : (Unit => Unit)) : Unit {
body (...) {
Interface_ApplyConditionally(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}
Interface_ApplyConditionally(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

operation ApplyConditionallyIntrinsicA(measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit is Adj) , onNonEqualOp : (Unit => Unit is Adj)) : Unit is Adj {
body (...) {
Interface_ApplyConditionally(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

adjoint (...) {
Interface_ApplyConditionallyA(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}
Interface_ApplyConditionallyA(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

operation ApplyConditionallyIntrinsicC(measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit is Ctl) , onNonEqualOp : (Unit => Unit is Ctl)) : Unit is Ctl {
body (...) {
Interface_ApplyConditionally(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

controlled (ctrls, ...) {
Interface_ApplyConditionallyC(ctrls, measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}
Interface_ApplyConditionallyC(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

operation ApplyConditionallyIntrinsicCA(measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit is Ctl + Adj) , onNonEqualOp : (Unit => Unit is Ctl + Adj)) : Unit is Ctl + Adj {
body (...) {
Interface_ApplyConditionally(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

adjoint (...) {
Interface_ApplyConditionallyA(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

controlled (ctrls, ...) {
Interface_ApplyConditionallyC(ctrls, measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

controlled adjoint (ctrls, ...) {
Interface_ApplyConditionallyCA(ctrls, measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}
Interface_ApplyConditionallyCA(measurementResults, resultsValues, onEqualOp, onNonEqualOp);
}

}
52 changes: 44 additions & 8 deletions src/Simulation/Simulators/QCTraceSimulator/Circuits/Interface.qs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -81,39 +81,60 @@ namespace Microsoft.Quantum.Simulation.Simulators.QCTraceSimulators.Implementati
/// <summary>
/// Performs the onResultZeroOp when measurementResult is Zero, else performs the onResultOneOp.
/// </summary>
operation Interface_ApplyIfElse (measurementResult : Result, onResultZeroOp : (Unit => Unit) , onResultOneOp : (Unit => Unit)) : Unit {
operation Interface_ApplyIfElse (
measurementResult : Result,
onResultZeroOp : (Unit => Unit),
onResultOneOp : (Unit => Unit)
) : Unit {
body intrinsic;
}

/// <summary>
/// Performs the onResultZeroOp when measurementResult is Zero, else performs the onResultOneOp.
/// onReusltZeroOp and onResultOneOp must both be adjointable.
/// </summary>
operation Interface_ApplyIfElseA (measurementResult : Result, onResultZeroOp : (Unit => Unit is Adj) , onResultOneOp : (Unit => Unit is Adj)) : Unit {
operation Interface_ApplyIfElseA (
measurementResult : Result,
onResultZeroOp : (Unit => Unit is Adj),
onResultOneOp : (Unit => Unit is Adj)
) : Unit is Adj {
body intrinsic;
}

/// <summary>
/// Performs the onResultZeroOp when measurementResult is Zero, else performs the onResultOneOp.
/// onReusltZeroOp and onResultOneOp must both be controllable.
/// </summary>
operation Interface_ApplyIfElseC (ctrls : Qubit[], measurementResult : Result, onResultZeroOp : (Unit => Unit is Ctl) , onResultOneOp : (Unit => Unit is Ctl)) : Unit {
operation Interface_ApplyIfElseC (
measurementResult : Result,
onResultZeroOp : (Unit => Unit is Ctl),
onResultOneOp : (Unit => Unit is Ctl)
) : Unit is Ctl {
body intrinsic;
}

/// <summary>
/// Performs the onResultZeroOp when measurementResult is Zero, else performs the onResultOneOp.
/// onReusltZeroOp and onResultOneOp must both be controllable and adjointable.
/// </summary>
operation Interface_ApplyIfElseCA (ctrls : Qubit[], measurementResult : Result, onResultZeroOp : (Unit => Unit is Ctl + Adj) , onResultOneOp : (Unit => Unit is Ctl + Adj)) : Unit {
operation Interface_ApplyIfElseCA (
measurementResult : Result,
onResultZeroOp : (Unit => Unit is Ctl + Adj),
onResultOneOp : (Unit => Unit is Ctl + Adj)
) : Unit is Adj + Ctl {
body intrinsic;
}

/// <summary>
/// Performs the onEqualOp when each element of measurementResults is equal to the corresponding
/// element of resultsValues, else performs onNonEqualOp.
/// </summary>
operation Interface_ApplyConditionally (measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit) , onNonEqualOp : (Unit => Unit)) : Unit {
operation Interface_ApplyConditionally (
measurementResults : Result[],
resultsValues : Result[],
onEqualOp : (Unit => Unit),
onNonEqualOp : (Unit => Unit)
) : Unit {
body intrinsic;
}

Expand All @@ -122,7 +143,12 @@ namespace Microsoft.Quantum.Simulation.Simulators.QCTraceSimulators.Implementati
/// element of resultsValues, else performs onNonEqualOp.
/// onEqualOp and onNonEqualOp must both be adjointable.
/// </summary>
operation Interface_ApplyConditionallyA (measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit is Adj) , onNonEqualOp : (Unit => Unit is Adj)) : Unit {
operation Interface_ApplyConditionallyA (
measurementResults : Result[],
resultsValues : Result[],
onEqualOp : (Unit => Unit is Adj),
onNonEqualOp : (Unit => Unit is Adj)
) : Unit is Adj {
body intrinsic;
}

Expand All @@ -131,7 +157,12 @@ namespace Microsoft.Quantum.Simulation.Simulators.QCTraceSimulators.Implementati
/// element of resultsValues, else performs onNonEqualOp.
/// onEqualOp and onNonEqualOp must both be controllable.
/// </summary>
operation Interface_ApplyConditionallyC (ctrls : Qubit[], measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit is Ctl) , onNonEqualOp : (Unit => Unit is Ctl)) : Unit {
operation Interface_ApplyConditionallyC (
measurementResults : Result[],
resultsValues : Result[],
onEqualOp : (Unit => Unit is Ctl),
onNonEqualOp : (Unit => Unit is Ctl)
) : Unit is Ctl {
body intrinsic;
}

Expand All @@ -140,7 +171,12 @@ namespace Microsoft.Quantum.Simulation.Simulators.QCTraceSimulators.Implementati
/// element of resultsValues, else performs onNonEqualOp.
/// onEqualOp and onNonEqualOp must both be controllable and adjointable.
/// </summary>
operation Interface_ApplyConditionallyCA (ctrls : Qubit[], measurementResults : Result[], resultsValues : Result[], onEqualOp : (Unit => Unit is Ctl + Adj) , onNonEqualOp : (Unit => Unit is Ctl + Adj)) : Unit {
operation Interface_ApplyConditionallyCA (
measurementResults : Result[],
resultsValues : Result[],
onEqualOp : (Unit => Unit is Ctl + Adj),
onNonEqualOp : (Unit => Unit is Ctl + Adj)
) : Unit is Adj + Ctl {
body intrinsic;
}

Expand Down
78 changes: 70 additions & 8 deletions src/Simulation/Simulators/QCTraceSimulator/QCTraceSimulator.ClassicalControl.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -140,6 +140,12 @@ public TracerApplyIfElseA(QCTraceSimulatorImpl m) : base(m)
}

public override Func<(Result, IAdjointable, IAdjointable), QVoid> Body => (q) =>
{
(Result measurementResult, ICallable onZero, ICallable onOne) = q;
return ExecuteConditionalStatement(measurementResult, onZero, onOne, OperationFunctor.Body, null);
};

public override Func<(Result, IAdjointable, IAdjointable), QVoid> AdjointBody => (q) =>
{
(Result measurementResult, ICallable onZero, ICallable onOne) = q;
return ExecuteConditionalStatement(measurementResult, onZero, onOne, OperationFunctor.Adjoint, null);
Expand All @@ -155,9 +161,15 @@ public TracerApplyIfElseC(QCTraceSimulatorImpl m) : base(m)
this.tracerCore = m;
}

public override Func<(IQArray<Qubit>, Result, IControllable, IControllable), QVoid> Body => (q) =>
public override Func<(Result, IControllable, IControllable), QVoid> Body => (q) =>
{
(IQArray<Qubit> ctrls, Result measurementResult, ICallable onZero, ICallable onOne) = q;
(Result measurementResult, ICallable onZero, ICallable onOne) = q;
return ExecuteConditionalStatement(measurementResult, onZero, onOne, OperationFunctor.Body, null);
};

public override Func<(IQArray<Qubit>, (Result, IControllable, IControllable)), QVoid> ControlledBody => (q) =>
{
(IQArray<Qubit> ctrls, (Result measurementResult, ICallable onZero, ICallable onOne)) = q;
OperationFunctor type = AdjustForNoControls(OperationFunctor.Controlled, ctrls);
return ExecuteConditionalStatement(measurementResult, onZero, onOne, type, ctrls);
};
Expand All @@ -172,9 +184,28 @@ public TracerApplyIfElseCA(QCTraceSimulatorImpl m) : base(m)
this.tracerCore = m;
}

public override Func<(IQArray<Qubit>, Result, IUnitary, IUnitary), QVoid> Body => (q) =>
public override Func<(Result, IUnitary, IUnitary), QVoid> Body => (q) =>
{
(Result measurementResult, ICallable onZero, ICallable onOne) = q;
return ExecuteConditionalStatement(measurementResult, onZero, onOne, OperationFunctor.Body, null);
};

public override Func<(Result, IUnitary, IUnitary), QVoid> AdjointBody => (q) =>
{
(Result measurementResult, ICallable onZero, ICallable onOne) = q;
return ExecuteConditionalStatement(measurementResult, onZero, onOne, OperationFunctor.Adjoint, null);
};

public override Func<(IQArray<Qubit>, (Result, IUnitary, IUnitary)), QVoid> ControlledBody => (q) =>
{
(IQArray<Qubit> ctrls, (Result measurementResult, ICallable onZero, ICallable onOne)) = q;
OperationFunctor type = AdjustForNoControls(OperationFunctor.Controlled, ctrls);
return ExecuteConditionalStatement(measurementResult, onZero, onOne, type, ctrls);
};

public override Func<(IQArray<Qubit>, (Result, IUnitary, IUnitary)), QVoid> ControlledAdjointBody => (q) =>
{
(IQArray<Qubit> ctrls, Result measurementResult, ICallable onZero, ICallable onOne) = q;
(IQArray<Qubit> ctrls, (Result measurementResult, ICallable onZero, ICallable onOne)) = q;
OperationFunctor type = AdjustForNoControls(OperationFunctor.ControlledAdjoint, ctrls);
return ExecuteConditionalStatement(measurementResult, onZero, onOne, type, ctrls);
};
Expand Down Expand Up @@ -210,6 +241,12 @@ public TracerApplyConditionallyA(QCTraceSimulatorImpl m) : base(m)
}

public override Func<(IQArray<Result>, IQArray<Result>, IAdjointable, IAdjointable), QVoid> Body => (q) =>
{
(IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, OperationFunctor.Body, null);
};

public override Func<(IQArray<Result>, IQArray<Result>, IAdjointable, IAdjointable), QVoid> AdjointBody => (q) =>
{
(IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, OperationFunctor.Adjoint, null);
Expand All @@ -225,9 +262,15 @@ public TracerApplyConditionallyC(QCTraceSimulatorImpl m) : base(m)
this.tracerCore = m;
}

public override Func<(IQArray<Qubit>, IQArray<Result>, IQArray<Result>, IControllable, IControllable), QVoid> Body => (q) =>
public override Func<(IQArray<Result>, IQArray<Result>, IControllable, IControllable), QVoid> Body => (q) =>
{
(IQArray<Qubit> ctrls, IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
(IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, OperationFunctor.Body, null);
};

public override Func<(IQArray<Qubit>, (IQArray<Result>, IQArray<Result>, IControllable, IControllable)), QVoid> ControlledBody => (q) =>
{
(IQArray<Qubit> ctrls, (IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp)) = q;
OperationFunctor type = AdjustForNoControls(OperationFunctor.Controlled, ctrls);
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, type, ctrls);
};
Expand All @@ -242,12 +285,31 @@ public TracerApplyConditionallyCA(QCTraceSimulatorImpl m) : base(m)
this.tracerCore = m;
}

public override Func<(IQArray<Qubit>, IQArray<Result>, IQArray<Result>, IUnitary, IUnitary), QVoid> Body => (q) =>
public override Func<(IQArray<Result>, IQArray<Result>, IUnitary, IUnitary), QVoid> Body => (q) =>
{
(IQArray<Qubit> ctrls, IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
(IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, OperationFunctor.Body, null);
};

public override Func<(IQArray<Result>, IQArray<Result>, IUnitary, IUnitary), QVoid> AdjointBody => (q) =>
{
(IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp) = q;
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, OperationFunctor.Adjoint, null);
};

public override Func<(IQArray<Qubit>, (IQArray<Result>, IQArray<Result>, IUnitary, IUnitary)), QVoid> ControlledBody => (q) =>
{
(IQArray<Qubit> ctrls, (IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp)) = q;
OperationFunctor type = AdjustForNoControls(OperationFunctor.Controlled, ctrls);
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, type, ctrls);
};

public override Func<(IQArray<Qubit>, (IQArray<Result>, IQArray<Result>, IUnitary, IUnitary)), QVoid> ControlledAdjointBody => (q) =>
{
(IQArray<Qubit> ctrls, (IQArray<Result> measurementResults, IQArray<Result> comparisonResults, ICallable onEqualOp, ICallable onNonEqualOp)) = q;
OperationFunctor type = AdjustForNoControls(OperationFunctor.ControlledAdjoint, ctrls);
return ExecuteConditionalStatement(measurementResults, comparisonResults, onEqualOp, onNonEqualOp, type, ctrls);
};
}

#endregion
Expand Down