qsharp-lang 1.12.3-dev → 1.12.5-dev

package/dist/browser.d.ts

@@ -15,11 +15,11 @@ export declare function getCompilerWorker(worker: string | Worker): ICompilerWor
 export declare function getLanguageService(host?: IProjectHost): Promise<ILanguageService>;
 export declare function getLanguageServiceWorker(worker: string | Worker): ILanguageServiceWorker;
 export { StepResultId } from "../lib/web/qsc_wasm.js";
-export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, IWorkspaceEdit, ProjectLoader, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, IWorkspaceEdit, ProjectLoader, ITestDescriptor, 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";
-export type { LanguageServiceEvent } from "./language-service/language-service.js";
+export type { LanguageServiceDiagnosticEvent, LanguageServiceEvent, LanguageServiceTestCallablesEvent, } from "./language-service/language-service.js";
 export { default as samples } from "./samples.generated.js";
 export { log, type LogLevel, type TargetProfile };
 export type { ICompiler, ICompilerWorker, IDebugService, IDebugServiceWorker, ILanguageService, ILanguageServiceWorker, };

package/dist/compiler/compiler.js

@@ -16,6 +16,8 @@ export class Compiler {
         const languageService = new this.wasm.LanguageService();
         const work = languageService.start_background_work((uri, version, errors) => {
             diags = errors;
+        }, () => {
+            // do nothing; test callables are not reported in checkCode
         }, {
             readFile: async () => null,
             listDirectory: async () => [],

package/dist/language-service/language-service.d.ts

@@ -1,8 +1,8 @@
-import type { ICodeAction, ICodeLens, ICompletionList, IHover, ILocation, INotebookMetadata, IPosition, IRange, ISignatureHelp, ITextEdit, IWorkspaceConfiguration, IWorkspaceEdit, VSDiagnostic } from "../../lib/web/qsc_wasm.js";
+import type { ICodeAction, ICodeLens, ICompletionList, IHover, ILocation, INotebookMetadata, IPosition, IRange, ISignatureHelp, ITextEdit, IWorkspaceConfiguration, IWorkspaceEdit, VSDiagnostic, ITestDescriptor } from "../../lib/web/qsc_wasm.js";
 import { IProjectHost } from "../browser.js";
 import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
-export type LanguageServiceEvent = {
+export type LanguageServiceDiagnosticEvent = {
     type: "diagnostics";
     detail: {
         uri: string;
@@ -10,6 +10,13 @@ export type LanguageServiceEvent = {
         diagnostics: VSDiagnostic[];
     };
 };
+export type LanguageServiceTestCallablesEvent = {
+    type: "testCallables";
+    detail: {
+        callables: ITestDescriptor[];
+    };
+};
+export type LanguageServiceEvent = LanguageServiceDiagnosticEvent | LanguageServiceTestCallablesEvent;
 export interface ILanguageService {
     updateConfiguration(config: IWorkspaceConfiguration): Promise<void>;
     updateDocument(uri: string, version: number, code: string): Promise<void>;
@@ -74,11 +81,12 @@ export declare class QSharpLanguageService implements ILanguageService {
         type: T;
     }>) => void): void;
     onDiagnostics(uri: string, version: number | undefined, diagnostics: VSDiagnostic[]): Promise<void>;
+    onTestCallables(callables: ITestDescriptor[]): Promise<void>;
 }
 /**
  * The protocol definition to allow running the language service in a worker.
  *
  * Not to be confused with "the" LSP (Language Server Protocol).
  */
-export declare const languageServiceProtocol: ServiceProtocol<ILanguageService, LanguageServiceEvent>;
+export declare const languageServiceProtocol: ServiceProtocol<ILanguageService, LanguageServiceDiagnosticEvent>;
 export {};

package/dist/language-service/language-service.js

@@ -15,7 +15,7 @@ export class QSharpLanguageService {
         this.eventHandler = new EventTarget();
         log.info("Constructing a QSharpLanguageService instance");
         this.languageService = new wasm.LanguageService();
-        this.backgroundWork = this.languageService.start_background_work(this.onDiagnostics.bind(this), host);
+        this.backgroundWork = this.languageService.start_background_work(this.onDiagnostics.bind(this), this.onTestCallables.bind(this), host);
     }
     async updateConfiguration(config) {
         this.languageService.update_configuration(config);
@@ -94,6 +94,18 @@ export class QSharpLanguageService {
             log.error("Error in onDiagnostics", e);
         }
     }
+    async onTestCallables(callables) {
+        try {
+            const event = new Event("testCallables");
+            event.detail = {
+                callables,
+            };
+            this.eventHandler.dispatchEvent(event);
+        }
+        catch (e) {
+            log.error("Error in onTestCallables", e);
+        }
+    }
 }
 /**
  * The protocol definition to allow running the language service in a worker.

package/dist/samples.generated.js

@@ -77,7 +77,7 @@ export default [
     {
         "title": "Shor",
         "shots": 1,
-        "code": "/// # Sample\n/// Shor's Algorithm\n///\n/// # Description\n/// Shor's algorithm is a quantum algorithm for finding the prime factors of an\n/// integer.\n///\n/// This Q# program implements Shor's algorithm.\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Random.*;\nimport Std.Math.*;\nimport Std.Arithmetic.*;\nimport Std.Arrays.*;\n\noperation Main() : (Int, Int) {\n    let n = 143; // 11*13;\n    // You can try these other examples for a lengthier computation.\n    // let n = 16837; // = 113*149\n    // let n = 22499; // = 149*151\n\n    // Use Shor's algorithm to factor a semiprime integer.\n    let (a, b) = FactorSemiprimeInteger(n);\n    Message($\"Found factorization {n} = {a} * {b}\");\n    return (a, b);\n}\n\n/// # Summary\n/// Uses Shor's algorithm to factor an input number.\n///\n/// # Input\n/// ## number\n/// A semiprime integer to be factored.\n///\n/// # Output\n/// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\noperation FactorSemiprimeInteger(number : Int) : (Int, Int) {\n    // First check the most trivial case (the provided number is even).\n    if number % 2 == 0 {\n        Message(\"An even number has been given; 2 is a factor.\");\n        return (number / 2, 2);\n    }\n    // These mutables will keep track of whether we found the factors, and\n    // if so, what they are. The default value for the factors is (1,1).\n    mutable foundFactors = false;\n    mutable factors = (1, 1);\n    mutable attempt = 1;\n    repeat {\n        Message($\"*** Factorizing {number}, attempt {attempt}.\");\n        // Try to guess a number co-prime to `number` by getting a random\n        // integer in the interval [1, number-1]\n        let generator = DrawRandomInt(1, number - 1);\n\n        // Check if the random integer is indeed co-prime.\n        // If true use Quantum algorithm for Period finding.\n        if GreatestCommonDivisorI(generator, number) == 1 {\n            Message($\"Estimating period of {generator}.\");\n\n            // Call Quantum Period finding algorithm for\n            // `generator` mod `number`.\n            let period = EstimatePeriod(generator, number);\n\n            // Set the flag and factors values if the continued\n            // fractions classical algorithm succeeds.\n            set (foundFactors, factors) = MaybeFactorsFromPeriod(number, generator, period);\n        }\n        // In this case, we guessed a divisor by accident.\n        else {\n            // Find divisor.\n            let gcd = GreatestCommonDivisorI(number, generator);\n            Message($\"We have guessed a divisor {gcd} by accident. \" + \"No quantum computation was done.\");\n\n            // Set the flag `foundFactors` to true, indicating that we\n            // succeeded in finding factors.\n            set foundFactors = true;\n            set factors = (gcd, number / gcd);\n        }\n        set attempt = attempt + 1;\n        if (attempt > 100) {\n            fail \"Failed to find factors: too many attempts!\";\n        }\n    } until foundFactors\n    fixup {\n        Message(\"The estimated period did not yield a valid factor. \" + \"Trying again.\");\n    }\n\n    // Return the factorization\n    return factors;\n}\n\n/// # Summary\n/// Tries to find the factors of `modulus` given a `period` and `generator`.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## period\n/// The estimated period (multiplicative order) of the generator mod\n/// `modulus`.\n///\n/// # Output\n/// A tuple of a flag indicating whether factors were found successfully,\n/// and a pair of integers representing the factors that were found.\n/// Note that the second output is only meaningful when the first output is\n/// `true`.\nfunction MaybeFactorsFromPeriod(\n    modulus : Int,\n    generator : Int,\n    period : Int\n) : (Bool, (Int, Int)) {\n\n    // Period finding reduces to factoring only if period is even\n    if period % 2 == 0 {\n        // Compute `generator` ^ `period/2` mod `number`.\n        let halfPower = ExpModI(generator, period / 2, modulus);\n\n        // If we are unlucky, halfPower is just -1 mod N, which is a trivial\n        // case and not useful for factoring.\n        if halfPower != modulus - 1 {\n            // When the halfPower is not -1 mod N, halfPower-1 or\n            // halfPower+1 share non-trivial divisor with `number`. Find it.\n            let factor = MaxI(\n                GreatestCommonDivisorI(halfPower - 1, modulus),\n                GreatestCommonDivisorI(halfPower + 1, modulus)\n            );\n\n            // Add a flag that we found the factors, and return only if computed\n            // non-trivial factors (not like 1:n or n:1)\n            if (factor != 1) and (factor != modulus) {\n                Message($\"Found factor={factor}\");\n                return (true, (factor, modulus / factor));\n            }\n        }\n        // Return a flag indicating we hit a trivial case and didn't get\n        // any factors.\n        Message($\"Found trivial factors.\");\n        return (false, (1, 1));\n    } else {\n        // When period is odd we have to pick another generator to estimate\n        // period of and start over.\n        Message($\"Estimated period {period} was odd, trying again.\");\n        return (false, (1, 1));\n    }\n}\n\n/// # Summary\n/// Find the period of a number from an input frequency.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## frequencyEstimate\n/// The frequency that we want to convert to a period.\n/// ## bitsPrecision\n/// Number of bits of precision with which we need to estimate s/r to\n/// recover period r using continued fractions algorithm.\n/// ## currentDivisor\n/// The divisor of the generator period found so far.\n///\n/// # Output\n/// The period as calculated from the estimated frequency via the continued\n/// fractions algorithm.\nfunction PeriodFromFrequency(\n    modulus : Int,\n    frequencyEstimate : Int,\n    bitsPrecision : Int,\n    currentDivisor : Int\n) : Int {\n    // Now we use the ContinuedFractionConvergentI function to recover s/r\n    // from dyadic fraction k/2^bitsPrecision.\n    let (numerator, period) = ContinuedFractionConvergentI(\n        (frequencyEstimate, 2^bitsPrecision),\n        modulus\n    );\n\n    // ContinuedFractionConvergentI does not guarantee the signs of the\n    // numerator and denominator. Here we make sure that both are positive\n    // using AbsI.\n    let (numeratorAbs, periodAbs) = (AbsI(numerator), AbsI(period));\n\n    // Compute and return the newly found divisor.\n    let period = (periodAbs * currentDivisor) / GreatestCommonDivisorI(currentDivisor, periodAbs);\n    Message($\"Found period={period}\");\n    return period;\n}\n\n/// # Summary\n/// Finds a multiplicative order of the generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n///\n/// # Output\n/// The period (multiplicative order) of the generator mod `modulus`\noperation EstimatePeriod(generator : Int, modulus : Int) : Int {\n    // Here we check that the inputs to the EstimatePeriod operation are\n    // valid.\n    Fact(\n        GreatestCommonDivisorI(generator, modulus) == 1,\n        \"`generator` and `modulus` must be co-prime\"\n    );\n\n    // Number of bits in the modulus with respect to which we are estimating\n    // the period.\n    let bitsize = BitSizeI(modulus);\n\n    // The EstimatePeriod operation estimates the period r by finding an\n    // approximation k/2^(bits precision) to a fraction s/r, where s is some\n    // integer. Note that if s and r have common divisors we will end up\n    // recovering a divisor of r and not r itself.\n\n    // Number of bits of precision with which we need to estimate s/r to\n    // recover period r, using continued fractions algorithm.\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Current estimate for the frequency of the form s/r.\n    let frequencyEstimate = EstimateFrequency(generator, modulus, bitsize);\n    if frequencyEstimate != 0 {\n        return PeriodFromFrequency(\n            modulus,\n            frequencyEstimate,\n            bitsPrecision,\n            1\n        );\n    } else {\n        Message(\"The estimated frequency was 0, trying again.\");\n        return 1;\n    }\n}\n\n/// # Summary\n/// Estimates the frequency of a generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// 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 approximating s/r.\noperation EstimateFrequency(generator : Int, modulus : Int, bitsize : Int) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n    Message($\"Estimating frequency with bitsPrecision={bitsPrecision}.\");\n\n    // Allocate qubits for the superposition of eigenstates of the oracle\n    // that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of the\n    // eigenstates we are estimating the phases of.\n    // We are interpreting the register as encoding an unsigned integer in\n    // little-endian format.\n    ApplyXorInPlace(1, eigenstateRegister);\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        H(c);\n        Controlled ApplyOrderFindingOracle(\n            [c],\n            (generator, modulus, 1 <<< idx, eigenstateRegister)\n        );\n        R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        H(c);\n        if M(c) == One {\n            X(c); // Reset\n            set frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using ResetAll.\n    ResetAll(eigenstateRegister);\n    Message($\"Estimated frequency={frequencyEstimate}\");\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/// Shor's Algorithm\n///\n/// # Description\n/// Shor's algorithm is a quantum algorithm for finding the prime factors of an\n/// integer.\n///\n/// This Q# program implements Shor's algorithm.\nimport Std.Convert.*;\nimport Std.Diagnostics.*;\nimport Std.Random.*;\nimport Std.Math.*;\nimport Std.Arithmetic.*;\nimport Std.Arrays.*;\n\noperation Main() : (Int, Int) {\n    let n = 187; // 11*17;\n    // You can try these other examples for a lengthier computation.\n    // let n = 16837; // = 113*149\n    // let n = 22499; // = 149*151\n\n    // Use Shor's algorithm to factor a semiprime integer.\n    let (a, b) = FactorSemiprimeInteger(n);\n    Message($\"Found factorization {n} = {a} * {b}\");\n    return (a, b);\n}\n\n/// # Summary\n/// Uses Shor's algorithm to factor an input number.\n///\n/// # Input\n/// ## number\n/// A semiprime integer to be factored.\n///\n/// # Output\n/// Pair of numbers p > 1 and q > 1 such that p⋅q = `number`\noperation FactorSemiprimeInteger(number : Int) : (Int, Int) {\n    // First check the most trivial case (the provided number is even).\n    if number % 2 == 0 {\n        Message(\"An even number has been given; 2 is a factor.\");\n        return (number / 2, 2);\n    }\n    // These mutables will keep track of whether we found the factors, and\n    // if so, what they are. The default value for the factors is (1,1).\n    mutable foundFactors = false;\n    mutable factors = (1, 1);\n    mutable attempt = 1;\n    repeat {\n        Message($\"*** Factorizing {number}, attempt {attempt}.\");\n        // Try to guess a number co-prime to `number` by getting a random\n        // integer in the interval [1, number-1]\n        let generator = DrawRandomInt(1, number - 1);\n\n        // Check if the random integer is indeed co-prime.\n        // If true use Quantum algorithm for Period finding.\n        if GreatestCommonDivisorI(generator, number) == 1 {\n            Message($\"Estimating period of {generator}.\");\n\n            // Call Quantum Period finding algorithm for\n            // `generator` mod `number`.\n            let period = EstimatePeriod(generator, number);\n\n            // Set the flag and factors values if the continued\n            // fractions classical algorithm succeeds.\n            set (foundFactors, factors) = MaybeFactorsFromPeriod(number, generator, period);\n        }\n        // In this case, we guessed a divisor by accident.\n        else {\n            // Find divisor.\n            let gcd = GreatestCommonDivisorI(number, generator);\n            Message($\"We have guessed a divisor {gcd} by accident. \" + \"No quantum computation was done.\");\n\n            // Set the flag `foundFactors` to true, indicating that we\n            // succeeded in finding factors.\n            set foundFactors = true;\n            set factors = (gcd, number / gcd);\n        }\n        set attempt = attempt + 1;\n        if (attempt > 100) {\n            fail \"Failed to find factors: too many attempts!\";\n        }\n    } until foundFactors\n    fixup {\n        Message(\"The estimated period did not yield a valid factor. \" + \"Trying again.\");\n    }\n\n    // Return the factorization\n    return factors;\n}\n\n/// # Summary\n/// Tries to find the factors of `modulus` given a `period` and `generator`.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## period\n/// The estimated period (multiplicative order) of the generator mod\n/// `modulus`.\n///\n/// # Output\n/// A tuple of a flag indicating whether factors were found successfully,\n/// and a pair of integers representing the factors that were found.\n/// Note that the second output is only meaningful when the first output is\n/// `true`.\nfunction MaybeFactorsFromPeriod(\n    modulus : Int,\n    generator : Int,\n    period : Int\n) : (Bool, (Int, Int)) {\n\n    // Period finding reduces to factoring only if period is even\n    if period % 2 == 0 {\n        // Compute `generator` ^ `period/2` mod `number`.\n        let halfPower = ExpModI(generator, period / 2, modulus);\n\n        // If we are unlucky, halfPower is just -1 mod N, which is a trivial\n        // case and not useful for factoring.\n        if halfPower != modulus - 1 {\n            // When the halfPower is not -1 mod N, halfPower-1 or\n            // halfPower+1 share non-trivial divisor with `number`. Find it.\n            let factor = MaxI(\n                GreatestCommonDivisorI(halfPower - 1, modulus),\n                GreatestCommonDivisorI(halfPower + 1, modulus)\n            );\n\n            // Add a flag that we found the factors, and return only if computed\n            // non-trivial factors (not like 1:n or n:1)\n            if (factor != 1) and (factor != modulus) {\n                Message($\"Found factor={factor}\");\n                return (true, (factor, modulus / factor));\n            }\n        }\n        // Return a flag indicating we hit a trivial case and didn't get\n        // any factors.\n        Message($\"Found trivial factors.\");\n        return (false, (1, 1));\n    } else {\n        // When period is odd we have to pick another generator to estimate\n        // period of and start over.\n        Message($\"Estimated period {period} was odd, trying again.\");\n        return (false, (1, 1));\n    }\n}\n\n/// # Summary\n/// Find the period of a number from an input frequency.\n///\n/// # Input\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n/// ## frequencyEstimate\n/// The frequency that we want to convert to a period.\n/// ## bitsPrecision\n/// Number of bits of precision with which we need to estimate s/r to\n/// recover period r using continued fractions algorithm.\n/// ## currentDivisor\n/// The divisor of the generator period found so far.\n///\n/// # Output\n/// The period as calculated from the estimated frequency via the continued\n/// fractions algorithm.\nfunction PeriodFromFrequency(\n    modulus : Int,\n    frequencyEstimate : Int,\n    bitsPrecision : Int,\n    currentDivisor : Int\n) : Int {\n    // Now we use the ContinuedFractionConvergentI function to recover s/r\n    // from dyadic fraction k/2^bitsPrecision.\n    let (numerator, period) = ContinuedFractionConvergentI(\n        (frequencyEstimate, 2^bitsPrecision),\n        modulus\n    );\n\n    // ContinuedFractionConvergentI does not guarantee the signs of the\n    // numerator and denominator. Here we make sure that both are positive\n    // using AbsI.\n    let (numeratorAbs, periodAbs) = (AbsI(numerator), AbsI(period));\n\n    // Compute and return the newly found divisor.\n    let period = (periodAbs * currentDivisor) / GreatestCommonDivisorI(currentDivisor, periodAbs);\n    Message($\"Found period={period}\");\n    return period;\n}\n\n/// # Summary\n/// Finds a multiplicative order of the generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// multiplicative order of `generator` is being estimated.\n///\n/// # Output\n/// The period (multiplicative order) of the generator mod `modulus`\noperation EstimatePeriod(generator : Int, modulus : Int) : Int {\n    // Here we check that the inputs to the EstimatePeriod operation are\n    // valid.\n    Fact(\n        GreatestCommonDivisorI(generator, modulus) == 1,\n        \"`generator` and `modulus` must be co-prime\"\n    );\n\n    // Number of bits in the modulus with respect to which we are estimating\n    // the period.\n    let bitsize = BitSizeI(modulus);\n\n    // The EstimatePeriod operation estimates the period r by finding an\n    // approximation k/2^(bits precision) to a fraction s/r, where s is some\n    // integer. Note that if s and r have common divisors we will end up\n    // recovering a divisor of r and not r itself.\n\n    // Number of bits of precision with which we need to estimate s/r to\n    // recover period r, using continued fractions algorithm.\n    let bitsPrecision = 2 * bitsize + 1;\n\n    // Current estimate for the frequency of the form s/r.\n    let frequencyEstimate = EstimateFrequency(generator, modulus, bitsize);\n    if frequencyEstimate != 0 {\n        return PeriodFromFrequency(\n            modulus,\n            frequencyEstimate,\n            bitsPrecision,\n            1\n        );\n    } else {\n        Message(\"The estimated frequency was 0, trying again.\");\n        return 1;\n    }\n}\n\n/// # Summary\n/// Estimates the frequency of a generator in the residue ring Z mod\n/// `modulus`.\n///\n/// # Input\n/// ## generator\n/// The unsigned integer multiplicative order (period) of which is being\n/// estimated. Must be co-prime to `modulus`.\n/// ## modulus\n/// The modulus which defines the residue ring Z mod `modulus` in which the\n/// 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 approximating s/r.\noperation EstimateFrequency(generator : Int, modulus : Int, bitsize : Int) : Int {\n    mutable frequencyEstimate = 0;\n    let bitsPrecision = 2 * bitsize + 1;\n    Message($\"Estimating frequency with bitsPrecision={bitsPrecision}.\");\n\n    // Allocate qubits for the superposition of eigenstates of the oracle\n    // that is used in period finding.\n    use eigenstateRegister = Qubit[bitsize];\n\n    // Initialize eigenstateRegister to 1, which is a superposition of the\n    // eigenstates we are estimating the phases of.\n    // We are interpreting the register as encoding an unsigned integer in\n    // little-endian format.\n    ApplyXorInPlace(1, eigenstateRegister);\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        H(c);\n        Controlled ApplyOrderFindingOracle(\n            [c],\n            (generator, modulus, 1 <<< idx, eigenstateRegister)\n        );\n        R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);\n        H(c);\n        if M(c) == One {\n            X(c); // Reset\n            set frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);\n        }\n    }\n\n    // Return all the qubits used for oracle's eigenstate back to 0 state\n    // using ResetAll.\n    ResetAll(eigenstateRegister);\n    Message($\"Estimated frequency={frequencyEstimate}\");\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"
     },
     {
         "title": "Three Qubit Repetition Code",

package/dist/workers/browser.js

@@ -22,7 +22,7 @@ export function createWorker(serviceProtocol) {
         switch (data.type) {
             case "init":
                 {
-                    wasm.initSync(data.wasmModule);
+                    wasm.initSync({ module: data.wasmModule });
                     invokeService = initService(self.postMessage.bind(self), serviceProtocol, wasm, data.qscLogLevel);
                 }
                 break;

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__

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

@@ -4,7 +4,7 @@ title: Microsoft.Quantum.Core namespace
 description: Table of contents for the Q# Microsoft.Quantum.Core namespace
 author: {AUTHOR}
 ms.author: {MS_AUTHOR}
-ms.date: 01/20/2025
+ms.date: 01/28/2025
 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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arithmetic/index.md

@@ -4,7 +4,7 @@ title: Std.Arithmetic namespace
 description: Table of contents for the Q# Arithmetic namespace
 author: {AUTHOR}
 ms.author: {MS_AUTHOR}
-ms.date: 01/20/2025
+ms.date: 01/28/2025
 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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

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: 01/20/2025
+ms.date: 01/28/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__