qsharp-lang 1.8.2-dev → 1.8.4-dev

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Reversed.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Reversed
+uid: Qdk.Std.Arrays.Reversed
 title: Reversed function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Reversed
-qsharp.summary: "Create an array that contains the same elements as an input array but in reversed order."
+qsharp.summary: "Create an array that contains the same elements as an input array but in reversed order.  # Type Parameters ## 'T The type of the array elements.  # Input ## array An array whose elements are to be copied in reversed order.  # Output An array containing the elements `array[Length(array) - 1]` .. `array[0]`."
 ---
 
 # Reversed function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Reversed
+Fully qualified name: Std.Arrays.Reversed
 
 ```qsharp
 function Reversed<'T>(array : 'T[]) : 'T[]
 ```
 
-## Summary
 Create an array that contains the same elements as an input array but in reversed
 order.
 

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/SequenceI.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.SequenceI
+uid: Qdk.Std.Arrays.SequenceI
 title: SequenceI function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: SequenceI
-qsharp.summary: "Get an array of integers in a given interval."
+qsharp.summary: "Get an array of integers in a given interval.  # Input ## from An inclusive start index of the interval. ## to An inclusive end index of the interval that is not smaller than `from`.  # Output An array containing the sequence of numbers `from`, `from + 1`, ..., `to`.  # Example ```qsharp let arr1 = SequenceI(0, 3); // [0, 1, 2, 3] let arr2 = SequenceI(23, 29); // [23, 24, 25, 26, 27, 28, 29] let arr3 = SequenceI(-5, -2); // [-5, -4, -3, -2]  let numbers = SequenceI(0, _); // function to create sequence from 0 to `to` let naturals = SequenceI(1, _); // function to create sequence from 1 to `to` ```"
 ---
 
 # SequenceI function
 
-Fully qualified name: Microsoft.Quantum.Arrays.SequenceI
+Fully qualified name: Std.Arrays.SequenceI
 
 ```qsharp
 function SequenceI(from : Int, to : Int) : Int[]
 ```
 
-## Summary
 Get an array of integers in a given interval.
 
 ## Input

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/SequenceL.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.SequenceL
+uid: Qdk.Std.Arrays.SequenceL
 title: SequenceL function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: SequenceL
-qsharp.summary: "Get an array of integers in a given interval."
+qsharp.summary: "Get an array of integers in a given interval.  # Input ## from An inclusive start index of the interval. ## to An inclusive end index of the interval that is not smaller than `from`.  # Output An array containing the sequence of numbers `from`, `from + 1`, ..., `to`.  # Remarks The difference between `from` and `to` must fit into an `Int` value.  # Example ```qsharp let arr1 = SequenceL(0L, 3L); // [0L, 1L, 2L, 3L] let arr2 = SequenceL(23L, 29L); // [23L, 24L, 25L, 26L, 27L, 28L, 29L] let arr3 = SequenceL(-5L, -2L); // [-5L, -4L, -3L, -2L] ```"
 ---
 
 # SequenceL function
 
-Fully qualified name: Microsoft.Quantum.Arrays.SequenceL
+Fully qualified name: Std.Arrays.SequenceL
 
 ```qsharp
 function SequenceL(from : BigInt, to : BigInt) : BigInt[]
 ```
 
-## Summary
 Get an array of integers in a given interval.
 
 ## Input

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Sorted.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Sorted
+uid: Qdk.Std.Arrays.Sorted
 title: Sorted function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Sorted
-qsharp.summary: "Given an array, returns the elements of that array sorted by a given comparison function."
+qsharp.summary: "Given an array, returns the elements of that array sorted by a given comparison function.  # Type Parameters ## 'T The type of each element of `array`.  # Input ## comparison A function that compares two elements such that `a` is considered to be less than or equal to `b` if `comparison(a, b)` is `true`. ## array The array to be sorted.  # Output An array containing the same elements as `array`, such that for all elements `a` occurring earlier than elements `b`, `comparison(a, b)` is `true`.  # Example The following snippet sorts an array of integers to occur in ascending order: ```qsharp let sortedArray = Sorted(LessThanOrEqualI, [3, 17, 11, -201, -11]); ```  # Remarks The function `comparison` is assumed to be transitive, such that if `comparison(a, b)` and `comparison(b, c)`, then `comparison(a, c)` is assumed. If this property does not hold, then the output of this function may be incorrect."
 ---
 
 # Sorted function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Sorted
+Fully qualified name: Std.Arrays.Sorted
 
 ```qsharp
 function Sorted<'T>(comparison : (('T, 'T) -> Bool), array : 'T[]) : 'T[]
 ```
 
-## Summary
 Given an array, returns the elements of that array sorted by a given
 comparison function.
 

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Subarray.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Subarray
+uid: Qdk.Std.Arrays.Subarray
 title: Subarray function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Subarray
-qsharp.summary: "Takes an array and a list of locations and produces a new array formed from the elements of the original array that match the given locations."
+qsharp.summary: "Takes an array and a list of locations and produces a new array formed from the elements of the original array that match the given locations.  # Remarks If `locations` contains repeated elements, the corresponding elements of `array` will likewise be repeated.  # Type Parameters ## 'T The type of `array` elements.  # Input ## locations A list of locations in the input array that is used to define the subarray. ## array An array from which a subarray will be generated.  # Output An array `out` of elements whose locations correspond to the subarray, such that `out[index] == array[locations[index]]`.  # Example  ```qsharp let array = [1, 2, 3, 4]; let permutation = Subarray([3, 0, 2, 1], array); // [4, 1, 3, 2] let duplicates = Subarray([1, 2, 2], array);     // [2, 3, 3] ```"
 ---
 
 # Subarray function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Subarray
+Fully qualified name: Std.Arrays.Subarray
 
 ```qsharp
 function Subarray<'T>(locations : Int[], array : 'T[]) : 'T[]
 ```
 
-## Summary
 Takes an array and a list of locations and
 produces a new array formed from the elements of the original
 array that match the given locations.

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Swapped.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Swapped
+uid: Qdk.Std.Arrays.Swapped
 title: Swapped function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Swapped
-qsharp.summary: "Applies a swap of two elements in an array."
+qsharp.summary: "Applies a swap of two elements in an array.  # Input ## firstIndex Index of the first element to be swapped.  ## secondIndex Index of the second element to be swapped.  ## array Array with elements to be swapped.  # Output The array with the in place swap applied.  # Example ```qsharp // The following returns [0, 3, 2, 1, 4] Swapped(1, 3, [0, 1, 2, 3, 4]); ```"
 ---
 
 # Swapped function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Swapped
+Fully qualified name: Std.Arrays.Swapped
 
 ```qsharp
 function Swapped<'T>(firstIndex : Int, secondIndex : Int, array : 'T[]) : 'T[]
 ```
 
-## Summary
 Applies a swap of two elements in an array.
 
 ## Input

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Tail.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Tail
+uid: Qdk.Std.Arrays.Tail
 title: Tail function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Tail
-qsharp.summary: "Returns the last element of the array."
+qsharp.summary: "Returns the last element of the array.  # Type Parameters ## 'A The type of the array elements.  # Input ## array Array of which the last element is taken. Array must have at least 1 element.  # Output The last element of the array."
 ---
 
 # Tail function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Tail
+Fully qualified name: Std.Arrays.Tail
 
 ```qsharp
 function Tail<'A>(array : 'A[]) : 'A
 ```
 
-## Summary
 Returns the last element of the array.
 
 ## Type Parameters

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Transposed.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Transposed
+uid: Qdk.Std.Arrays.Transposed
 title: Transposed function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Transposed
-qsharp.summary: "Returns the transpose of a matrix represented as an array of arrays."
+qsharp.summary: "Returns the transpose of a matrix represented as an array of arrays.  # Description Input as an r x c matrix with r rows and c columns.  The matrix is row-based, i.e., `matrix[i][j]` accesses the element at row `i` and column `j`.  This function returns the c x r matrix that is the transpose of the input matrix.  # Type Parameters ## 'T The type of each element of `matrix`.  # Input ## matrix Row-based r x c matrix.  # Output Transposed c x r matrix.  # Example ```qsharp // same as [[1, 4], [2, 5], [3, 6]] let transposed = Transposed([[1, 2, 3], [4, 5, 6]]); ```"
 ---
 
 # Transposed function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Transposed
+Fully qualified name: Std.Arrays.Transposed
 
 ```qsharp
 function Transposed<'T>(matrix : 'T[][]) : 'T[][]
 ```
 
-## Summary
 Returns the transpose of a matrix represented as an array
 of arrays.
 

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Unzipped.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Unzipped
+uid: Qdk.Std.Arrays.Unzipped
 title: Unzipped function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Unzipped
-qsharp.summary: "Given an array of 2-tuples, returns a tuple of two arrays, each containing the elements of the tuples of the input array."
+qsharp.summary: "Given an array of 2-tuples, returns a tuple of two arrays, each containing the elements of the tuples of the input array.  # Type Parameters ## 'T The type of the first element in each tuple. ## 'U The type of the second element in each tuple.  # Input ## array An array containing 2-tuples.  # Output Two arrays, the first one containing all first elements of the input tuples, the second one containing all second elements of the input tuples.  # Example ```qsharp // split is same as ([5, 4, 3, 2, 1], [true, false, true, true, false]) let split = Unzipped([(5, true), (4, false), (3, true), (2, true), (1, false)]); ```  # See Also - Microsoft.Quantum.Arrays.Zipped"
 ---
 
 # Unzipped function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Unzipped
+Fully qualified name: Std.Arrays.Unzipped
 
 ```qsharp
 function Unzipped<'T, 'U>(array : ('T, 'U)[]) : ('T[], 'U[])
 ```
 
-## Summary
 Given an array of 2-tuples, returns a tuple of two arrays, each containing
 the elements of the tuples of the input array.
 

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Where.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Where
+uid: Qdk.Std.Arrays.Where
 title: Where function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Where
-qsharp.summary: "Given a predicate and an array, returns the indices of that array where the predicate is true."
+qsharp.summary: "Given a predicate and an array, returns the indices of that array where the predicate is true.  # Type Parameters ## 'T The type of `array` elements.  # Input ## predicate A function from `'T` to Boolean that is used to filter elements. ## array An array of elements over `'T`.  # Output An array of indices where `predicate` is true."
 ---
 
 # Where function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Where
+Fully qualified name: Std.Arrays.Where
 
 ```qsharp
 function Where<'T>(predicate : ('T -> Bool), array : 'T[]) : Int[]
 ```
 
-## Summary
 Given a predicate and an array, returns the indices of that
 array where the predicate is true.
 

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Windows.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Windows
+uid: Qdk.Std.Arrays.Windows
 title: Windows function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Windows
-qsharp.summary: "Returns all consecutive subarrays of length `size`."
+qsharp.summary: "Returns all consecutive subarrays of length `size`.  # Description This function returns all `n - size + 1` subarrays of length `size` in order, where `n` is the length of `array`. The first subarrays are `array[0..size - 1], array[1..size], array[2..size + 1]` until the last subarray `array[n - size..n - 1]`.  # Type Parameters ## 'T The type of `array` elements.  # Input ## size Length of the subarrays.  ## array An array of elements.  # Example ```qsharp // same as [[1, 2, 3], [2, 3, 4], [3, 4, 5]] let windows = Windows(3, [1, 2, 3, 4, 5]); ```  # Remarks The size of the window must be a positive integer no greater than the size of the array"
 ---
 
 # Windows function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Windows
+Fully qualified name: Std.Arrays.Windows
 
 ```qsharp
 function Windows<'T>(size : Int, array : 'T[]) : 'T[][]
 ```
 
-## Summary
 Returns all consecutive subarrays of length `size`.
 
 ## Description

package/docs/{Microsoft.Quantum.Arrays → Std.Arrays}/Zipped.md

@@ -1,23 +1,22 @@
 ---
-uid: Qdk.Microsoft.Quantum.Arrays.Zipped
+uid: Qdk.Std.Arrays.Zipped
 title: Zipped function
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
-qsharp.namespace: Microsoft.Quantum.Arrays
+qsharp.namespace: Std.Arrays
 qsharp.name: Zipped
-qsharp.summary: "Given two arrays, returns a new array of pairs such that each pair contains an element from each original array."
+qsharp.summary: "Given two arrays, returns a new array of pairs such that each pair contains an element from each original array.  # Type Parameters ## 'T The type of the left array elements. ## 'U The type of the right array elements.  # Input ## left An array containing values for the first element of each tuple. ## right An array containing values for the second element of each tuple.  # Output An array containing pairs of the form `(left[index], right[index])` for each `index`. If the two arrays are not of equal length, the output will be as long as the shorter of the inputs.  # Example ```qsharp let left = [1, 3, 71]; let right = [false, true]; let pairs = Zipped(left, right); // [(1, false), (3, true)] ```  # See Also - Microsoft.Quantum.Arrays.Unzipped"
 ---
 
 # Zipped function
 
-Fully qualified name: Microsoft.Quantum.Arrays.Zipped
+Fully qualified name: Std.Arrays.Zipped
 
 ```qsharp
 function Zipped<'T, 'U>(left : 'T[], right : 'U[]) : ('T, 'U)[]
 ```
 
-## Summary
 Given two arrays, returns a new array of pairs such that each pair
 contains an element from each original array.
 

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyCNOTChain.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyCNOTChain
+uid: Qdk.Std.Canon.ApplyCNOTChain
 title: ApplyCNOTChain operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.Canon
 qsharp.name: ApplyCNOTChain
 qsharp.summary: "Computes the parity of a register of qubits in-place."
 ---
 
 # ApplyCNOTChain operation
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyCNOTChain
+Fully qualified name: Std.Canon.ApplyCNOTChain
 
 ```qsharp
 operation ApplyCNOTChain(qubits : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyControlledOnBitString.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyControlledOnBitString
+uid: Qdk.Std.Canon.ApplyControlledOnBitString
 title: ApplyControlledOnBitString operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.Canon
 qsharp.name: ApplyControlledOnBitString
 qsharp.summary: "Applies `oracle` on `target` when `controlRegister` is in the state specified by `bits`."
 ---
 
 # ApplyControlledOnBitString operation
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyControlledOnBitString
+Fully qualified name: Std.Canon.ApplyControlledOnBitString
 
 ```qsharp
 operation ApplyControlledOnBitString<'T>(bits : Bool[], oracle : ('T => Unit is Adj + Ctl), controlRegister : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyControlledOnInt.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyControlledOnInt
+uid: Qdk.Std.Canon.ApplyControlledOnInt
 title: ApplyControlledOnInt operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyControlledOnInt
+Fully qualified name: Std.Canon.ApplyControlledOnInt
 
 ```qsharp
 operation ApplyControlledOnInt<'T>(numberState : Int, oracle : ('T => Unit is Adj + Ctl), controlRegister : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyP.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyP
+uid: Qdk.Std.Canon.ApplyP
 title: ApplyP operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.Canon
 qsharp.name: ApplyP
 qsharp.summary: "Given a single-qubit Pauli operator, applies the corresponding operation to a single qubit."
 ---
 
 # ApplyP operation
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyP
+Fully qualified name: Std.Canon.ApplyP
 
 ```qsharp
 operation ApplyP(pauli : Pauli, target : Qubit) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyPauli.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyPauli
+uid: Qdk.Std.Canon.ApplyPauli
 title: ApplyPauli operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.Canon
 qsharp.name: ApplyPauli
 qsharp.summary: "Given a multi-qubit Pauli operator, applies the corresponding operation to a quantum register."
 ---
 
 # ApplyPauli operation
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyPauli
+Fully qualified name: Std.Canon.ApplyPauli
 
 ```qsharp
 operation ApplyPauli(pauli : Pauli[], target : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyPauliFromBitString.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyPauliFromBitString
+uid: Qdk.Std.Canon.ApplyPauliFromBitString
 title: ApplyPauliFromBitString operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyPauliFromBitString
+Fully qualified name: Std.Canon.ApplyPauliFromBitString
 
 ```qsharp
 operation ApplyPauliFromBitString(pauli : Pauli, bitApply : Bool, bits : Bool[], qubits : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyPauliFromInt.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyPauliFromInt
+uid: Qdk.Std.Canon.ApplyPauliFromInt
 title: ApplyPauliFromInt operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyPauliFromInt
+Fully qualified name: Std.Canon.ApplyPauliFromInt
 
 ```qsharp
 operation ApplyPauliFromInt(pauli : Pauli, bitApply : Bool, numberState : Int, qubits : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyQFT.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyQFT
+uid: Qdk.Std.Canon.ApplyQFT
 title: ApplyQFT operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.Canon
 qsharp.name: ApplyQFT
 qsharp.summary: "Applies the rotations of Quantum Fourier Transform (QFT) to a little-endian quantum register."
 ---
 
 # ApplyQFT operation
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyQFT
+Fully qualified name: Std.Canon.ApplyQFT
 
 ```qsharp
 operation ApplyQFT(qs : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyToEach.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyToEach
+uid: Qdk.Std.Canon.ApplyToEach
 title: ApplyToEach operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.Canon
 qsharp.name: ApplyToEach
 qsharp.summary: "Applies an operation to each element in a register."
 ---
 
 # ApplyToEach operation
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyToEach
+Fully qualified name: Std.Canon.ApplyToEach
 
 ```qsharp
 operation ApplyToEach<'T>(singleElementOperation : ('T => Unit), register : 'T[]) : Unit

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyToEachA.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyToEachA
+uid: Qdk.Std.Canon.ApplyToEachA
 title: ApplyToEachA operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyToEachA
+Fully qualified name: Std.Canon.ApplyToEachA
 
 ```qsharp
 operation ApplyToEachA<'T>(singleElementOperation : ('T => Unit is Adj), register : 'T[]) : Unit is Adj

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyToEachC.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyToEachC
+uid: Qdk.Std.Canon.ApplyToEachC
 title: ApplyToEachC operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyToEachC
+Fully qualified name: Std.Canon.ApplyToEachC
 
 ```qsharp
 operation ApplyToEachC<'T>(singleElementOperation : ('T => Unit is Ctl), register : 'T[]) : Unit is Ctl

package/docs/{Microsoft.Quantum.Canon → Std.Canon}/ApplyToEachCA.md

@@ -1,17 +1,17 @@
 ---
-uid: Qdk.Microsoft.Quantum.Canon.ApplyToEachCA
+uid: Qdk.Std.Canon.ApplyToEachCA
 title: ApplyToEachCA operation
-ms.date: 09/10/2024 12:00:00 AM
+ms.date: 09/25/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
-qsharp.namespace: Microsoft.Quantum.Canon
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Canon.ApplyToEachCA
+Fully qualified name: Std.Canon.ApplyToEachCA
 
 ```qsharp
 operation ApplyToEachCA<'T>(singleElementOperation : ('T => Unit is Adj + Ctl), register : 'T[]) : Unit is Adj + Ctl