Q Sharp

History

Usage

Features

Documentation and resources

Syntax

Similarities with C#

Similarities with F#

Differences

Example

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
namespaceMicrosoft.Quantum.Canon{
openMicrosoft.Quantum.Intrinsic;
openMicrosoft.Quantum.Arithmetic;
openMicrosoft.Quantum.Arrays;
openMicrosoft.Quantum.Diagnostics;
openMicrosoft.Quantum.Math;
/// # Summary
/// Applies a multiply-controlled unitary operation $U$ that applies a
/// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
///
/// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # Input
/// ## unitaryGenerator
/// A tuple where the first element `Int` is the number of unitaries $N,ドル
/// and the second element `(Int -> ('T => () is Adj + Ctl))`
/// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
/// operation $V_j$.
///
/// ## index
/// $n$-qubit control register that encodes number states $\ket{j}$ in
/// little-endian format.
///
/// ## target
/// Generic qubit register that $V_j$ acts on.
///
/// # Remarks
/// `coefficients` will be padded with identity elements if
/// fewer than 2ドル^n$ are specified. This implementation uses
/// $n-1$ auxiliary qubits.
///
/// # References
/// - [ *Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su*,
/// arXiv:1711.10980](https://arxiv.org/abs/1711.10980)
operationMultiplexOperationsFromGenerator<'T>(unitaryGenerator:(Int,(Int->('T=>UnitisAdj+Ctl))),index:LittleEndian,target:'T):UnitisCtl+Adj{
let(nUnitaries,unitaryFunction)=unitaryGenerator;
letunitaryGeneratorWithOffset=(nUnitaries,0,unitaryFunction);
ifLength(index!)==0{
fail"MultiplexOperations failed. Number of index qubits must be greater than 0.";
}
ifnUnitaries>0{
letauxiliary=[];
AdjointMultiplexOperationsFromGeneratorImpl(unitaryGeneratorWithOffset,auxiliary,index,target);
}
}
/// # Summary
/// Implementation step of `MultiplexOperationsFromGenerator`.
/// # See Also
/// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator
internaloperationMultiplexOperationsFromGeneratorImpl<'T>(unitaryGenerator:(Int,Int,(Int->('T=>UnitisAdj+Ctl))),auxiliary:Qubit[],index:LittleEndian,target:'T)
:Unit{
body(...){
letnIndex=Length(index!);
letnStates=2^nIndex;
let(nUnitaries,unitaryOffset,unitaryFunction)=unitaryGenerator;
letnUnitariesLeft=MinI(nUnitaries,nStates/2);
letnUnitariesRight=MinI(nUnitaries,nStates);
letleftUnitaries=(nUnitariesLeft,unitaryOffset,unitaryFunction);
letrightUnitaries=(nUnitariesRight-nUnitariesLeft,unitaryOffset+nUnitariesLeft,unitaryFunction);
letnewControls=LittleEndian(Most(index!));
ifnUnitaries>0{
ifLength(auxiliary)==1andnIndex==0{
// Termination case
(ControlledAdjoint(unitaryFunction(unitaryOffset)))(auxiliary,target);
}elifLength(auxiliary)==0andnIndex>=1{
// Start case
letnewauxiliary=Tail(index!);
ifnUnitariesRight>0{
MultiplexOperationsFromGeneratorImpl(rightUnitaries,[newauxiliary],newControls,target);
}
within{
X(newauxiliary);
}apply{
MultiplexOperationsFromGeneratorImpl(leftUnitaries,[newauxiliary],newControls,target);
}
}else{
// Recursion that reduces nIndex by 1 and sets Length(auxiliary) to 1.
letcontrols=[Tail(index!)]+auxiliary;
usenewauxiliary=Qubit();
useandauxiliary=Qubit[MaxI(0,Length(controls)-2)];
within{
ApplyAndChain(andauxiliary,controls,newauxiliary);
}apply{
ifnUnitariesRight>0{
MultiplexOperationsFromGeneratorImpl(rightUnitaries,[newauxiliary],newControls,target);
}
within{
(ControlledX)(auxiliary,newauxiliary);
}apply{
MultiplexOperationsFromGeneratorImpl(leftUnitaries,[newauxiliary],newControls,target);
}
}
}
}
}
adjointauto;
controlled(controlRegister,...){
MultiplexOperationsFromGeneratorImpl(unitaryGenerator,auxiliary+controlRegister,index,target);
}
adjointcontrolledauto;
}
/// # Summary
/// Applies multiply-controlled unitary operation $U$ that applies a
/// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
///
/// $U = \sum^{N-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # Input
/// ## unitaryGenerator
/// A tuple where the first element `Int` is the number of unitaries $N,ドル
/// and the second element `(Int -> ('T => () is Adj + Ctl))`
/// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
/// operation $V_j$.
///
/// ## index
/// $n$-qubit control register that encodes number states $\ket{j}$ in
/// little-endian format.
///
/// ## target
/// Generic qubit register that $V_j$ acts on.
///
/// # Remarks
/// `coefficients` will be padded with identity elements if
/// fewer than 2ドル^n$ are specified. This version is implemented
/// directly by looping through n-controlled unitary operators.
operationMultiplexOperationsBruteForceFromGenerator<'T>(unitaryGenerator:(Int,(Int->('T=>UnitisAdj+Ctl))),index:LittleEndian,target:'T)
:UnitisAdj+Ctl{
letnIndex=Length(index!);
letnStates=2^nIndex;
let(nUnitaries,unitaryFunction)=unitaryGenerator;
foridxOpin0..MinI(nStates,nUnitaries)-1{
(ControlledOnInt(idxOp,unitaryFunction(idxOp)))(index!,target);
}
}
/// # Summary
/// Returns a multiply-controlled unitary operation $U$ that applies a
/// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
///
/// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # Input
/// ## unitaryGenerator
/// A tuple where the first element `Int` is the number of unitaries $N,ドル
/// and the second element `(Int -> ('T => () is Adj + Ctl))`
/// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
/// operation $V_j$.
///
/// # Output
/// A multiply-controlled unitary operation $U$ that applies unitaries
/// described by `unitaryGenerator`.
///
/// # See Also
/// - Microsoft.Quantum.Canon.MultiplexOperationsFromGenerator
functionMultiplexerFromGenerator(unitaryGenerator:(Int,(Int->(Qubit[]=>UnitisAdj+Ctl)))):((LittleEndian,Qubit[])=>UnitisAdj+Ctl){
returnMultiplexOperationsFromGenerator(unitaryGenerator,_,_);
}
/// # Summary
/// Returns a multiply-controlled unitary operation $U$ that applies a
/// unitary $V_j$ when controlled by n-qubit number state $\ket{j}$.
///
/// $U = \sum^{2^n-1}_{j=0}\ket{j}\bra{j}\otimes V_j$.
///
/// # Input
/// ## unitaryGenerator
/// A tuple where the first element `Int` is the number of unitaries $N,ドル
/// and the second element `(Int -> ('T => () is Adj + Ctl))`
/// is a function that takes an integer $j$ in $[0,N-1]$ and outputs the unitary
/// operation $V_j$.
///
/// # Output
/// A multiply-controlled unitary operation $U$ that applies unitaries
/// described by `unitaryGenerator`.
///
/// # See Also
/// - Microsoft.Quantum.Canon.MultiplexOperationsBruteForceFromGenerator
functionMultiplexerBruteForceFromGenerator(unitaryGenerator:(Int,(Int->(Qubit[]=>UnitisAdj+Ctl)))):((LittleEndian,Qubit[])=>UnitisAdj+Ctl){
returnMultiplexOperationsBruteForceFromGenerator(unitaryGenerator,_,_);
}
/// # Summary
/// Computes a chain of AND gates
///
/// # Description
/// The auxiliary qubits to compute temporary results must be specified explicitly.
/// The length of that register is `Length(ctrlRegister) - 2`, if there are at least
/// two controls, otherwise the length is 0.
internaloperationApplyAndChain(auxRegister:Qubit[],ctrlRegister:Qubit[],target:Qubit)
:UnitisAdj{
ifLength(ctrlRegister)==0{
X(target);
}elifLength(ctrlRegister)==1{
CNOT(Head(ctrlRegister),target);
}else{
EqualityFactI(Length(auxRegister),Length(ctrlRegister));
letcontrols1=ctrlRegister[0..0]+auxRegister;
letcontrols2=Rest(ctrlRegister);
lettargets=auxRegister+[target];
ApplyToEachA(ApplyAnd,Zipped3(controls1,controls2,targets));
}
}
}

References

External links