qsharp-lang 1.23.1-dev → 1.23.2-dev

package/dist/browser.d.ts

@@ -17,7 +17,7 @@ export declare function getLanguageService(host?: IProjectHost): Promise<ILangua
 export declare function getLanguageServiceWorker(worker: string | Worker): ILanguageServiceWorker;
 export declare function getTargetProfileFromEntryPoint(fileName: string, source: string): Promise<wasm.TargetProfile | undefined>;
 export { StepResultId } from "../lib/web/qsc_wasm.js";
-export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, ITestDescriptor, IWorkspaceEdit, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, ITestDescriptor, IVariable, IVariableChild, IWorkspaceEdit, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
 export { type Dump, type ShotResult } from "./compiler/common.js";
 export { type CompilerState, type ProgramConfig } from "./compiler/compiler.js";
 export { QscEventTarget } from "./compiler/events.js";

package/dist/katas-content.generated.js

@@ -9834,7 +9834,7 @@ export default {
         },
         {
             "id": "qec_shor__Common.qs",
-            "code": "namespace Kata.Verification {\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Random.*;\n\n    operation CheckErrorDetection(\n        n : Int,\n        encode : (Qubit[] => Unit is Adj),\n        error : (Qubit => Unit is Adj),\n        detect : (Qubit[] => Int)\n    ) : Bool {\n        for err_ind in -1..n - 1 {\n            for _ in 1..10 {\n                use qs = Qubit[n];\n                let theta = DrawRandomDouble(0.0, 1.0);\n                within {\n                    // Prepare logical state on first qubit\n                    Ry(2.0 * theta * PI(), qs[0]);\n                    // Encode the state in multiple qubits\n                    encode(qs);\n                    // Introduce X error\n                    if err_ind > -1 {\n                        error(qs[err_ind]);\n                    }\n                } apply {\n                    // Call solution to detect index\n                    let detected = detect(qs);\n                    // Check that it is correct\n                    if detected != err_ind {\n                        Message(\"Incorrect.\");\n                        let actual = err_ind == -1 ? \"No error happened\" | $\"Error happened on qubit {err_ind}\";\n                        Message($\"{actual}, but solution returned {detected}\");\n                        ResetAll(qs);\n                        return false;\n                    }\n                }\n                // Check that the state was not modified by the solution\n                if not CheckAllZero(qs) {\n                    Message(\"Incorrect.\");\n                    Message(\"The state of the qubits changed after the solution was applied\");\n                    ResetAll(qs);\n                    return false;\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Random.*;\n\n    operation CheckErrorDetection(\n        n : Int,\n        encode : (Qubit[] => Unit is Adj),\n        error : (Qubit => Unit is Adj),\n        detect : (Qubit[] => Int)\n    ) : Bool {\n        for err_ind in -1..n - 1 {\n            for _ in 1..10 {\n                use qs = Qubit[n];\n                let theta = DrawRandomDouble(0.0, 1.0);\n                let correct = within {\n                    // Prepare logical state on first qubit\n                    Ry(2.0 * theta * PI(), qs[0]);\n                    // Encode the state in multiple qubits\n                    encode(qs);\n                    // Introduce X error\n                    if err_ind > -1 {\n                        error(qs[err_ind]);\n                    }\n                } apply {\n                    // Call solution to detect index\n                    let detected = detect(qs);\n                    // Check that it is correct\n                    if detected != err_ind {\n                        Message(\"Incorrect.\");\n                        let actual = err_ind == -1 ? \"No error happened\" | $\"Error happened on qubit {err_ind}\";\n                        Message($\"{actual}, but solution returned {detected}\");\n                        false\n                    } else {\n                        true\n                    }\n                };\n                if not correct {\n                    ResetAll(qs);\n                    return false;\n                }\n                // Check that the state was not modified by the solution\n                if not CheckAllZero(qs) {\n                    Message(\"Incorrect.\");\n                    Message(\"The state of the qubits changed after the solution was applied\");\n                    ResetAll(qs);\n                    return false;\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "qec_shor__xx_measurement__Verification.qs",

package/dist/katas-content.generated.md.js

@@ -9834,7 +9834,7 @@ export default {
         },
         {
             "id": "qec_shor__Common.qs",
-            "code": "namespace Kata.Verification {\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Random.*;\n\n    operation CheckErrorDetection(\n        n : Int,\n        encode : (Qubit[] => Unit is Adj),\n        error : (Qubit => Unit is Adj),\n        detect : (Qubit[] => Int)\n    ) : Bool {\n        for err_ind in -1..n - 1 {\n            for _ in 1..10 {\n                use qs = Qubit[n];\n                let theta = DrawRandomDouble(0.0, 1.0);\n                within {\n                    // Prepare logical state on first qubit\n                    Ry(2.0 * theta * PI(), qs[0]);\n                    // Encode the state in multiple qubits\n                    encode(qs);\n                    // Introduce X error\n                    if err_ind > -1 {\n                        error(qs[err_ind]);\n                    }\n                } apply {\n                    // Call solution to detect index\n                    let detected = detect(qs);\n                    // Check that it is correct\n                    if detected != err_ind {\n                        Message(\"Incorrect.\");\n                        let actual = err_ind == -1 ? \"No error happened\" | $\"Error happened on qubit {err_ind}\";\n                        Message($\"{actual}, but solution returned {detected}\");\n                        ResetAll(qs);\n                        return false;\n                    }\n                }\n                // Check that the state was not modified by the solution\n                if not CheckAllZero(qs) {\n                    Message(\"Incorrect.\");\n                    Message(\"The state of the qubits changed after the solution was applied\");\n                    ResetAll(qs);\n                    return false;\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    import Std.Diagnostics.*;\n    import Std.Math.*;\n    import Std.Random.*;\n\n    operation CheckErrorDetection(\n        n : Int,\n        encode : (Qubit[] => Unit is Adj),\n        error : (Qubit => Unit is Adj),\n        detect : (Qubit[] => Int)\n    ) : Bool {\n        for err_ind in -1..n - 1 {\n            for _ in 1..10 {\n                use qs = Qubit[n];\n                let theta = DrawRandomDouble(0.0, 1.0);\n                let correct = within {\n                    // Prepare logical state on first qubit\n                    Ry(2.0 * theta * PI(), qs[0]);\n                    // Encode the state in multiple qubits\n                    encode(qs);\n                    // Introduce X error\n                    if err_ind > -1 {\n                        error(qs[err_ind]);\n                    }\n                } apply {\n                    // Call solution to detect index\n                    let detected = detect(qs);\n                    // Check that it is correct\n                    if detected != err_ind {\n                        Message(\"Incorrect.\");\n                        let actual = err_ind == -1 ? \"No error happened\" | $\"Error happened on qubit {err_ind}\";\n                        Message($\"{actual}, but solution returned {detected}\");\n                        false\n                    } else {\n                        true\n                    }\n                };\n                if not correct {\n                    ResetAll(qs);\n                    return false;\n                }\n                // Check that the state was not modified by the solution\n                if not CheckAllZero(qs) {\n                    Message(\"Incorrect.\");\n                    Message(\"The state of the qubits changed after the solution was applied\");\n                    ResetAll(qs);\n                    return false;\n                }\n            }\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "qec_shor__xx_measurement__Verification.qs",

package/dist/main.d.ts

@@ -13,3 +13,4 @@ export declare function getDebugServiceWorker(): IDebugServiceWorker;
 export declare function getLanguageService(host?: IProjectHost): ILanguageService;
 export declare function getLanguageServiceWorker(): ILanguageServiceWorker;
 export * as utils from "./utils.js";
+export type { IVariable, IVariableChild } from "./browser.js";

package/dist/samples.generated.js

@@ -130,7 +130,7 @@ export default [
     {
         "title": "Shor (Resource Estimation)",
         "shots": 1,
-        "code": "/// # Sample\n/// Estimating Frequency for Shor's algorithm\n///\n/// # Description\n/// In this sample we concentrate on costing the `EstimateFrequency`\n/// operation, which is the core quantum operation in Shor's algorithm, and\n/// we omit the classical pre- and post-processing. This makes it ideal for\n/// use with the Azure Quantum Resource Estimator.\nimport Std.Arrays.*;\nimport Std.Canon.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\nimport Std.Arithmetic.*;\nimport Std.ResourceEstimation.*;\n\noperation Main() : Unit {\n    let bitsize = 31;\n\n    // When chooseing parameters for `EstimateFrequency`, make sure that\n    // generator and modules are not co-prime\n    let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);\n}\n\n/// # Summary\n/// Estimates the frequency of a generator\n/// in the residue ring Z mod `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period)\n/// of which is being estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus`\n/// in which the multiplicative order of `generator` is being estimated.\n/// ## bitsize\n/// Number of bits needed to represent the modulus.\n///\n/// # Output\n/// The numerator k of dyadic fraction k/2^bitsPrecision\n/// approximating s/r.\noperation EstimateFrequency(\n    generator : Int,\n    modulus : Int,\n    bitsize : Int\n) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Allocate qubits for the superposition of eigenstates of\n    // the oracle that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of\n    // the eigenstates we are estimating the phases of.\n    // We first interpret the register as encoding an unsigned integer\n    // in little endian encoding.\n    ApplyXorInPlace(1, eigenstateRegister);\n    let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);\n\n    // Use phase estimation with a semiclassical Fourier transform to\n    // estimate the frequency.\n    use c = Qubit();\n    for idx in bitsPrecision - 1..-1..0 {\n        within {\n            H(c);\n        } apply {\n            // `BeginEstimateCaching` and `EndEstimateCaching` are the operations\n            // exposed by Azure Quantum Resource Estimator. These will instruct\n            // resource counting such that the if-block will be executed\n            // only once, its resources will be cached, and appended in\n            // every other iteration.\n            if BeginEstimateCaching(\"ControlledOracle\", SingleVariant()) {\n                Controlled oracle([c], (1 <<< idx, eigenstateRegister));\n                EndEstimateCaching();\n            }\n            R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        }\n        if MResetZ(c) == One {\n            frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using Std.Intrinsic.ResetAll.\n    ResetAll(eigenstateRegister);\n\n    return frequencyEstimate;\n}\n\n/// # Summary\n/// Interprets `target` as encoding unsigned little-endian integer k\n/// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where\n/// p is `power`, g is `generator` and N is `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period)\n/// of which is being estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus`\n/// in which the multiplicative order of `generator` is being estimated.\n/// ## power\n/// Power of `generator` by which `target` is multiplied.\n/// ## target\n/// Register interpreted as little-endian which is multiplied by\n/// given power of the generator. The multiplication is performed modulo\n/// `modulus`.\ninternal operation ApplyOrderFindingOracle(\n    generator : Int,\n    modulus : Int,\n    power : Int,\n    target : Qubit[]\n) : Unit is Adj + Ctl {\n    // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We\n    // also use `ExpModI` to compute a by which x must be multiplied. Also\n    // note that we interpret target as unsigned integer in little-endian\n    // format.\n    ModularMultiplyByConstant(\n        modulus,\n        ExpModI(generator, power, modulus),\n        target\n    );\n}\n\n/// # Summary\n/// Performs modular in-place multiplication by a classical constant.\n///\n/// # Description\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(c*x) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular multiplication\n/// ## c\n/// Constant by which to multiply |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    use qs = Qubit[Length(y)];\n    for idx in IndexRange(y) {\n        let shiftedC = (c <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, shiftedC, qs)\n        );\n    }\n    for idx in IndexRange(y) {\n        SWAP(y[idx], qs[idx]);\n    }\n    let invC = InverseModI(c, modulus);\n    for idx in IndexRange(y) {\n        let shiftedC = (invC <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, modulus - shiftedC, qs)\n        );\n    }\n}\n\n/// # Summary\n/// Performs modular in-place addition of a classical constant into a\n/// quantum register.\n///\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(x+c) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular addition\n/// ## c\n/// Constant to add to |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    body (...) {\n        Controlled ModularAddConstant([], (modulus, c, y));\n    }\n    controlled (ctrls, ...) {\n        // We apply a custom strategy to control this operation instead of\n        // letting the compiler create the controlled variant for us in\n        // which the `Controlled` functor would be distributed over each\n        // operation in the body.\n        //\n        // Here we can use some scratch memory to save ensure that at most\n        // one control qubit is used for costly operations such as\n        // `AddConstant` and `CompareGreaterThenOrEqualConstant`.\n        if Length(ctrls) >= 2 {\n            use control = Qubit();\n            within {\n                Controlled X(ctrls, control);\n            } apply {\n                Controlled ModularAddConstant([control], (modulus, c, y));\n            }\n        } else {\n            use carry = Qubit();\n            Controlled IncByI(ctrls, (c, y + [carry]));\n            Controlled Adjoint IncByI(ctrls, (modulus, y + [carry]));\n            Controlled IncByI([carry], (modulus, y));\n            Controlled ApplyIfLessOrEqualL(ctrls, (X, IntAsBigInt(c), y, carry));\n        }\n    }\n}\n",
+        "code": "/// # Sample\n/// Estimating Frequency for Shor's algorithm\n///\n/// # Description\n/// In this sample we concentrate on costing the `EstimateFrequency`\n/// operation, which is the core quantum operation in Shor's algorithm, and\n/// we omit the classical pre- and post-processing. This makes it ideal for\n/// use with the Microsoft Quantum Resource Estimator.\nimport Std.Arrays.*;\nimport Std.Canon.*;\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Math.*;\nimport Std.Measurement.*;\nimport Std.Arithmetic.*;\nimport Std.ResourceEstimation.*;\n\noperation Main() : Unit {\n    let bitsize = 31;\n\n    // When chooseing parameters for `EstimateFrequency`, make sure that\n    // generator and modules are not co-prime\n    let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);\n}\n\n/// # Summary\n/// Estimates the frequency of a generator\n/// in the residue ring Z mod `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period)\n/// of which is being estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus`\n/// in which the multiplicative order of `generator` is being estimated.\n/// ## bitsize\n/// Number of bits needed to represent the modulus.\n///\n/// # Output\n/// The numerator k of dyadic fraction k/2^bitsPrecision\n/// approximating s/r.\noperation EstimateFrequency(\n    generator : Int,\n    modulus : Int,\n    bitsize : Int\n) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Allocate qubits for the superposition of eigenstates of\n    // the oracle that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of\n    // the eigenstates we are estimating the phases of.\n    // We first interpret the register as encoding an unsigned integer\n    // in little endian encoding.\n    ApplyXorInPlace(1, eigenstateRegister);\n    let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);\n\n    // Use phase estimation with a semiclassical Fourier transform to\n    // estimate the frequency.\n    use c = Qubit();\n    for idx in bitsPrecision - 1..-1..0 {\n        within {\n            H(c);\n        } apply {\n            // `BeginEstimateCaching` and `EndEstimateCaching` are the operations\n            // exposed by Microsoft Quantum Resource Estimator. These will instruct\n            // resource counting such that the if-block will be executed\n            // only once, its resources will be cached, and appended in\n            // every other iteration.\n            if BeginEstimateCaching(\"ControlledOracle\", SingleVariant()) {\n                Controlled oracle([c], (1 <<< idx, eigenstateRegister));\n                EndEstimateCaching();\n            }\n            R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        }\n        if MResetZ(c) == One {\n            frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using Std.Intrinsic.ResetAll.\n    ResetAll(eigenstateRegister);\n\n    return frequencyEstimate;\n}\n\n/// # Summary\n/// Interprets `target` as encoding unsigned little-endian integer k\n/// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where\n/// p is `power`, g is `generator` and N is `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period)\n/// of which is being estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus`\n/// in which the multiplicative order of `generator` is being estimated.\n/// ## power\n/// Power of `generator` by which `target` is multiplied.\n/// ## target\n/// Register interpreted as little-endian which is multiplied by\n/// given power of the generator. The multiplication is performed modulo\n/// `modulus`.\ninternal operation ApplyOrderFindingOracle(\n    generator : Int,\n    modulus : Int,\n    power : Int,\n    target : Qubit[]\n) : Unit is Adj + Ctl {\n    // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We\n    // also use `ExpModI` to compute a by which x must be multiplied. Also\n    // note that we interpret target as unsigned integer in little-endian\n    // format.\n    ModularMultiplyByConstant(\n        modulus,\n        ExpModI(generator, power, modulus),\n        target\n    );\n}\n\n/// # Summary\n/// Performs modular in-place multiplication by a classical constant.\n///\n/// # Description\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(c*x) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular multiplication\n/// ## c\n/// Constant by which to multiply |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    use qs = Qubit[Length(y)];\n    for idx in IndexRange(y) {\n        let shiftedC = (c <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, shiftedC, qs)\n        );\n    }\n    for idx in IndexRange(y) {\n        SWAP(y[idx], qs[idx]);\n    }\n    let invC = InverseModI(c, modulus);\n    for idx in IndexRange(y) {\n        let shiftedC = (invC <<< idx) % modulus;\n        Controlled ModularAddConstant(\n            [y[idx]],\n            (modulus, modulus - shiftedC, qs)\n        );\n    }\n}\n\n/// # Summary\n/// Performs modular in-place addition of a classical constant into a\n/// quantum register.\n///\n/// Given the classical constants `c` and `modulus`, and an input quantum\n/// register |𝑦⟩ in little-endian format, this operation computes\n/// `(x+c) % modulus` into |𝑦⟩.\n///\n/// # Input\n/// ## modulus\n/// Modulus to use for modular addition\n/// ## c\n/// Constant to add to |𝑦⟩\n/// ## y\n/// Quantum register of target\ninternal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[]) : Unit is Adj + Ctl {\n    body (...) {\n        Controlled ModularAddConstant([], (modulus, c, y));\n    }\n    controlled (ctrls, ...) {\n        // We apply a custom strategy to control this operation instead of\n        // letting the compiler create the controlled variant for us in\n        // which the `Controlled` functor would be distributed over each\n        // operation in the body.\n        //\n        // Here we can use some scratch memory to save ensure that at most\n        // one control qubit is used for costly operations such as\n        // `AddConstant` and `CompareGreaterThenOrEqualConstant`.\n        if Length(ctrls) >= 2 {\n            use control = Qubit();\n            within {\n                Controlled X(ctrls, control);\n            } apply {\n                Controlled ModularAddConstant([control], (modulus, c, y));\n            }\n        } else {\n            use carry = Qubit();\n            Controlled IncByI(ctrls, (c, y + [carry]));\n            Controlled Adjoint IncByI(ctrls, (modulus, y + [carry]));\n            Controlled IncByI([carry], (modulus, y));\n            Controlled ApplyIfLessOrEqualL(ctrls, (X, IntAsBigInt(c), y, carry));\n        }\n    }\n}\n",
         "omitFromTests": true
     }
 ];

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

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.IsRangeEmpty
 title: IsRangeEmpty exported item
 description: "Q# IsRangeEmpty exported item: This is an exported item. The actual definition is found here: [Std.Range.IsRangeEmpty](xref:Qdk.Std.Range.IsRangeEmpty)"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Length
 title: Length exported item
 description: "Q# Length exported item: This is an exported item. The actual definition is found here: [Std.Core.Length](xref:Qdk.Std.Core.Length)"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.RangeEnd
 title: RangeEnd exported item
 description: "Q# RangeEnd exported item: This is an exported item. The actual definition is found here: [Std.Range.RangeEnd](xref:Qdk.Std.Range.RangeEnd)"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.RangeStart
 title: RangeStart exported item
 description: "Q# RangeStart exported item: This is an exported item. The actual definition is found here: [Std.Range.RangeStart](xref:Qdk.Std.Range.RangeStart)"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Repeated
 title: Repeated exported item
 description: "Q# Repeated exported item: This is an exported item. The actual definition is found here: [Std.Core.Repeated](xref:Qdk.Std.Core.Repeated)"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

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

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core-toc
 title: Microsoft.Quantum.Core namespace
 description: Table of contents for the Q# Microsoft.Quantum.Core namespace
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 ms.topic: landing-page
 ---
 

package/docs/Std.Arithmetic/AddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.AddLE
 title: AddLE operation
 description: "Q# AddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfEqualL
 title: ApplyIfEqualL operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfEqualLE
 title: ApplyIfEqualLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterL
 title: ApplyIfGreaterL operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterLE
 title: ApplyIfGreaterLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterOrEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualL
 title: ApplyIfGreaterOrEqualL operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterOrEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualLE
 title: ApplyIfGreaterOrEqualLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessL
 title: ApplyIfLessL operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessLE
 title: ApplyIfLessLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessOrEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualL
 title: ApplyIfLessOrEqualL operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessOrEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualLE
 title: ApplyIfLessOrEqualLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/FourierTDIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.FourierTDIncByLE
 title: FourierTDIncByLE operation
 description: "Q# FourierTDIncByLE operation: Increments a little-endian register ys by a little-endian register xs using Quantum Fourier Transform."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByI.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByI
 title: IncByI operation
 description: "Q# IncByI operation: Increments a little-endian register ys by an integer number c"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByIUsingIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByIUsingIncByLE
 title: IncByIUsingIncByLE operation
 description: "Q# IncByIUsingIncByLE operation: Increments a little-endian register ys by an Int number c using provided adder."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByL
 title: IncByL operation
 description: "Q# IncByL operation: Increments a little-endian register ys by a BigInt number c"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByLE
 title: IncByLE operation
 description: "Q# IncByLE operation: Increments a little-endian register ys by a little-endian register xs"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByLEUsingAddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByLEUsingAddLE
 title: IncByLEUsingAddLE operation
 description: "Q# IncByLEUsingAddLE operation: Generic operation to turn two out-place adders into one in-place adder"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByLUsingIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByLUsingIncByLE
 title: IncByLUsingIncByLE operation
 description: "Q# IncByLUsingIncByLE operation: Increments a little-endian register ys by a BigInt number c using provided adder."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/LookAheadDKRSAddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.LookAheadDKRSAddLE
 title: LookAheadDKRSAddLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/MAJ.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.MAJ
 title: MAJ operation
 description: "Q# MAJ operation: This applies the in-place majority operation to 3 qubits."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ReflectAboutInteger.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ReflectAboutInteger
 title: ReflectAboutInteger operation
 description: "Q# ReflectAboutInteger operation: Reflects a quantum register about a given classical integer."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/RippleCarryCGAddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.RippleCarryCGAddLE
 title: RippleCarryCGAddLE operation
 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: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/RippleCarryCGIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.RippleCarryCGIncByLE
 title: RippleCarryCGIncByLE operation
 description: "Q# RippleCarryCGIncByLE operation: Increments a little-endian register ys by a little-endian register xs using the ripple-carry algorithm."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/RippleCarryTTKIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.RippleCarryTTKIncByLE
 title: RippleCarryTTKIncByLE operation
 description: "Q# RippleCarryTTKIncByLE operation: Reversible, in-place ripple-carry addition of two integers."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/index.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic-toc
 title: Std.Arithmetic namespace
 description: Table of contents for the Q# Arithmetic namespace
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 ms.topic: landing-page
 ---
 

package/docs/Std.Arrays/All.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.All
 title: All function
 description: "Q# All function: Given an array and a predicate that is defined for the elements of the array, and checks if all elements of the array satisfy the predicate."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Any.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Any
 title: Any function
 description: "Q# Any function: Given an array and a predicate that is defined for the elements of the array, checks if at least one element of the array satisfies the predicate."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Chunks.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Chunks
 title: Chunks function
 description: "Q# Chunks function: Splits an array into multiple parts of equal length."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/CircularlyShifted.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.CircularlyShifted
 title: CircularlyShifted function
 description: "Q# CircularlyShifted function: Shift an array circularly left or right by a specific step size."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/ColumnAt.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.ColumnAt
 title: ColumnAt function
 description: "Q# ColumnAt function: Extracts a column from a matrix."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Count.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Count
 title: Count function
 description: "Q# Count function: Given an array and a predicate that is defined for the elements of the array, returns the number of elements an array that consists of those elements that satisfy the predicate."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Diagonal.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Diagonal
 title: Diagonal function
 description: "Q# Diagonal function: Returns an array of diagonal elements of a 2-dimensional array"
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/DrawMany.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.DrawMany
 title: DrawMany operation
 description: "Q# DrawMany operation: Repeats an operation for a given number of samples, collecting its outputs in an array."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Enumerated.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Enumerated
 title: Enumerated function
 description: "Q# Enumerated function: Given an array, returns a new array containing elements of the original array along with the indices of each element."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Excluding.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Excluding
 title: Excluding function
 description: "Q# Excluding function: Returns an array containing the elements of another array, excluding elements at a given list of indices."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Filtered.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Filtered
 title: Filtered function
 description: "Q# Filtered function: Given an array and a predicate that is defined for the elements of the array, returns an array that consists of those elements that satisfy the predicate."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/FlatMapped.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.FlatMapped
 title: FlatMapped function
 description: "Q# FlatMapped function: Given an array and a function that maps an array element to some output array, returns the concatenated output arrays for each array element."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Flattened.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Flattened
 title: Flattened function
 description: "Q# Flattened function: Given an array of arrays, returns the concatenation of all arrays."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Fold.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Fold
 title: Fold function
 description: "Q# Fold function: Iterates a function `f` through an array `array`, returning `f(...f(f(initialState, array[0]), array[1]), ...)`."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/ForEach.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.ForEach
 title: ForEach operation
 description: "Q# ForEach operation: Given an array and an operation that is defined for the elements of the array, returns a new array that consists of the images of the original array under the operation."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/Head.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Head
 title: Head function
 description: "Q# Head function: Returns the first element of the array."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/HeadAndRest.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.HeadAndRest
 title: HeadAndRest function
 description: "Q# HeadAndRest function: Returns a tuple of first and all remaining elements of the array."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/IndexOf.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.IndexOf
 title: IndexOf function
 description: "Q# IndexOf function: Returns the first index of the first element in an array that satisfies a given predicate. If no such element exists, returns -1."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays

package/docs/Std.Arrays/IndexRange.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.IndexRange
 title: IndexRange function
 description: "Q# IndexRange function: Given an array, returns a range over the indices of that array, suitable for use in a for loop."
-ms.date: 12/09/2025
+ms.date: 01/17/2026
 qsharp.kind: function
 qsharp.package: __Std__
 qsharp.namespace: Std.Arrays