qsharp-lang 1.10.2-dev → 1.10.3-dev

package/docs/Microsoft.Quantum.Core/Length.md

@@ -1,19 +1,18 @@
 ---
 uid: Qdk.Microsoft.Quantum.Core.Length
 title: Length exported item
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# Length exported item: This is an exported item. The actual definition is found here: [Length](xref:Qdk.Std.Core.Length)"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core
 qsharp.name: Length
-qsharp.summary: ""
+qsharp.summary: "This is an exported item. The actual definition is found here: [Length](xref:Qdk.Std.Core.Length)"
 ---
 
 # Length exported item
 
 Fully qualified name: Microsoft.Quantum.Core.Length
 
-```qsharp
-
-```
+This is an exported item. The actual definition is found here: [Length](xref:Qdk.Std.Core.Length)

package/docs/Microsoft.Quantum.Core/Repeated.md

@@ -1,19 +1,18 @@
 ---
 uid: Qdk.Microsoft.Quantum.Core.Repeated
 title: Repeated exported item
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# Repeated exported item: This is an exported item. The actual definition is found here: [Repeated](xref:Qdk.Std.Core.Repeated)"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core
 qsharp.name: Repeated
-qsharp.summary: ""
+qsharp.summary: "This is an exported item. The actual definition is found here: [Repeated](xref:Qdk.Std.Core.Repeated)"
 ---
 
 # Repeated exported item
 
 Fully qualified name: Microsoft.Quantum.Core.Repeated
 
-```qsharp
-
-```
+This is an exported item. The actual definition is found here: [Repeated](xref:Qdk.Std.Core.Repeated)

package/docs/Microsoft.Quantum.Core/index.md

@@ -0,0 +1,18 @@
+---
+uid: Qdk.Microsoft.Quantum.Core-toc
+title: Microsoft.Quantum.Core namespace
+description: Table of contents for the Q# Microsoft.Quantum.Core namespace
+author: {AUTHOR}
+ms.author: {MS_AUTHOR}
+ms.date: 11/15/2024
+ms.topic: landing-page
+---
+
+# Microsoft.Quantum.Core
+
+The Microsoft.Quantum.Core namespace contains the following items:
+
+| Name | Description |
+|------|-------------|
+| [Length](xref:Qdk.Microsoft.Quantum.Core.Length) | This is an exported item. The actual definition is found here: [Length](xref:Qdk.Std.Core.Length) |
+| [Repeated](xref:Qdk.Microsoft.Quantum.Core.Repeated) | This is an exported item. The actual definition is found here: [Repeated](xref:Qdk.Std.Core.Repeated) |

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/AddLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.AddLE
+uid: Qdk.Std.Arithmetic.AddLE
 title: AddLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# AddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: AddLE
 qsharp.summary: "Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys"
 ---
 
 # AddLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.AddLE
+Fully qualified name: Std.Arithmetic.AddLE
 
 ```qsharp
 operation AddLE(xs : Qubit[], ys : Qubit[], zs : Qubit[]) : Unit is Adj

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfEqualL.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfEqualL
+uid: Qdk.Std.Arithmetic.ApplyIfEqualL
 title: ApplyIfEqualL operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfEqualL operation: Computes `if (c == x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is equal to the little-endian qubit register `x`"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfEqualL
 qsharp.summary: "Computes `if (c == x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is equal to the little-endian qubit register `x`"
 ---
 
 # ApplyIfEqualL operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfEqualL
+Fully qualified name: Std.Arithmetic.ApplyIfEqualL
 
 ```qsharp
 operation ApplyIfEqualL<'T>(action : ('T => Unit is Adj + Ctl), c : BigInt, xs : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfEqualLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfEqualLE
+uid: Qdk.Std.Arithmetic.ApplyIfEqualLE
 title: ApplyIfEqualLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfEqualLE operation: Computes `if x == y { action(target) }`, that is, applies `action` to `target` if register `x` is equal to the register `y`. Both qubit registers should be in a little-endian format."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfEqualLE
 qsharp.summary: "Computes `if x == y { action(target) }`, that is, applies `action` to `target` if register `x` is equal to the register `y`. Both qubit registers should be in a little-endian format."
 ---
 
 # ApplyIfEqualLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfEqualLE
+Fully qualified name: Std.Arithmetic.ApplyIfEqualLE
 
 ```qsharp
 operation ApplyIfEqualLE<'T>(action : ('T => Unit is Adj + Ctl), x : Qubit[], y : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfGreaterL.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterL
+uid: Qdk.Std.Arithmetic.ApplyIfGreaterL
 title: ApplyIfGreaterL operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfGreaterL operation: Computes `if (c > x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater than the little-endian qubit register `x`"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfGreaterL
 qsharp.summary: "Computes `if (c > x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater than the little-endian qubit register `x`"
 ---
 
 # ApplyIfGreaterL operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterL
+Fully qualified name: Std.Arithmetic.ApplyIfGreaterL
 
 ```qsharp
 operation ApplyIfGreaterL<'T>(action : ('T => Unit is Adj + Ctl), c : BigInt, x : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfGreaterLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterLE
+uid: Qdk.Std.Arithmetic.ApplyIfGreaterLE
 title: ApplyIfGreaterLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfGreaterLE operation: Computes `if x > y { action(target) }`, that is, applies `action` to `target` if register `x` is greater than the register `y`. Both qubit registers should be in a little-endian format."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfGreaterLE
 qsharp.summary: "Computes `if x > y { action(target) }`, that is, applies `action` to `target` if register `x` is greater than the register `y`. Both qubit registers should be in a little-endian format."
 ---
 
 # ApplyIfGreaterLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterLE
+Fully qualified name: Std.Arithmetic.ApplyIfGreaterLE
 
 ```qsharp
 operation ApplyIfGreaterLE<'T>(action : ('T => Unit is Adj + Ctl), x : Qubit[], y : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfGreaterOrEqualL.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterOrEqualL
+uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualL
 title: ApplyIfGreaterOrEqualL operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfGreaterOrEqualL operation: Computes `if (c >= x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater or equal to the little-endian qubit register `x`"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfGreaterOrEqualL
 qsharp.summary: "Computes `if (c >= x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater or equal to the little-endian qubit register `x`"
 ---
 
 # ApplyIfGreaterOrEqualL operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterOrEqualL
+Fully qualified name: Std.Arithmetic.ApplyIfGreaterOrEqualL
 
 ```qsharp
 operation ApplyIfGreaterOrEqualL<'T>(action : ('T => Unit is Adj + Ctl), c : BigInt, x : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfGreaterOrEqualLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterOrEqualLE
+uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualLE
 title: ApplyIfGreaterOrEqualLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfGreaterOrEqualLE operation: Computes `if x >= y { action(target) }`, that is, applies `action` to `target` if register `x` is greater or equal to the register `y`. Both qubit registers should be in a little-endian format."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfGreaterOrEqualLE
 qsharp.summary: "Computes `if x >= y { action(target) }`, that is, applies `action` to `target` if register `x` is greater or equal to the register `y`. Both qubit registers should be in a little-endian format."
 ---
 
 # ApplyIfGreaterOrEqualLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfGreaterOrEqualLE
+Fully qualified name: Std.Arithmetic.ApplyIfGreaterOrEqualLE
 
 ```qsharp
 operation ApplyIfGreaterOrEqualLE<'T>(action : ('T => Unit is Adj + Ctl), x : Qubit[], y : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfLessL.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessL
+uid: Qdk.Std.Arithmetic.ApplyIfLessL
 title: ApplyIfLessL operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfLessL operation: Computes `if (c < x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is less than the little-endian qubit register `x`"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfLessL
 qsharp.summary: "Computes `if (c < x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is less than the little-endian qubit register `x`"
 ---
 
 # ApplyIfLessL operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessL
+Fully qualified name: Std.Arithmetic.ApplyIfLessL
 
 ```qsharp
 operation ApplyIfLessL<'T>(action : ('T => Unit is Adj + Ctl), c : BigInt, x : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfLessLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessLE
+uid: Qdk.Std.Arithmetic.ApplyIfLessLE
 title: ApplyIfLessLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfLessLE operation: Computes `if x < y { action(target) }`, that is, applies `action` to `target` if register `x` is less than the register `y`. Both qubit registers should be in a little-endian format."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ApplyIfLessLE
 qsharp.summary: "Computes `if x < y { action(target) }`, that is, applies `action` to `target` if register `x` is less than the register `y`. Both qubit registers should be in a little-endian format."
 ---
 
 # ApplyIfLessLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessLE
+Fully qualified name: Std.Arithmetic.ApplyIfLessLE
 
 ```qsharp
 operation ApplyIfLessLE<'T>(action : ('T => Unit is Adj + Ctl), x : Qubit[], y : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfLessOrEqualL.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessOrEqualL
+uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualL
 title: ApplyIfLessOrEqualL operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfLessOrEqualL operation: 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`"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessOrEqualL
+Fully qualified name: Std.Arithmetic.ApplyIfLessOrEqualL
 
 ```qsharp
 operation ApplyIfLessOrEqualL<'T>(action : ('T => Unit is Adj + Ctl), c : BigInt, x : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ApplyIfLessOrEqualLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessOrEqualLE
+uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualLE
 title: ApplyIfLessOrEqualLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ApplyIfLessOrEqualLE operation: 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."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ApplyIfLessOrEqualLE
+Fully qualified name: Std.Arithmetic.ApplyIfLessOrEqualLE
 
 ```qsharp
 operation ApplyIfLessOrEqualLE<'T>(action : ('T => Unit is Adj + Ctl), x : Qubit[], y : Qubit[], target : 'T) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/FourierTDIncByLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.FourierTDIncByLE
+uid: Qdk.Std.Arithmetic.FourierTDIncByLE
 title: FourierTDIncByLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# FourierTDIncByLE operation: Increments a little-endian register ys by a little-endian register xs using Quantum Fourier Transform."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: FourierTDIncByLE
 qsharp.summary: "Increments a little-endian register ys by a little-endian register xs using Quantum Fourier Transform."
 ---
 
 # FourierTDIncByLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.FourierTDIncByLE
+Fully qualified name: Std.Arithmetic.FourierTDIncByLE
 
 ```qsharp
 operation FourierTDIncByLE(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/IncByI.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.IncByI
+uid: Qdk.Std.Arithmetic.IncByI
 title: IncByI operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# IncByI operation: Increments a little-endian register ys by an integer number c"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: IncByI
 qsharp.summary: "Increments a little-endian register ys by an integer number c"
 ---
 
 # IncByI operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.IncByI
+Fully qualified name: Std.Arithmetic.IncByI
 
 ```qsharp
 operation IncByI(c : Int, ys : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/IncByIUsingIncByLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.IncByIUsingIncByLE
+uid: Qdk.Std.Arithmetic.IncByIUsingIncByLE
 title: IncByIUsingIncByLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# IncByIUsingIncByLE operation: Increments a little-endian register ys by an Int number c using provided adder."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: IncByIUsingIncByLE
 qsharp.summary: "Increments a little-endian register ys by an Int number c using provided adder."
 ---
 
 # IncByIUsingIncByLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.IncByIUsingIncByLE
+Fully qualified name: Std.Arithmetic.IncByIUsingIncByLE
 
 ```qsharp
 operation IncByIUsingIncByLE(adder : ((Qubit[], Qubit[]) => Unit is Adj + Ctl), c : Int, ys : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/IncByL.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.IncByL
+uid: Qdk.Std.Arithmetic.IncByL
 title: IncByL operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# IncByL operation: Increments a little-endian register ys by a BigInt number c"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: IncByL
 qsharp.summary: "Increments a little-endian register ys by a BigInt number c"
 ---
 
 # IncByL operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.IncByL
+Fully qualified name: Std.Arithmetic.IncByL
 
 ```qsharp
 operation IncByL(c : BigInt, ys : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/IncByLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.IncByLE
+uid: Qdk.Std.Arithmetic.IncByLE
 title: IncByLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# IncByLE operation: Increments a little-endian register ys by a little-endian register xs"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: IncByLE
 qsharp.summary: "Increments a little-endian register ys by a little-endian register xs"
 ---
 
 # IncByLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.IncByLE
+Fully qualified name: Std.Arithmetic.IncByLE
 
 ```qsharp
 operation IncByLE(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/IncByLEUsingAddLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.IncByLEUsingAddLE
+uid: Qdk.Std.Arithmetic.IncByLEUsingAddLE
 title: IncByLEUsingAddLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# IncByLEUsingAddLE operation: Generic operation to turn two out-place adders into one in-place adder"
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: IncByLEUsingAddLE
 qsharp.summary: "Generic operation to turn two out-place adders into one in-place adder"
 ---
 
 # IncByLEUsingAddLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.IncByLEUsingAddLE
+Fully qualified name: Std.Arithmetic.IncByLEUsingAddLE
 
 ```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

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/IncByLUsingIncByLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.IncByLUsingIncByLE
+uid: Qdk.Std.Arithmetic.IncByLUsingIncByLE
 title: IncByLUsingIncByLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# IncByLUsingIncByLE operation: Increments a little-endian register ys by a BigInt number c using provided adder."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: IncByLUsingIncByLE
 qsharp.summary: "Increments a little-endian register ys by a BigInt number c using provided adder."
 ---
 
 # IncByLUsingIncByLE operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.IncByLUsingIncByLE
+Fully qualified name: Std.Arithmetic.IncByLUsingIncByLE
 
 ```qsharp
 operation IncByLUsingIncByLE(adder : ((Qubit[], Qubit[]) => Unit is Adj + Ctl), c : BigInt, ys : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/LookAheadDKRSAddLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.LookAheadDKRSAddLE
+uid: Qdk.Std.Arithmetic.LookAheadDKRSAddLE
 title: LookAheadDKRSAddLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# LookAheadDKRSAddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys using the carry-lookahead algorithm."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.LookAheadDKRSAddLE
+Fully qualified name: Std.Arithmetic.LookAheadDKRSAddLE
 
 ```qsharp
 operation LookAheadDKRSAddLE(xs : Qubit[], ys : Qubit[], zs : Qubit[]) : Unit is Adj

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/MAJ.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.MAJ
+uid: Qdk.Std.Arithmetic.MAJ
 title: MAJ operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# MAJ operation: This applies the in-place majority operation to 3 qubits."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: MAJ
 qsharp.summary: "This applies the in-place majority operation to 3 qubits."
 ---
 
 # MAJ operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.MAJ
+Fully qualified name: Std.Arithmetic.MAJ
 
 ```qsharp
 operation MAJ(x : Qubit, y : Qubit, z : Qubit) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/ReflectAboutInteger.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.ReflectAboutInteger
+uid: Qdk.Std.Arithmetic.ReflectAboutInteger
 title: ReflectAboutInteger operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# ReflectAboutInteger operation: Reflects a quantum register about a given classical integer."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.Arithmetic
 qsharp.name: ReflectAboutInteger
 qsharp.summary: "Reflects a quantum register about a given classical integer."
 ---
 
 # ReflectAboutInteger operation
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.ReflectAboutInteger
+Fully qualified name: Std.Arithmetic.ReflectAboutInteger
 
 ```qsharp
 operation ReflectAboutInteger(index : Int, reg : Qubit[]) : Unit is Adj + Ctl

package/docs/{Microsoft.Quantum.Unstable.Arithmetic → Std.Arithmetic}/RippleCarryCGAddLE.md

@@ -1,18 +1,19 @@
 ---
-uid: Qdk.Microsoft.Quantum.Unstable.Arithmetic.RippleCarryCGAddLE
+uid: Qdk.Std.Arithmetic.RippleCarryCGAddLE
 title: RippleCarryCGAddLE operation
-ms.date: 11/01/2024 12:00:00 AM
+description: "Q# RippleCarryCGAddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys using the ripple-carry algorithm."
+ms.date: 11/15/2024
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__
-qsharp.namespace: Microsoft.Quantum.Unstable.Arithmetic
+qsharp.namespace: Std.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
 
-Fully qualified name: Microsoft.Quantum.Unstable.Arithmetic.RippleCarryCGAddLE
+Fully qualified name: Std.Arithmetic.RippleCarryCGAddLE
 
 ```qsharp
 operation RippleCarryCGAddLE(xs : Qubit[], ys : Qubit[], zs : Qubit[]) : Unit is Adj