qsharp-lang 1.1.2-dev → 1.1.4-dev

package/docs/Microsoft.Quantum.Unstable.Arithmetic/ApplyIfLessOrEqualL.md

@@ -0,0 +1,23 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessOrEqualL
+title: ApplyIfLessOrEqualL operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: ApplyIfLessOrEqualL
+qsharp.summary: Computes `if (c <= x) { action(target) }`, that is, applies `action` to `target`
+if a BigInt value `c` is less or equal to the little-endian qubit register `x`
+---
+
+# ApplyIfLessOrEqualL operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation ApplyIfLessOrEqualL<'T>(action : ('T => Unit is Adj + Ctl), c : BigInt, x : Qubit[], target : 'T) : Unit is Adj + Ctl
+```
+
+## Summary
+Computes `if (c <= x) { action(target) }`, that is, applies `action` to `target`
+if a BigInt value `c` is less or equal to the little-endian qubit register `x`

package/docs/Microsoft.Quantum.Unstable.Arithmetic/ApplyIfLessOrEqualLE.md

@@ -0,0 +1,25 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessOrEqualLE
+title: ApplyIfLessOrEqualLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: ApplyIfLessOrEqualLE
+qsharp.summary: Computes `if x <= y { action(target) }`, that is, applies `action` to `target`
+if register `x` is less or equal to the register `y`.
+Both qubit registers should be in a little-endian format.
+---
+
+# ApplyIfLessOrEqualLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation ApplyIfLessOrEqualLE<'T>(action : ('T => Unit is Adj + Ctl), x : Qubit[], y : Qubit[], target : 'T) : Unit is Adj + Ctl
+```
+
+## Summary
+Computes `if x <= y { action(target) }`, that is, applies `action` to `target`
+if register `x` is less or equal to the register `y`.
+Both qubit registers should be in a little-endian format.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/FourierTDIncByLE.md

@@ -0,0 +1,32 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.FourierTDIncByLE
+title: FourierTDIncByLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: FourierTDIncByLE
+qsharp.summary: Increments a little-endian register ys by a little-endian register xs
+using Quantum Fourier Transform.
+---
+
+# FourierTDIncByLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation FourierTDIncByLE(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by a little-endian register xs
+using Quantum Fourier Transform.
+
+## Description
+Computes ys += xs modulo 2ⁿ, where xs and ys are little-endian registers,
+and Length(xs) = Length(ys) = n.
+This operation uses Quantum Fourier Transform.
+
+## Reference
+    - [arXiv:quant-ph/0008033](https://arxiv.org/abs/quant-ph/0008033)
+     "Addition on a Quantum Computer" by Thomas G. Draper

package/docs/Microsoft.Quantum.Unstable.Arithmetic/IncByI.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.IncByI
+title: IncByI operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: IncByI
+qsharp.summary: Increments a little-endian register ys by an integer number c
+---
+
+# IncByI operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation IncByI(c : Int, ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by an integer number c
+
+## Description
+Computes ys += c modulo 2ⁿ, where ys is a little-endian register,
+Length(ys) = n > 0, c is a Int number, 0 ≤ c < 2ⁿ.
+NOTE: Use IncByIUsingIncByLE directly if the choice of implementation
+is important.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/IncByIUsingIncByLE.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.IncByIUsingIncByLE
+title: IncByIUsingIncByLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: IncByIUsingIncByLE
+qsharp.summary: Increments a little-endian register ys by an Int number c
+using provided adder.
+---
+
+# IncByIUsingIncByLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation IncByIUsingIncByLE(adder : ((Qubit[], Qubit[]) => Unit is Adj + Ctl), c : Int, ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by an Int number c
+using provided adder.
+
+## Description
+Computes ys += c modulo 2ⁿ, where ys is a little-endian register
+Length(ys) = n > 0, c is an Int number, 0 ≤ c < 2ⁿ.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/IncByL.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.IncByL
+title: IncByL operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: IncByL
+qsharp.summary: Increments a little-endian register ys by a BigInt number c
+---
+
+# IncByL operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation IncByL(c : BigInt, ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by a BigInt number c
+
+## Description
+Computes ys += c modulo 2ⁿ, where ys is a little-endian register,
+Length(ys) = n > 0, c is a BigInt number, 0 ≤ c < 2ⁿ.
+NOTE: Use IncByLUsingIncByLE directly if the choice of implementation
+is important.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/IncByLE.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.IncByLE
+title: IncByLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: IncByLE
+qsharp.summary: Increments a little-endian register ys by a little-endian register xs
+---
+
+# IncByLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation IncByLE(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by a little-endian register xs
+
+## Description
+Computes ys += xs modulo 2ⁿ, where xs and ys are little-endian registers,
+and Length(xs) ≤ Length(ys) = n.
+NOTE: Use operations like RippleCarryCGIncByLE directly if
+the choice of implementation is important.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/IncByLEUsingAddLE.md

@@ -0,0 +1,36 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.IncByLEUsingAddLE
+title: IncByLEUsingAddLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: IncByLEUsingAddLE
+qsharp.summary: Generic operation to turn two out-place adders into one in-place adder
+---
+
+# IncByLEUsingAddLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation IncByLEUsingAddLE(forwardAdder : ((Qubit[], Qubit[], Qubit[]) => Unit is Adj), backwardAdder : ((Qubit[], Qubit[], Qubit[]) => Unit is Adj), xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Generic operation to turn two out-place adders into one in-place adder
+
+## Description
+This implementation allows to specify two distinct adders for forward
+and backward direction.  The forward adder is always applied in its
+body variant, whereas the backward adder is always applied in its adjoint
+variant.  Therefore, it's possible to, for example, use the ripple-carry
+out-of-place adder in backwards direction to require no T gates.
+
+The controlled variant is also optimized in a way that everything but
+the adders is controlled,
+
+## Reference
+    - [arXiv:2012.01624](https://arxiv.org/abs/2012.01624)
+      "Quantum block lookahead adders and the wait for magic states"
+      by by Craig Gidney.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/IncByLUsingIncByLE.md

@@ -0,0 +1,27 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.IncByLUsingIncByLE
+title: IncByLUsingIncByLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: IncByLUsingIncByLE
+qsharp.summary: Increments a little-endian register ys by a BigInt number c
+using provided adder.
+---
+
+# IncByLUsingIncByLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation IncByLUsingIncByLE(adder : ((Qubit[], Qubit[]) => Unit is Adj + Ctl), c : BigInt, ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by a BigInt number c
+using provided adder.
+
+## Description
+Computes ys += c modulo 2ⁿ, where ys is a little-endian register
+Length(ys) = n > 0, c is a BigInt number, 0 ≤ c < 2ⁿ.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/LookAheadDKRSAddLE.md

@@ -0,0 +1,36 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.LookAheadDKRSAddLE
+title: LookAheadDKRSAddLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: LookAheadDKRSAddLE
+qsharp.summary: Sets a zero-initialized little-endian register zs to the sum of
+little-endian registers xs and ys using the carry-lookahead algorithm.
+---
+
+# LookAheadDKRSAddLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation LookAheadDKRSAddLE(xs : Qubit[], ys : Qubit[], zs : Qubit[]) : Unit is Adj
+```
+
+## Summary
+Sets a zero-initialized little-endian register zs to the sum of
+little-endian registers xs and ys using the carry-lookahead algorithm.
+
+## Description
+Computes zs := xs + ys + zs[0] modulo 2ⁿ, where xs, ys, and zs are
+little-endian registers, Length(xs) = Length(ys) ≤ Length(zs) = n,
+assuming zs is 0-initialized, except for maybe zs[0], which can be
+in |0> or |1> state and can be used as carry-in.
+NOTE: `zs[Length(xs)]` can be used as carry-out, if `zs` is longer than `xs`.
+This operation uses the carry-lookahead algorithm.
+
+## Reference
+    - [arXiv:quant-ph/0406142](https://arxiv.org/abs/quant-ph/0406142)
+     "A logarithmic-depth quantum carry-lookahead adder" by
+     Thomas G. Draper, Samuel A. Kutin, Eric M. Rains, Krysta M. Svore

package/docs/Microsoft.Quantum.Unstable.Arithmetic/MAJ.md

@@ -0,0 +1,34 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.MAJ
+title: MAJ operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: MAJ
+qsharp.summary: This applies the in-place majority operation to 3 qubits.
+---
+
+# MAJ operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation MAJ(x : Qubit, y : Qubit, z : Qubit) : Unit is Adj + Ctl
+```
+
+## Summary
+This applies the in-place majority operation to 3 qubits.
+
+## Description
+Assuming the state of the input qubits are |x⟩, |y⟩ and |z⟩, then
+this operation performs the following transformation:
+|x⟩|y⟩|z⟩ ↦ |x ⊕ z⟩|y ⊕ z⟩MAJ(x, y, z).
+
+## Input
+### x
+The first input qubit.
+### y
+The second input qubit.
+### z
+A qubit onto which the majority function will be applied.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/ReflectAboutInteger.md

@@ -0,0 +1,37 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.ReflectAboutInteger
+title: ReflectAboutInteger operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: ReflectAboutInteger
+qsharp.summary: Reflects a quantum register about a given classical integer.
+---
+
+# ReflectAboutInteger operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation ReflectAboutInteger(index : Int, reg : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Reflects a quantum register about a given classical integer.
+
+## Description
+Given a quantum register initially in the state ∑ᵢ(αᵢ|i⟩),
+where each |i⟩ is a basis state representing an integer i,
+reflects the state of the register about the basis state |j⟩
+for a given integer j: ∑ᵢ(-1)^(δᵢⱼ)(αᵢ|i⟩)
+
+## Input
+### index
+The classical integer j indexing the basis state about which to reflect.
+### reg
+Little-endian quantum register to reflect.
+
+## Remarks
+This operation is implemented in-place, without explicit allocation of
+additional auxiliary qubits.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/RippleCarryCGAddLE.md

@@ -0,0 +1,34 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.RippleCarryCGAddLE
+title: RippleCarryCGAddLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: RippleCarryCGAddLE
+qsharp.summary: Sets a zero-initialized little-endian register zs to the sum of
+little-endian registers xs and ys using the ripple-carry algorithm.
+---
+
+# RippleCarryCGAddLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation RippleCarryCGAddLE(xs : Qubit[], ys : Qubit[], zs : Qubit[]) : Unit is Adj
+```
+
+## Summary
+Sets a zero-initialized little-endian register zs to the sum of
+little-endian registers xs and ys using the ripple-carry algorithm.
+
+## Description
+Computes zs := xs + ys + zs[0] modulo 2ⁿ, where xs, ys, and zs are
+little-endian registers, Length(xs) = Length(ys) ≤ Length(zs) = n,
+assuming zs is 0-initialized, except for maybe zs[0], which can be
+This operation uses the ripple-carry algorithm.
+NOTE: `zs[Length(xs)]` can be used as carry-out, if `zs` is longer than `xs`.
+
+## Reference
+    - [arXiv:1709.06648](https://arxiv.org/pdf/1709.06648.pdf)
+      "Halving the cost of quantum addition" by Craig Gidney.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/RippleCarryCGIncByLE.md

@@ -0,0 +1,34 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.RippleCarryCGIncByLE
+title: RippleCarryCGIncByLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: RippleCarryCGIncByLE
+qsharp.summary: Increments a little-endian register ys by a little-endian register xs
+using the ripple-carry algorithm.
+---
+
+# RippleCarryCGIncByLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation RippleCarryCGIncByLE(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Increments a little-endian register ys by a little-endian register xs
+using the ripple-carry algorithm.
+
+## Description
+Computes ys += xs modulo 2ⁿ, where xs and ys are little-endian registers,
+and Length(xs) ≤ Length(ys) = n.
+Note that if Length(xs) != Length(ys), xs is padded with 0-initialized
+qubits to match ys's length.
+This operation uses the ripple-carry algorithm.
+
+## Reference
+    - [arXiv:1709.06648](https://arxiv.org/pdf/1709.06648.pdf)
+      "Halving the cost of quantum addition" by Craig Gidney.

package/docs/Microsoft.Quantum.Unstable.Arithmetic/RippleCarryTTKIncByLE.md

@@ -0,0 +1,35 @@
+---
+uid: Microsoft.Quantum.Unstable.Arithmetic.RippleCarryTTKIncByLE
+title: RippleCarryTTKIncByLE operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.name: RippleCarryTTKIncByLE
+qsharp.summary: Reversible, in-place ripple-carry addition of two integers.
+---
+
+# RippleCarryTTKIncByLE operation
+
+Namespace: [Microsoft.Quantum.Unstable.Arithmetic](xref:Microsoft.Quantum.Unstable.Arithmetic)
+
+```qsharp
+operation RippleCarryTTKIncByLE(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Reversible, in-place ripple-carry addition of two integers.
+
+## Description
+Computes ys += xs modulo 2ⁿ, where xs and ys are little-endian registers,
+and Length(xs) ≤ Length(ys) = n.
+This operation uses the ripple-carry algorithm.
+Note that if Length(ys) >= Length(xs)+2, xs is padded with 0-initialized
+qubits to match ys's length. The operation doesn't use any auxilliary
+qubits otherwise.
+
+## References
+    - [arXiv:0910.2530](https://arxiv.org/abs/0910.2530)
+      "Quantum Addition Circuits and Unbounded Fan-Out"
+      by Yasuhiro Takahashi, Seiichiro Tani, Noboru Kunihiro
+

package/docs/Microsoft.Quantum.Unstable.StatePreparation/ApproximatelyPreparePureStateCP.md

@@ -0,0 +1,68 @@
+---
+uid: Microsoft.Quantum.Unstable.StatePreparation.ApproximatelyPreparePureStateCP
+title: ApproximatelyPreparePureStateCP operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.StatePreparation
+qsharp.name: ApproximatelyPreparePureStateCP
+qsharp.summary: Given a set of coefficients and a big-endian quantum register,
+prepares a state on that register described by the given coefficients,
+up to a given approximation tolerance.
+---
+
+# ApproximatelyPreparePureStateCP operation
+
+Namespace: [Microsoft.Quantum.Unstable.StatePreparation](xref:Microsoft.Quantum.Unstable.StatePreparation)
+
+```qsharp
+operation ApproximatelyPreparePureStateCP(tolerance : Double, coefficients : ComplexPolar[], qubits : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Given a set of coefficients and a big-endian quantum register,
+prepares a state on that register described by the given coefficients,
+up to a given approximation tolerance.
+
+## Description
+This operation prepares an arbitrary quantum
+state |𝜓⟩ with complex coefficients rⱼ·𝒆^(𝒊·tⱼ) from
+the n-qubit computational basis state |0...0⟩.
+In particular, the action of this operation can be simulated by the
+a unitary transformation U which acts on the all-zeros state as
+
+$$
+\begin{align}
+    U\ket{0...0}
+        & = \ket{\psi} \\\\
+        & = \frac{
+                \sum_{j=0}^{2^n-1} r_j e^{i t_j} \ket{j}
+            }{
+                \sqrt{\sum_{j=0}^{2^n-1} |r_j|^2}
+            }.
+\end{align}
+$$
+
+## Input
+### tolerance
+The approximation tolerance to be used when preparing the given state.
+
+### coefficients
+Array of up to 2ⁿ complex coefficients represented by their
+absolute value and phase (rⱼ, tⱼ). The j-th coefficient
+indexes the number state |j⟩ encoded in a big-endian format.
+
+### qubits
+Qubit register encoding number states in a big-endian format. This is
+expected to be initialized in the computational basis state
+|0...0⟩.
+
+## Remarks
+`coefficients` will be padded with
+elements (rⱼ, tⱼ) = (0.0, 0.0) if fewer than 2ⁿ are
+specified.
+
+## References
+- Synthesis of Quantum Logic Circuits
+  Vivek V. Shende, Stephen S. Bullock, Igor L. Markov
+  https://arxiv.org/abs/quant-ph/0406176

package/docs/Microsoft.Quantum.Unstable.StatePreparation/PreparePureStateD.md

@@ -0,0 +1,65 @@
+---
+uid: Microsoft.Quantum.Unstable.StatePreparation.PreparePureStateD
+title: PreparePureStateD operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.StatePreparation
+qsharp.name: PreparePureStateD
+qsharp.summary: Given a set of coefficients and a big-endian quantum register,
+prepares a state on that register described by the given coefficients.
+---
+
+# PreparePureStateD operation
+
+Namespace: [Microsoft.Quantum.Unstable.StatePreparation](xref:Microsoft.Quantum.Unstable.StatePreparation)
+
+```qsharp
+operation PreparePureStateD(coefficients : Double[], qubits : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Given a set of coefficients and a big-endian quantum register,
+prepares a state on that register described by the given coefficients.
+
+## Description
+This operation prepares an arbitrary quantum
+state |𝜓⟩ with coefficients 𝑎ⱼ from
+the n-qubit computational basis state |0...0⟩.
+
+The action of U on the all-zeros state is given by
+$$
+\begin{align}
+    U \ket{0\cdots 0} = \ket{\psi} = \frac{\sum_{j=0}^{2^n-1}\alpha_j \ket{j}}{\sqrt{\sum_{j=0}^{2^n-1}|\alpha_j|^2}}.
+\end{align}
+$$
+
+## Input
+### coefficients
+Array of up to 2ⁿ real coefficients. The j-th coefficient
+indexes the number state |j⟩ encoded in big-endian format.
+
+### qubits
+Qubit register encoding number states in a big-endian format. This is
+expected to be initialized in the computational basis state |0...0⟩.
+
+## Remarks
+`coefficients` will be normalized and padded with
+elements 𝑎ⱼ = 0.0 if fewer than 2ⁿ are specified.
+
+## Example
+The following snippet prepares the quantum state |𝜓⟩=√(1/8)|0⟩+√(7/8)|2⟩=√(1/8)|00⟩+√(7/8)|10⟩
+in the qubit register `qubits`.
+```qsharp
+let amplitudes = [Sqrt(0.125), 0.0, Sqrt(0.875), 0.0];
+use qubits = Qubit[2];
+PreparePureStateD(amplitudes, qubits);
+```
+
+## References
+- Synthesis of Quantum Logic Circuits
+  Vivek V. Shende, Stephen S. Bullock, Igor L. Markov
+  https://arxiv.org/abs/quant-ph/0406176
+
+## See Also
+- Microsoft.Quantum.Unstable.StatePreparation.ApproximatelyPreparePureStateCP

package/docs/Microsoft.Quantum.Unstable.TableLookup/Select.md

@@ -0,0 +1,53 @@
+---
+uid: Microsoft.Quantum.Unstable.TableLookup.Select
+title: Select operation
+ms.date: 02/16/2024 12:00:00 AM
+ms.topic: managed-reference
+qsharp.kind: opeartion
+qsharp.namespace: Microsoft.Quantum.Unstable.TableLookup
+qsharp.name: Select
+qsharp.summary: Performs table lookup using a SELECT network
+---
+
+# Select operation
+
+Namespace: [Microsoft.Quantum.Unstable.TableLookup](xref:Microsoft.Quantum.Unstable.TableLookup)
+
+```qsharp
+operation Select(data : Bool[][], address : Qubit[], target : Qubit[]) : Unit is Adj + Ctl
+```
+
+## Summary
+Performs table lookup using a SELECT network
+
+## Description
+Assuming a zero-initialized `target` register, this operation will
+initialize it with the bitstrings in `data` at indices according to the
+computational values of the `address` register.
+
+## Input
+### data
+The classical table lookup data which is prepared in `target` with
+respect to the state in `address`. The length of data must be less than
+2ⁿ, where 𝑛 is the length of `address`. Each entry in data must have
+the same length that must be equal to the length of `target`.
+### address
+Address register
+### target
+Zero-initialized target register
+
+## Remarks
+The implementation of the SELECT network is based on unary encoding as
+presented in [1].  The recursive implementation of that algorithm is
+presented in [3].  The adjoint variant is optimized using a
+measurement-based unlookup operation [3]. The controlled adjoint variant
+is not optimized using this technique.
+
+## References
+[1] [arXiv:1805.03662](https://arxiv.org/abs/1805.03662)
+    "Encoding Electronic Spectra in Quantum Circuits with Linear T
+     Complexity"
+[2] [arXiv:1905.07682](https://arxiv.org/abs/1905.07682)
+    "Windowed arithmetic"
+[3] [arXiv:2211.01133](https://arxiv.org/abs/2211.01133)
+    "Space-time optimized table lookup"