qsharp-lang 1.1.2-dev → 1.1.4-dev

package/docs/Microsoft.Quantum.Diagnostics/CheckOperationsAreEqual.md

@@ -0,0 +1,47 @@
+---
+uid: Microsoft.Quantum.Diagnostics.CheckOperationsAreEqual
+title: CheckOperationsAreEqual operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Diagnostics
+qsharp.name: CheckOperationsAreEqual
+qsharp.summary: Given two operations, checks that they act identically for all input states.
+---
+
+# CheckOperationsAreEqual operation
+
+Namespace: [Microsoft.Quantum.Diagnostics](xref:Microsoft.Quantum.Diagnostics)
+
+```qsharp
+operation CheckOperationsAreEqual(nQubits : Int, actual : (Qubit[] => Unit), expected : (Qubit[] => Unit is Adj)) : Bool
+```
+
+## Summary
+Given two operations, checks that they act identically for all input states.
+
+## Description
+This check is implemented by using the Choi–Jamiołkowski isomorphism to reduce
+this check to a check on two entangled registers.
+Thus, this operation needs only a single call to each operation being tested,
+but requires twice as many qubits to be allocated.
+This check can be used to ensure, for instance, that an optimized version of an
+operation acts identically to its naïve implementation, or that an operation
+which acts on a range of non-quantum inputs agrees with known cases.
+
+## Remarks
+This operation requires that the operation modeling the expected behavior is
+adjointable, so that the inverse can be performed on the target register alone.
+Formally, one can specify a transpose operation, which relaxes this requirement,
+but the transpose operation is not in general physically realizable for arbitrary
+quantum operations and thus is not included here as an option.
+
+## Input
+### nQubits
+Number of qubits to pass to each operation.
+### actual
+Operation to be tested.
+### expected
+Operation defining the expected behavior for the operation under test.
+## Output
+True if operations are equal, false otherwise.

package/docs/Microsoft.Quantum.Diagnostics/CheckZero.md

@@ -0,0 +1,18 @@
+---
+uid: Microsoft.Quantum.Diagnostics.CheckZero
+title: CheckZero operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Diagnostics
+qsharp.name: CheckZero
+qsharp.summary: 
+---
+
+# CheckZero operation
+
+Namespace: [Microsoft.Quantum.Diagnostics](xref:Microsoft.Quantum.Diagnostics)
+
+```qsharp
+operation CheckZero(qubit : Qubit) : Bool
+```

package/docs/Microsoft.Quantum.Diagnostics/DumpMachine.md

@@ -0,0 +1,18 @@
+---
+uid: Microsoft.Quantum.Diagnostics.DumpMachine
+title: DumpMachine function
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.namespace: Microsoft.Quantum.Diagnostics
+qsharp.name: DumpMachine
+qsharp.summary: 
+---
+
+# DumpMachine function
+
+Namespace: [Microsoft.Quantum.Diagnostics](xref:Microsoft.Quantum.Diagnostics)
+
+```qsharp
+function DumpMachine() : Unit
+```

package/docs/Microsoft.Quantum.Diagnostics/Fact.md

@@ -0,0 +1,20 @@
+---
+uid: Microsoft.Quantum.Diagnostics.Fact
+title: Fact function
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.namespace: Microsoft.Quantum.Diagnostics
+qsharp.name: Fact
+qsharp.summary: Checks whether a classical condition is true, and throws an exception if it is not.
+---
+
+# Fact function
+
+Namespace: [Microsoft.Quantum.Diagnostics](xref:Microsoft.Quantum.Diagnostics)
+
+```qsharp
+function Fact(actual : Bool, message : String) : Unit
+```
+
+Checks whether a classical condition is true, and throws an exception if it is not.

package/docs/Microsoft.Quantum.Intrinsic/CCNOT.md

@@ -0,0 +1,35 @@
+---
+uid: Microsoft.Quantum.Intrinsic.CCNOT
+title: CCNOT operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: CCNOT
+qsharp.summary: Applies the doubly controlled–NOT (CCNOT) gate to three qubits.
+---
+
+# CCNOT operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation CCNOT(control1 : Qubit, control2 : Qubit, target : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies the doubly controlled–NOT (CCNOT) gate to three qubits.
+
+## Input
+### control1
+First control qubit for the CCNOT gate.
+### control2
+Second control qubit for the CCNOT gate.
+### target
+Target qubit for the CCNOT gate.
+
+## Remarks
+Equivalent to:
+```qsharp
+Controlled X([control1, control2], target);
+```

package/docs/Microsoft.Quantum.Intrinsic/CNOT.md

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

package/docs/Microsoft.Quantum.Intrinsic/Exp.md

@@ -0,0 +1,40 @@
+---
+uid: Microsoft.Quantum.Intrinsic.Exp
+title: Exp operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: Exp
+qsharp.summary: Applies the exponential of a multi-qubit Pauli operator.
+---
+
+# Exp operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation Exp(paulis : Pauli[], theta : Double, qubits : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies the exponential of a multi-qubit Pauli operator.
+
+## Input
+### paulis
+Array of single-qubit Pauli values indicating the tensor product
+factors on each qubit.
+### theta
+Angle about the given multi-qubit Pauli operator by which the
+target register is to be rotated.
+### qubits
+Register to apply the given rotation to.
+
+## Remarks
+$$
+\begin{align}
+    e^{i \theta [P_0 \otimes P_1 \cdots P_{N-1}]},
+\end{align}
+$$
+where $P_i$ is the $i$th element of `paulis`, and where
+$N = $`Length(paulis)`.

package/docs/Microsoft.Quantum.Intrinsic/H.md

@@ -0,0 +1,34 @@
+---
+uid: Microsoft.Quantum.Intrinsic.H
+title: H operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: H
+qsharp.summary: Applies the Hadamard transformation to a single qubit.
+---
+
+# H operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation H(qubit : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies the Hadamard transformation to a single qubit.
+
+## Input
+### qubit
+Qubit to which the gate should be applied.
+
+## Remarks
+$$
+\begin{align}
+    e^{i \theta [P_0 \otimes P_1 \cdots P_{N-1}]},
+\end{align}
+$$
+where $P_i$ is the $i$th element of `paulis`, and where
+$N = $`Length(paulis)`.

package/docs/Microsoft.Quantum.Intrinsic/I.md

@@ -0,0 +1,25 @@
+---
+uid: Microsoft.Quantum.Intrinsic.I
+title: I operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: I
+qsharp.summary: Performs the identity operation (no-op) on a single qubit.
+---
+
+# I operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation I(target : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Performs the identity operation (no-op) on a single qubit.
+
+## Remarks
+This is a no-op. It is provided for completeness and because
+sometimes it is useful to call the identity in an algorithm or to pass it as a parameter.

package/docs/Microsoft.Quantum.Intrinsic/M.md

@@ -0,0 +1,46 @@
+---
+uid: Microsoft.Quantum.Intrinsic.M
+title: M operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: M
+qsharp.summary: Performs a measurement of a single qubit in the
+Pauli _Z_ basis.
+---
+
+# M operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation M(qubit : Qubit) : Result
+```
+
+## Summary
+Performs a measurement of a single qubit in the
+Pauli _Z_ basis.
+
+## Input
+### qubit
+Qubit to be measured.
+
+## Output
+`Zero` if the +1 eigenvalue is observed, and `One` if
+the -1 eigenvalue is observed.
+
+## Remarks
+The output result is given by
+the distribution
+$$
+\begin{align}
+    \Pr(\texttt{Zero} | \ket{\psi}) =
+        \braket{\psi | 0} \braket{0 | \psi}.
+\end{align}
+$$
+
+Equivalent to:
+```qsharp
+Measure([PauliZ], [qubit]);
+```

package/docs/Microsoft.Quantum.Intrinsic/Measure.md

@@ -0,0 +1,56 @@
+---
+uid: Microsoft.Quantum.Intrinsic.Measure
+title: Measure operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: Measure
+qsharp.summary: Performs a joint measurement of one or more qubits in the
+specified Pauli bases.
+---
+
+# Measure operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation Measure(bases : Pauli[], qubits : Qubit[]) : Result
+```
+
+## Summary
+Performs a joint measurement of one or more qubits in the
+specified Pauli bases.
+
+## Input
+### bases
+Array of single-qubit Pauli values indicating the tensor product
+factors on each qubit.
+### qubits
+Register of qubits to be measured.
+
+## Output
+`Zero` if the +1 eigenvalue is observed, and `One` if
+the -1 eigenvalue is observed.
+
+## Remarks
+The output result is given by the distribution:
+$$
+\begin{align}
+    \Pr(\texttt{Zero} | \ket{\psi}) =
+        \frac12 \braket{
+            \psi \mid|
+            \left(
+                \boldone + P_0 \otimes P_1 \otimes \cdots \otimes P_{N-1}
+            \right) \mid|
+            \psi
+        },
+\end{align}
+$$
+where $P_i$ is the $i$th element of `bases`, and where
+$N = \texttt{Length}(\texttt{bases})$.
+That is, measurement returns a `Result` $d$ such that the eigenvalue of the
+observed measurement effect is $(-1)^d$.
+
+If the basis array and qubit array are different lengths, then the
+operation will fail.

package/docs/Microsoft.Quantum.Intrinsic/Message.md

@@ -0,0 +1,30 @@
+---
+uid: Microsoft.Quantum.Intrinsic.Message
+title: Message function
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: function
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: Message
+qsharp.summary: Logs a message.
+---
+
+# Message function
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+function Message(msg : String) : Unit
+```
+
+## Summary
+Logs a message.
+
+## Input
+### msg
+The message to be reported.
+
+## Remarks
+The specific behavior of this function is simulator-dependent,
+but in most cases the given message will be written to the console.
+```

package/docs/Microsoft.Quantum.Intrinsic/R.md

@@ -0,0 +1,42 @@
+---
+uid: Microsoft.Quantum.Intrinsic.R
+title: R operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: R
+qsharp.summary: Applies a rotation about the given Pauli axis.
+---
+
+# R operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation R(pauli : Pauli, theta : Double, qubit : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a rotation about the given Pauli axis.
+
+## Input
+### pauli
+Pauli operator (μ) to be exponentiated to form the rotation.
+### theta
+Angle in radians about which the qubit is to be rotated.
+### qubit
+Qubit to which the gate should be applied.
+
+## Remarks
+$$
+\begin{align}
+    R_{\mu}(\theta) \mathrel{:=}
+    e^{-i \theta \sigma_{\mu} / 2},
+\end{align}
+$$
+where $\mu \in \{I, X, Y, Z\}$.
+
+When called with `pauli = PauliI`, this operation applies
+a *global phase*. This phase can be significant
+when used with the `Controlled` functor.

package/docs/Microsoft.Quantum.Intrinsic/R1.md

@@ -0,0 +1,41 @@
+---
+uid: Microsoft.Quantum.Intrinsic.R1
+title: R1 operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: R1
+qsharp.summary: Applies a rotation about the |1⟩ state by a given angle.
+---
+
+# R1 operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation R1(theta : Double, qubit : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a rotation about the |1⟩ state by a given angle.
+
+## Input
+### theta
+Angle about which the qubit is to be rotated.
+### qubit
+Qubit to which the gate should be applied.
+
+## Remarks
+$$
+\begin{align}
+    R_1(\theta) \mathrel{:=}
+    \operatorname{diag}(1, e^{i\theta}).
+\end{align}
+$$
+
+Equivalent to:
+```qsharp
+R(PauliZ, theta, qubit);
+R(PauliI, -theta, qubit);
+```

package/docs/Microsoft.Quantum.Intrinsic/R1Frac.md

@@ -0,0 +1,57 @@
+---
+uid: Microsoft.Quantum.Intrinsic.R1Frac
+title: R1Frac operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: R1Frac
+qsharp.summary: Applies a rotation about the |1⟩ state by an angle specified
+as a dyadic fraction.
+
+WARNING:
+This operation uses the **opposite** sign convention from
+Microsoft.Quantum.Intrinsic.R, and does not include the
+factor of 1/2 included by Microsoft.Quantum.Intrinsic.R1.
+---
+
+# R1Frac operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation R1Frac(numerator : Int, power : Int, qubit : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a rotation about the |1⟩ state by an angle specified
+as a dyadic fraction.
+
+WARNING:
+This operation uses the **opposite** sign convention from
+Microsoft.Quantum.Intrinsic.R, and does not include the
+factor of 1/2 included by Microsoft.Quantum.Intrinsic.R1.
+
+## Input
+### numerator
+Numerator in the dyadic fraction representation of the angle
+by which the qubit is to be rotated. This angle is expressed in radians.
+### power
+Power of two specifying the denominator of the angle by which
+the qubit is to be rotated. This angle is expressed in radians.
+### qubit
+Qubit to which the gate should be applied.
+
+## Remarks
+$$
+\begin{align}
+    R_1(n, k) \mathrel{:=}
+    \operatorname{diag}(1, e^{i \pi k / 2^n}).
+\end{align}
+$$
+
+Equivalent to:
+```qsharp
+RFrac(PauliZ, -numerator, denominator + 1, qubit);
+RFrac(PauliI, numerator, denominator + 1, qubit);
+```

package/docs/Microsoft.Quantum.Intrinsic/RFrac.md

@@ -0,0 +1,58 @@
+---
+uid: Microsoft.Quantum.Intrinsic.RFrac
+title: RFrac operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: RFrac
+qsharp.summary: Applies a rotation about the given Pauli axis by an angle specified
+as a dyadic fraction.
+
+WARNING:
+This operation uses the **opposite** sign convention from
+Microsoft.Quantum.Intrinsic.R.
+---
+
+# RFrac operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation RFrac(pauli : Pauli, numerator : Int, power : Int, qubit : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+Applies a rotation about the given Pauli axis by an angle specified
+as a dyadic fraction.
+
+WARNING:
+This operation uses the **opposite** sign convention from
+Microsoft.Quantum.Intrinsic.R.
+
+## Input
+### pauli
+Pauli operator to be exponentiated to form the rotation.
+### numerator
+Numerator in the dyadic fraction representation of the angle
+by which the qubit is to be rotated. This angle is expressed in radians.
+### power
+Power of two specifying the denominator of the angle by which
+the qubit is to be rotated. This angle is expressed in radians.
+### qubit
+Qubit to which the gate should be applied.
+
+## Remarks
+$$
+\begin{align}
+    R_{\mu}(n, k) \mathrel{:=}
+    e^{i \pi n \sigma_{\mu} / 2^k},
+\end{align}
+$$
+where $\mu \in \{I, X, Y, Z\}$.
+
+Equivalent to:
+```qsharp
+// PI() is a Q# function that returns an approximation of π.
+R(pauli, -PI() * IntAsDouble(numerator) / IntAsDouble(2 ^ (power - 1)), qubit);
+```

package/docs/Microsoft.Quantum.Intrinsic/Reset.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Intrinsic.Reset
+title: Reset operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: Reset
+qsharp.summary: Given a single qubit, measures it and ensures it is in the |0⟩ state
+such that it can be safely released.
+---
+
+# Reset operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation Reset(qubit : Qubit) : Unit
+```
+
+## Summary
+Given a single qubit, measures it and ensures it is in the |0⟩ state
+such that it can be safely released.
+
+## Input
+### qubit
+The qubit whose state is to be reset to |0⟩.

package/docs/Microsoft.Quantum.Intrinsic/ResetAll.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Intrinsic.ResetAll
+title: ResetAll operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Intrinsic
+qsharp.name: ResetAll
+qsharp.summary: Given an array of qubits, measure them and ensure they are in the |0⟩ state
+such that they can be safely released.
+---
+
+# ResetAll operation
+
+Namespace: [Microsoft.Quantum.Intrinsic](xref:Microsoft.Quantum.Intrinsic)
+
+```qsharp
+operation ResetAll(qubits : Qubit[]) : Unit
+```
+
+## Summary
+Given an array of qubits, measure them and ensure they are in the |0⟩ state
+such that they can be safely released.
+
+## Input
+### qubits
+An array of qubits whose states are to be reset to |0⟩.