qsharp-lang 1.1.2-dev → 1.1.4-dev

package/docs/Microsoft.Quantum.Canon/ApplyControlledOnInt.md

@@ -0,0 +1,41 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyControlledOnInt
+title: ApplyControlledOnInt operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyControlledOnInt
+qsharp.summary: Applies a unitary operation on the target if the control
+register state corresponds to a specified nonnegative integer.
+---
+
+# ApplyControlledOnInt operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyControlledOnInt<'T>(numberState : Int, oracle : ('T => Unit is Adj + Ctl), controlRegister : Qubit[], target : 'T) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a unitary operation on the target if the control
+register state corresponds to a specified nonnegative integer.
+
+## Input
+### numberState
+A nonnegative integer on which the operation `oracle` should be
+controlled.
+### oracle
+A unitary operation to be controlled.
+### target
+A target on which to apply `oracle`.
+### controlRegister
+A quantum register that controls application of `oracle`.
+
+## Remarks
+The value of `numberState` is interpreted using a little-endian encoding.
+
+`numberState` must be at most $2^\texttt{Length(controlRegister)} - 1$.
+For example, `numberState = 537` means that `oracle`
+is applied if and only if `controlRegister` is in the state $\ket{537}$.

package/docs/Microsoft.Quantum.Canon/ApplyP.md

@@ -0,0 +1,39 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyP
+title: ApplyP operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyP
+qsharp.summary: Given a single-qubit Pauli operator, applies the corresponding operation
+to a single qubit.
+---
+
+# ApplyP operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyP(pauli : Pauli, target : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Given a single-qubit Pauli operator, applies the corresponding operation
+to a single qubit.
+
+## Input
+### pauli
+The Pauli operator to be applied.
+### target
+The qubit to which `pauli` is to be applied as an operation.
+
+## Example
+The following are equivalent:
+```qsharp
+ApplyP(PauliX, q);
+```
+and
+```qsharp
+X(q);
+```

package/docs/Microsoft.Quantum.Canon/ApplyPauli.md

@@ -0,0 +1,41 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyPauli
+title: ApplyPauli operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyPauli
+qsharp.summary: Given a multi-qubit Pauli operator, applies the corresponding operation
+to a quantum register.
+---
+
+# ApplyPauli operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyPauli(pauli : Pauli[], target : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Given a multi-qubit Pauli operator, applies the corresponding operation
+to a quantum register.
+
+## Input
+### pauli
+A multi-qubit Pauli operator represented as an array of single-qubit Pauli operators.
+### target
+Register to apply the given Pauli operation on.
+
+## Example
+The following are equivalent:
+```qsharp
+ApplyPauli([PauliY, PauliZ, PauliX], target);
+```
+and
+```qsharp
+Y(target[0]);
+Z(target[1]);
+X(target[2]);
+```

package/docs/Microsoft.Quantum.Canon/ApplyPauliFromBitString.md

@@ -0,0 +1,47 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyPauliFromBitString
+title: ApplyPauliFromBitString operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyPauliFromBitString
+qsharp.summary: Applies a Pauli operator on each qubit in an array if the corresponding
+bit of a Boolean array matches a given input.
+---
+
+# ApplyPauliFromBitString operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyPauliFromBitString(pauli : Pauli, bitApply : Bool, bits : Bool[], qubits : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a Pauli operator on each qubit in an array if the corresponding
+bit of a Boolean array matches a given input.
+
+## Input
+### pauli
+Pauli operator to apply to `qubits[idx]` where `bitApply == bits[idx]`
+### bitApply
+apply Pauli if bit is this value
+### bits
+Boolean register specifying which corresponding qubit in `qubits` should be operated on
+### qubits
+Quantum register on which to selectively apply the specified Pauli operator
+
+## Remarks
+The Boolean array and the quantum register must be of equal length.
+
+## Example
+The following applies an X operation on qubits 0 and 2, and a Z operation on qubits 1 and 3.
+```qsharp
+use qubits = Qubit[4];
+let bits = [true, false, true, false];
+// Apply when index in `bits` is `true`.
+ApplyPauliFromBitString(PauliX, true, bits, qubits);
+// Apply when index in `bits` is `false`.
+ApplyPauliFromBitString(PauliZ, false, bits, qubits);
+```

package/docs/Microsoft.Quantum.Canon/ApplyPauliFromInt.md

@@ -0,0 +1,45 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyPauliFromInt
+title: ApplyPauliFromInt operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyPauliFromInt
+qsharp.summary: Applies a Pauli operator on each qubit in an array if the corresponding
+bit of a Little-endian integer matches a given input.
+---
+
+# ApplyPauliFromInt operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyPauliFromInt(pauli : Pauli, bitApply : Bool, numberState : Int, qubits : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a Pauli operator on each qubit in an array if the corresponding
+bit of a Little-endian integer matches a given input.
+
+## Input
+### pauli
+Pauli operator to apply to `qubits[idx]` when bit of numberState
+in idx position is the same as bitApply.
+### bitApply
+apply Pauli if bit is this value
+### numberState
+Little-endian integer specifying which corresponding qubit in `qubits` should be operated on
+### qubits
+Quantum register on which to selectively apply the specified Pauli operator
+
+## Example
+The following applies an X operation on qubits 0 and 2, and a Z operation on qubits 1 and 3.
+```qsharp
+use qubits = Qubit[4];
+let n = 5;
+// Apply when index in `bits` is `true`.
+ApplyPauliFromBitString(PauliX, true, n, qubits);
+// Apply when index in `bits` is `false`.
+ApplyPauliFromBitString(PauliZ, false, n, qubits);
+```

package/docs/Microsoft.Quantum.Canon/ApplyQFT.md

@@ -0,0 +1,34 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyQFT
+title: ApplyQFT operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyQFT
+qsharp.summary: Applies Quantum Fourier Transform (QFT) to a little-endian quantum register.
+---
+
+# ApplyQFT operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyQFT(qs : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies Quantum Fourier Transform (QFT) to a little-endian quantum register.
+
+## Description
+Applies QFT to a little-endian register `qs` of length n
+containing |x₁⟩⊗|x₂⟩⊗…⊗|xₙ⟩. The qs[0] contains the
+least significant bit xₙ. The state of qs[0] becomes
+(|0⟩+𝑒^(2π𝑖[0.xₙ])|1⟩)/sqrt(2) after the operation.
+
+## Input
+### qs
+Quantum register in a little-endian format to which the QFT is applied.
+
+## Reference
+ - [Quantum Fourier transform](https://en.wikipedia.org/wiki/Quantum_Fourier_transform)

package/docs/Microsoft.Quantum.Canon/ApplyToEach.md

@@ -0,0 +1,38 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyToEach
+title: ApplyToEach operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyToEach
+qsharp.summary: Applies an operation to each element in a register.
+---
+
+# ApplyToEach operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyToEach<'T>(singleElementOperation : ('T => Unit), register : 'T[]) : Unit
+```
+
+## Summary
+Applies an operation to each element in a register.
+
+## Input
+### singleElementOperation
+Operation to apply to each element.
+### register
+Array of elements on which to apply the given operation.
+
+## Type Parameters
+### 'T
+The target on which the operation acts.
+
+## Example
+Prepare a three-qubit |+⟩ state:
+```qsharp
+use register = Qubit[3];
+ApplyToEach(H, register);
+```

package/docs/Microsoft.Quantum.Canon/ApplyToEachA.md

@@ -0,0 +1,43 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyToEachA
+title: ApplyToEachA operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyToEachA
+qsharp.summary: Applies an operation to each element in a register.
+The modifier `A` indicates that the single-element operation is adjointable.
+---
+
+# ApplyToEachA operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyToEachA<'T>(singleElementOperation : ('T => Unit is Adj), register : 'T[]) : Unit is Adj
+```
+
+## Summary
+Applies an operation to each element in a register.
+The modifier `A` indicates that the single-element operation is adjointable.
+
+## Input
+### singleElementOperation
+Operation to apply to each element.
+### register
+Array of elements on which to apply the given operation.
+
+## Type Parameters
+### 'T
+The target on which the operation acts.
+
+## Example
+Prepare a three-qubit |+⟩ state:
+```qsharp
+use register = Qubit[3];
+ApplyToEach(H, register);
+```
+
+## See Also
+- Microsoft.Quantum.Canon.ApplyToEach

package/docs/Microsoft.Quantum.Canon/ApplyToEachC.md

@@ -0,0 +1,43 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyToEachC
+title: ApplyToEachC operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyToEachC
+qsharp.summary: Applies an operation to each element in a register.
+The modifier `C` indicates that the single-element operation is controllable.
+---
+
+# ApplyToEachC operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyToEachC<'T>(singleElementOperation : ('T => Unit is Ctl), register : 'T[]) : Unit is Ctl
+```
+
+## Summary
+Applies an operation to each element in a register.
+The modifier `C` indicates that the single-element operation is controllable.
+
+## Input
+### singleElementOperation
+Operation to apply to each element.
+### register
+Array of elements on which to apply the given operation.
+
+## Type Parameters
+### 'T
+The target on which the operation acts.
+
+## Example
+Prepare a three-qubit |+⟩ state:
+```qsharp
+use register = Qubit[3];
+ApplyToEach(H, register);
+```
+
+## See Also
+- Microsoft.Quantum.Canon.ApplyToEach

package/docs/Microsoft.Quantum.Canon/ApplyToEachCA.md

@@ -0,0 +1,43 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyToEachCA
+title: ApplyToEachCA operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyToEachCA
+qsharp.summary: Applies an operation to each element in a register.
+The modifier `CA` indicates that the single-element operation is controllable and adjointable.
+---
+
+# ApplyToEachCA operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyToEachCA<'T>(singleElementOperation : ('T => Unit is Adj + Ctl), register : 'T[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies an operation to each element in a register.
+The modifier `CA` indicates that the single-element operation is controllable and adjointable.
+
+## Input
+### singleElementOperation
+Operation to apply to each element.
+### register
+Array of elements on which to apply the given operation.
+
+## Type Parameters
+### 'T
+The target on which the operation acts.
+
+## Example
+Prepare a three-qubit |+⟩ state:
+```qsharp
+use register = Qubit[3];
+ApplyToEach(H, register);
+```
+
+## See Also
+- Microsoft.Quantum.Canon.ApplyToEach

package/docs/Microsoft.Quantum.Canon/ApplyXorInPlace.md

@@ -0,0 +1,31 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyXorInPlace
+title: ApplyXorInPlace operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyXorInPlace
+qsharp.summary: Applies a bitwise-XOR operation between a classical integer and an
+integer represented by a register of qubits.
+---
+
+# ApplyXorInPlace operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyXorInPlace(value : Int, target : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a bitwise-XOR operation between a classical integer and an
+integer represented by a register of qubits.
+
+## Description
+Applies `X` operations to qubits in a little-endian register based on
+1 bits in an integer.
+
+Let us denote `value` by a and let y be an unsigned integer encoded in `target`,
+then `ApplyXorInPlace` performs an operation given by the following map:
+|y⟩ ↦ |y ⊕ a⟩, where ⊕ is the bitwise exclusive OR operator.

package/docs/Microsoft.Quantum.Canon/ApplyXorInPlaceL.md

@@ -0,0 +1,31 @@
+---
+uid: Microsoft.Quantum.Canon.ApplyXorInPlaceL
+title: ApplyXorInPlaceL operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: ApplyXorInPlaceL
+qsharp.summary: Applies a bitwise-XOR operation between a classical integer and an
+integer represented by a register of qubits.
+---
+
+# ApplyXorInPlaceL operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation ApplyXorInPlaceL(value : BigInt, target : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a bitwise-XOR operation between a classical integer and an
+integer represented by a register of qubits.
+
+## Description
+Applies `X` operations to qubits in a little-endian register based on
+1 bits in an integer.
+
+Let us denote `value` by a and let y be an unsigned integer encoded in `target`,
+then `ApplyXorInPlace` performs an operation given by the following map:
+|y⟩ ↦ |y ⊕ a⟩, where ⊕ is the bitwise exclusive OR operator.

package/docs/Microsoft.Quantum.Canon/CX.md

@@ -0,0 +1,50 @@
+---
+uid: Microsoft.Quantum.Canon.CX
+title: CX operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: CX
+qsharp.summary: Applies the controlled-X (CX) gate to a pair of qubits.
+---
+
+# CX operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation CX(control : Qubit, target : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies the controlled-X (CX) gate to a pair of qubits.
+
+## Input
+### control
+Control qubit for the CX gate.
+### target
+Target qubit for the CX gate.
+
+## Remarks
+This operation can be simulated by the unitary matrix
+$$
+\begin{align}
+    \left(\begin{matrix}
+        1 & 0 & 0 & 0 \\\\
+        0 & 1 & 0 & 0 \\\\
+        0 & 0 & 0 & 1 \\\\
+        0 & 0 & 1 & 0
+     \end{matrix}\right)
+\end{align},
+$$
+where rows and columns are organized as in the quantum concepts guide.
+
+Equivalent to:
+```qsharp
+Controlled X([control], target);
+```
+and to:
+```qsharp
+CNOT(control, target);
+```

package/docs/Microsoft.Quantum.Canon/CY.md

@@ -0,0 +1,44 @@
+---
+uid: Microsoft.Quantum.Canon.CY
+title: CY operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: CY
+qsharp.summary: Applies the controlled-Y (CY) gate to a pair of qubits.
+---
+
+# CY operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation CY(control : Qubit, target : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies the controlled-Y (CY) gate to a pair of qubits.
+
+## Input
+### control
+Control qubit for the CY gate.
+### target
+Target qubit for the CY gate.
+
+## Remarks
+This operation can be simulated by the unitary matrix
+$$
+\begin{align}
+    1 & 0 & 0 & 0 \\\\
+    0 & 1 & 0 & 0 \\\\
+    0 & 0 & 0 & -i \\\\
+    0 & 0 & i & 0
+\end{align},
+$$
+where rows and columns are organized as in the quantum concepts guide.
+
+Equivalent to:
+```qsharp
+Controlled Y([control], target);
+```

package/docs/Microsoft.Quantum.Canon/CZ.md

@@ -0,0 +1,44 @@
+---
+uid: Microsoft.Quantum.Canon.CZ
+title: CZ operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: CZ
+qsharp.summary: Applies the controlled-Z (CZ) gate to a pair of qubits.
+---
+
+# CZ operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation CZ(control : Qubit, target : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies the controlled-Z (CZ) gate to a pair of qubits.
+
+## Input
+### control
+Control qubit for the CZ gate.
+### target
+Target qubit for the CZ gate.
+
+## Remarks
+This operation can be simulated by the unitary matrix
+$$
+\begin{align}
+    1 & 0 & 0 & 0 \\\\
+    0 & 1 & 0 & 0 \\\\
+    0 & 0 & 1 & 0 \\\\
+    0 & 0 & 0 & -1
+\end{align},
+$$
+where rows and columns are organized as in the quantum concepts guide.
+
+Equivalent to:
+```qsharp
+Controlled Z([control], target);
+```

package/docs/Microsoft.Quantum.Canon/Fst.md

@@ -0,0 +1,20 @@
+---
+uid: Microsoft.Quantum.Canon.Fst
+title: Fst function
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: Fst
+qsharp.summary: Given a pair, returns its first element.
+---
+
+# Fst function
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+function Fst<'T, 'U>(pair : ('T, 'U)) : 'T
+```
+
+Given a pair, returns its first element.

package/docs/Microsoft.Quantum.Canon/Snd.md

@@ -0,0 +1,20 @@
+---
+uid: Microsoft.Quantum.Canon.Snd
+title: Snd function
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: Snd
+qsharp.summary: Given a pair, returns its second element.
+---
+
+# Snd function
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+function Snd<'T, 'U>(pair : ('T, 'U)) : 'U
+```
+
+Given a pair, returns its second element.

package/docs/Microsoft.Quantum.Canon/SwapReverseRegister.md

@@ -0,0 +1,25 @@
+---
+uid: Microsoft.Quantum.Canon.SwapReverseRegister
+title: SwapReverseRegister operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.name: SwapReverseRegister
+qsharp.summary: Uses SWAP gates to reverse the order of the qubits in a register.
+---
+
+# SwapReverseRegister operation
+
+Namespace: [Microsoft.Quantum.Canon](xref:Microsoft.Quantum.Canon)
+
+```qsharp
+operation SwapReverseRegister(register : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Uses SWAP gates to reverse the order of the qubits in a register.
+
+## Input
+### register
+The qubits order of which should be reversed using SWAP gates