/// <summary>
/// Gets an identifier and argument tuple for the built-in operation NoOp.
/// </summary>
private (TypedExpression, TypedExpression) GetNoOp()
{
var opInfo = BuiltIn.NoOp;
var properties = new[] { OpProperty.Adjointable, OpProperty.Controllable };
var characteristics = new CallableInformation(
ResolvedCharacteristics.FromProperties(properties),
new InferredCallableInformation(((BuiltInKind.Operation)opInfo.Kind).IsSelfAdjoint, false));
var unitType = ResolvedType.New(ResolvedTypeKind.UnitType);
var operationType = ResolvedType.New(ResolvedTypeKind.NewOperation(
Tuple.Create(unitType, unitType),
characteristics));
var args = new TypedExpression(
ExpressionKind.UnitValue,
TypeArgsResolution.Empty,
unitType,
new InferredExpressionInformation(false, false),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null);
var typeArgs = ImmutableArray.Create(unitType);
var identifier = new TypedExpression(
ExpressionKind.NewIdentifier(
Identifier.NewGlobalCallable(opInfo.FullName),
QsNullable <ImmutableArray <ResolvedType> > .NewValue(typeArgs)),
typeArgs
.Zip(((BuiltInKind.Operation)opInfo.Kind).TypeParameters, (type, param) => Tuple.Create(opInfo.FullName, param, type))
.ToImmutableArray(),
operationType,
new InferredExpressionInformation(false, false),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null);
return(identifier, args);
}
internal static ResolvedType GetOperationType(IEnumerable <OpProperty> props, ResolvedType argumentType)
{
var characteristics = new CallableInformation(
ResolvedCharacteristics.FromProperties(props),
InferredCallableInformation.NoInformation);
return(ResolvedType.New(ResolvedTypeKind.NewOperation(
Tuple.Create(argumentType, ResolvedType.New(ResolvedTypeKind.UnitType)),
characteristics)));
}
/// <summary>
/// Creates an operation call from the conditional control API, given information
/// about which operation to call and with what arguments.
/// </summary>
private TypedExpression CreateControlCall(BuiltIn opInfo, IEnumerable <OpProperty> properties, TypedExpression args, IEnumerable <ResolvedType> typeArgs)
{
var characteristics = new CallableInformation(
ResolvedCharacteristics.FromProperties(properties),
new InferredCallableInformation(((BuiltInKind.Operation)opInfo.Kind).IsSelfAdjoint, false));
var unitType = ResolvedType.New(ResolvedTypeKind.UnitType);
var operationType = ResolvedType.New(ResolvedTypeKind.NewOperation(
Tuple.Create(args.ResolvedType, unitType),
characteristics));
// Build the surrounding control call
var identifier = new TypedExpression(
ExpressionKind.NewIdentifier(
Identifier.NewGlobalCallable(opInfo.FullName),
typeArgs.Any()
? QsNullable <ImmutableArray <ResolvedType> > .NewValue(typeArgs.ToImmutableArray())
: QsNullable <ImmutableArray <ResolvedType> > .Null),
typeArgs
.Zip(((BuiltInKind.Operation)opInfo.Kind).TypeParameters, (type, param) => Tuple.Create(opInfo.FullName, param, type))
.ToImmutableArray(),
operationType,
new InferredExpressionInformation(false, false),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null);
// Creates type resolutions for the call expression
var opTypeArgResolutions = typeArgs
.SelectMany(x =>
x.Resolution is ResolvedTypeKind.TupleType tup
? tup.Item
: ImmutableArray.Create(x))
.Where(x => x.Resolution.IsTypeParameter)
.Select(x => (x.Resolution as ResolvedTypeKind.TypeParameter).Item)
.GroupBy(x => (x.Origin, x.TypeName))
.Select(group =>
{
var typeParam = group.First();
return(Tuple.Create(typeParam.Origin, typeParam.TypeName, ResolvedType.New(ResolvedTypeKind.NewTypeParameter(typeParam))));
})
.ToImmutableArray();
return(new TypedExpression(
ExpressionKind.NewCallLikeExpression(identifier, args),
opTypeArgResolutions,
unitType,
new InferredExpressionInformation(false, true),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null));
}
private (ResolvedSignature, IEnumerable <QsSpecialization>) MakeSpecializations(
QsQualifiedName callableName, ResolvedType paramsType, SpecializationImplementation bodyImplementation)
{
QsSpecialization MakeSpec(QsSpecializationKind kind, ResolvedSignature signature, SpecializationImplementation impl) =>
new QsSpecialization(
kind,
callableName,
ImmutableArray <QsDeclarationAttribute> .Empty,
this.CurrentCallable.Callable.SourceFile,
QsNullable <QsLocation> .Null,
QsNullable <ImmutableArray <ResolvedType> > .Null,
signature,
impl,
ImmutableArray <string> .Empty,
QsComments.Empty);
var adj = this.CurrentCallable.Adjoint;
var ctl = this.CurrentCallable.Controlled;
var ctlAdj = this.CurrentCallable.ControlledAdjoint;
bool addAdjoint = false;
bool addControlled = false;
bool isSelfAdjoint = false;
if (this.InWithinBlock)
{
addAdjoint = true;
addControlled = false;
}
else if (this.InBody)
{
if (adj != null && adj.Implementation is SpecializationImplementation.Generated adjGen)
{
addAdjoint = adjGen.Item.IsInvert;
isSelfAdjoint = adjGen.Item.IsSelfInverse;
}
if (ctl != null && ctl.Implementation is SpecializationImplementation.Generated ctlGen)
{
addControlled = ctlGen.Item.IsDistribute;
}
if (ctlAdj != null && ctlAdj.Implementation is SpecializationImplementation.Generated ctlAdjGen)
{
addAdjoint = addAdjoint || (ctlAdjGen.Item.IsInvert && ctl.Implementation.IsGenerated);
addControlled = addControlled || (ctlAdjGen.Item.IsDistribute && adj.Implementation.IsGenerated);
isSelfAdjoint = isSelfAdjoint || ctlAdjGen.Item.IsSelfInverse;
}
}
else if (ctlAdj != null && ctlAdj.Implementation is SpecializationImplementation.Generated gen)
{
addControlled = this.InAdjoint && gen.Item.IsDistribute;
addAdjoint = this.InControlled && gen.Item.IsInvert;
isSelfAdjoint = gen.Item.IsSelfInverse;
}
var props = new List <OpProperty>();
if (addAdjoint)
{
props.Add(OpProperty.Adjointable);
}
if (addControlled)
{
props.Add(OpProperty.Controllable);
}
var newSig = new ResolvedSignature(
this.CurrentCallable.Callable.Signature.TypeParameters,
paramsType,
ResolvedType.New(ResolvedTypeKind.UnitType),
new CallableInformation(ResolvedCharacteristics.FromProperties(props), new InferredCallableInformation(isSelfAdjoint, false)));
var controlledSig = new ResolvedSignature(
newSig.TypeParameters,
ResolvedType.New(ResolvedTypeKind.NewTupleType(ImmutableArray.Create(
ResolvedType.New(ResolvedTypeKind.NewArrayType(ResolvedType.New(ResolvedTypeKind.Qubit))),
newSig.ArgumentType))),
newSig.ReturnType,
newSig.Information);
var specializations = new List <QsSpecialization>()
{
MakeSpec(QsSpecializationKind.QsBody, newSig, bodyImplementation)
};
if (addAdjoint)
{
specializations.Add(MakeSpec(
QsSpecializationKind.QsAdjoint,
newSig,
SpecializationImplementation.NewGenerated(QsGeneratorDirective.Invert)));
}
if (addControlled)
{
specializations.Add(MakeSpec(
QsSpecializationKind.QsControlled,
controlledSig,
SpecializationImplementation.NewGenerated(QsGeneratorDirective.Distribute)));
}
if (addAdjoint && addControlled)
{
specializations.Add(MakeSpec(
QsSpecializationKind.QsControlledAdjoint,
controlledSig,
SpecializationImplementation.NewGenerated(QsGeneratorDirective.Distribute)));
}
return(newSig, specializations);
}
public void ParseOp()
{
ArgDeclType BuildArgument(string name, ResolvedType t)
{
var validName = QsLocalSymbol.NewValidName(NonNullable <string> .New(name));
var info = new InferredExpressionInformation(false, false);
return(new ArgDeclType(validName, t, info, QsNullable <Tuple <int, int> > .Null, EmptyRange));
}
string[] comments =
{
"# Summary",
"Convenience function that performs state preparation by applying a ",
"`statePrepUnitary` on the input state, followed by adiabatic state ",
"preparation using a `adiabaticUnitary`, and finally phase estimation ",
"with respect to `qpeUnitary`on the resulting state using a ",
"`phaseEstAlgorithm`.",
"",
"# Input",
"## statePrepUnitary",
"An oracle representing state preparation for the initial dynamical",
"generator.",
"## adiabaticUnitary",
"An oracle representing the adiabatic evolution algorithm to be used",
"to implement the sweeps to the final state of the algorithm.",
"## qpeUnitary",
"An oracle representing a unitary operator $U$ representing evolution",
"for time $\\delta t$ under a dynamical generator with ground state",
"$\\ket{\\phi}$ and ground state energy $E = \\phi\\\\,\\delta t$.",
"## phaseEstAlgorithm",
"An operation that performs phase estimation on a given unitary operation.",
"See [iterative phase estimation](/quantum/libraries/characterization#iterative-phase-estimation)",
"for more details.",
"## qubits",
"A register of qubits to be used to perform the simulation.",
"",
"# Output",
"An estimate $\\hat{\\phi}$ of the ground state energy $\\phi$",
"of the generator represented by $U$."
};
string expected = @"### YamlMime:QSharpType
uid: microsoft.quantum.canon.adiabaticstateenergyunitary
name: AdiabaticStateEnergyUnitary
type: operation
namespace: Microsoft.Quantum.Canon
summary: |-
Convenience function that performs state preparation by applying a
`statePrepUnitary` on the input state, followed by adiabatic state
preparation using a `adiabaticUnitary`, and finally phase estimation
with respect to `qpeUnitary`on the resulting state using a
`phaseEstAlgorithm`.
syntax: 'operation AdiabaticStateEnergyUnitary (statePrepUnitary : (Qubit[] => Unit), adiabaticUnitary : (Qubit[] => Unit), qpeUnitary : (Qubit[] => Unit is Adj + Ctl), phaseEstAlgorithm : ((Microsoft.Quantum.Canon.DiscreteOracle, Qubit[]) => Double), qubits : Qubit[]) : Double'
input:
content: '(statePrepUnitary : (Qubit[] => Unit), adiabaticUnitary : (Qubit[] => Unit), qpeUnitary : (Qubit[] => Unit is Adj + Ctl), phaseEstAlgorithm : ((Microsoft.Quantum.Canon.DiscreteOracle, Qubit[]) => Double), qubits : Qubit[])'
types:
- name: statePrepUnitary
summary: |-
An oracle representing state preparation for the initial dynamical
generator.
isOperation: true
input:
types:
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Unit
- name: adiabaticUnitary
summary: |-
An oracle representing the adiabatic evolution algorithm to be used
to implement the sweeps to the final state of the algorithm.
isOperation: true
input:
types:
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Unit
- name: qpeUnitary
summary: |-
An oracle representing a unitary operator $U$ representing evolution
for time $\delta t$ under a dynamical generator with ground state
$\ket{\phi}$ and ground state energy $E = \phi\\,\delta t$.
isOperation: true
input:
types:
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Unit
functors:
- Adjoint
- Controlled
- name: phaseEstAlgorithm
summary: |-
An operation that performs phase estimation on a given unitary operation.
See [iterative phase estimation](/quantum/libraries/characterization#iterative-phase-estimation)
for more details.
isOperation: true
input:
types:
- uid: microsoft.quantum.canon.discreteoracle
- isArray: true
isPrimitive: true
uid: Qubit
output:
types:
- isPrimitive: true
uid: Double
- name: qubits
summary: A register of qubits to be used to perform the simulation.
isArray: true
isPrimitive: true
uid: Qubit
output:
content: Double
types:
- summary: |-
An estimate $\hat{\phi}$ of the ground state energy $\phi$
of the generator represented by $U$.
isPrimitive: true
uid: Double
...
";
var qubitArrayType = ResolvedType.New(QsType.NewArrayType(ResolvedType.New(QsType.Qubit)));
var unitType = ResolvedType.New(QsType.UnitType);
var doubleType = ResolvedType.New(QsType.Double);
var oracleType = ResolvedType.New(QsType.NewUserDefinedType(new UserDefinedType(CanonName,
NonNullable <string> .New("DiscreteOracle"),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null)));
var noInfo = CallableInformation.NoInformation;
var acFunctors = ResolvedCharacteristics.FromProperties(new[] { OpProperty.Adjointable, OpProperty.Controllable });
var acInfo = new CallableInformation(acFunctors, InferredCallableInformation.NoInformation);
var qubitToUnitOp = ResolvedType.New(QsType.NewOperation(new SigTypeTuple(qubitArrayType, unitType), noInfo));
var qubitToUnitOpAC = ResolvedType.New(QsType.NewOperation(new SigTypeTuple(qubitArrayType, unitType), acInfo));
var phaseEstArgs = new ResolvedType[] { oracleType, qubitArrayType }.ToImmutableArray();
var phaseEstArgTuple = ResolvedType.New(QsType.NewTupleType(phaseEstArgs));
var phaseEstOp = ResolvedType.New(QsType.NewOperation(new SigTypeTuple(phaseEstArgTuple, doubleType), noInfo));
var typeParams = new QsLocalSymbol[] { }.ToImmutableArray();
var argTypes = new ResolvedType[] { qubitToUnitOp, qubitToUnitOp, qubitToUnitOpAC, phaseEstOp, qubitArrayType }.ToImmutableArray();
var argTupleType = ResolvedType.New(QsType.NewTupleType(argTypes));
var signature = new ResolvedSignature(typeParams, argTupleType, doubleType, noInfo);
var args = new List <ArgDeclType> {
BuildArgument("statePrepUnitary", qubitToUnitOp),
BuildArgument("adiabaticUnitary", qubitToUnitOp),
BuildArgument("qpeUnitary", qubitToUnitOpAC),
BuildArgument("phaseEstAlgorithm", phaseEstOp),
BuildArgument("qubits", qubitArrayType)
}
.ConvertAll(arg => QsTuple <ArgDeclType> .NewQsTupleItem(arg))
.ToImmutableArray();
var argTuple = QsTuple <ArgDeclType> .NewQsTuple(args);
var specs = new QsSpecialization[] { }.ToImmutableArray();
var qsCallable = new QsCallable(QsCallableKind.Operation,
MakeFullName("AdiabaticStateEnergyUnitary"),
ImmutableArray <QsDeclarationAttribute> .Empty,
NonNullable <string> .New("Techniques.qs"),
ZeroLocation,
signature,
argTuple,
specs,
comments.ToImmutableArray(),
QsComments.Empty);
var callable = new DocCallable("Microsoft.Quantum.Canon", qsCallable);
var stream = new StringWriter();
callable.WriteToFile(stream);
var s = stream.ToString();
Assert.Equal(expected, s);
}
internal static string ToSyntax(this ResolvedCharacteristics characteristics) =>
characteristics.SupportedFunctors switch
{
{ IsNull : true } => "",
