qsharp-lang 1.6.2-dev → 1.6.3-dev

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

@@ -39,6 +39,7 @@ export interface ILanguageService {
     }>) => void): void;
 }
 export declare const qsharpLibraryUriScheme = "qsharp-library-source";
+export declare const qsharpGithubUriScheme = "qsharp-github-source";
 export type ILanguageServiceWorker = ILanguageService & IServiceProxy;
 export declare class QSharpLanguageService implements ILanguageService {
     private wasm;

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

@@ -2,11 +2,13 @@
 // Licensed under the MIT License.
 import { log } from "../log.js";
 export const qsharpLibraryUriScheme = "qsharp-library-source";
+export const qsharpGithubUriScheme = "qsharp-github-source";
 export class QSharpLanguageService {
     constructor(wasm, host = {
         readFile: async () => null,
         listDirectory: async () => [],
         resolvePath: async () => null,
+        fetchGithub: async () => "",
         findManifestDirectory: async () => null,
     }) {
         this.wasm = wasm;

package/dist/samples.generated.js

@@ -17,12 +17,12 @@ export default [
     {
         "title": "Bell States",
         "shots": 100,
-        "code": "/// # Sample\n/// Bell States\n///\n/// # Description\n/// Bell states or EPR pairs are specific quantum states of two qubits\n/// that represent the simplest (and maximal) examples of quantum entanglement.\n///\n/// This Q# program implements the four different Bell states.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation BellStates() : (Result, Result)[] {\n        // This array contains a label and a preparation operation for each one\n        // of the four Bell states.\n        let bellStateTuples = [\n            (\"|Φ+〉\", PreparePhiPlus),\n            (\"|Φ-〉\", PreparePhiMinus),\n            (\"|Ψ+〉\", PreparePsiPlus),\n            (\"|Ψ-〉\", PreparePsiMinus)\n        ];\n\n        // Prepare all Bell states, show them using the `DumpMachine` operation\n        // and measure the Bell state qubits.\n        mutable measurements = [];\n        for (label, prepare) in bellStateTuples {\n            // Allocate the two qubits that will be used to create a Bell state.\n            use register = Qubit[2];\n            prepare(register);\n            Message($\"Bell state {label}:\");\n            DumpMachine();\n            set measurements += [(MResetZ(register[0]), MResetZ(register[1]))];\n        }\n        return measurements;\n    }\n\n    /// # Summary\n    /// Prepares |Φ+⟩ = (|00⟩+|11⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePhiPlus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 + |11〉)\n    }\n\n    /// # Summary\n    /// Prepares |Φ−⟩ = (|00⟩-|11⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePhiMinus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        Z(register[0]);                 // |-0〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 - |11〉)\n    }\n\n    /// # Summary\n    /// Prepares |Ψ+⟩ = (|01⟩+|10⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePsiPlus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        X(register[1]);                 // |+1〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 + |10〉)\n    }\n\n    /// # Summary\n    /// Prepares |Ψ−⟩ = (|01⟩-|10⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePsiMinus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        Z(register[0]);                 // |-0〉\n        X(register[1]);                 // |-1〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 - |10〉)\n    }\n}\n"
+        "code": "/// # Sample\n/// Bell States\n///\n/// # Description\n/// Bell states or EPR pairs are specific quantum states of two qubits\n/// that represent the simplest (and maximal) examples of quantum entanglement.\n///\n/// This Q# program implements the four different Bell states.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation BellStates() : (Result, Result)[] {\n        // This array contains a label and a preparation operation for each one\n        // of the four Bell states.\n        let bellStateTuples = [\n            (\"|Φ+〉\", PreparePhiPlus),\n            (\"|Φ-〉\", PreparePhiMinus),\n            (\"|Ψ+〉\", PreparePsiPlus),\n            (\"|Ψ-〉\", PreparePsiMinus)\n        ];\n\n        // Prepare all Bell states, show them using the `DumpMachine` operation\n        // and measure the Bell state qubits.\n        mutable measurements = [];\n        for (label, prepare) in bellStateTuples {\n            // Allocate the two qubits that will be used to create a Bell state.\n            use register = Qubit[2];\n            prepare(register);\n            Message($\"Bell state {label}:\");\n            DumpMachine();\n            set measurements += [(MResetZ(register[0]), MResetZ(register[1]))];\n        }\n        return measurements;\n    }\n\n    /// # Summary\n    /// Prepares |Φ+⟩ = (|00⟩+|11⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePhiPlus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 + |11〉)\n    }\n\n    /// # Summary\n    /// Prepares |Φ−⟩ = (|00⟩-|11⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePhiMinus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        Z(register[0]);                 // |-0〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|00〉 - |11〉)\n    }\n\n    /// # Summary\n    /// Prepares |Ψ+⟩ = (|01⟩+|10⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePsiPlus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        X(register[1]);                 // |+1〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 + |10〉)\n    }\n\n    /// # Summary\n    /// Prepares |Ψ−⟩ = (|01⟩-|10⟩)/√2 state assuming `register` is in |00⟩ state.\n    operation PreparePsiMinus(register : Qubit[]) : Unit {\n        H(register[0]);                 // |+0〉\n        Z(register[0]);                 // |-0〉\n        X(register[1]);                 // |-1〉\n        CNOT(register[0], register[1]); // 1/sqrt(2)(|01〉 - |10〉)\n    }\n}\n"
     },
     {
         "title": "Teleportation",
         "shots": 1,
-        "code": "/// # Sample\n/// Quantum Teleportation\n///\n/// # Description\n/// Quantum teleportation provides a way of moving a quantum state from one\n/// location to another without having to move physical particle(s) along with\n/// it. This is done with the help of previously shared quantum entanglement\n/// between the sending and the receiving locations, and classical\n/// communication.\n///\n/// This Q# program implements quantum teleportation.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        // Use the `Teleport` operation to send different quantum states.\n        let stateInitializerBasisTuples = [\n            (\"|0〉\", I, PauliZ),\n            (\"|1〉\", X, PauliZ),\n            (\"|+〉\", SetToPlus, PauliX),\n            (\"|-〉\", SetToMinus, PauliX)\n        ];\n\n        mutable results = [];\n        for (state, initializer, basis) in stateInitializerBasisTuples {\n            // Allocate the message and target qubits.\n            use (message, target) = (Qubit(), Qubit());\n\n            // Initialize the message and show its state using the `DumpMachine`\n            // function.\n            initializer(message);\n            Message($\"Teleporting state {state}\");\n            DumpRegister([message]);\n\n            // Teleport the message and show the quantum state after\n            // teleportation.\n            Teleport(message, target);\n            Message($\"Received state {state}\");\n            DumpRegister([target]);\n\n            // Measure target in the corresponding basis and reset the qubits to\n            // continue teleporting more messages.\n            let result = Measure([basis], [target]);\n            set results += [result];\n            ResetAll([message, target]);\n        }\n\n        return results;\n    }\n\n    /// # Summary\n    /// Sends the state of one qubit to a target qubit by using teleportation.\n    ///\n    /// Notice that after calling Teleport, the state of `message` is collapsed.\n    ///\n    /// # Input\n    /// ## message\n    /// A qubit whose state we wish to send.\n    /// ## target\n    /// A qubit initially in the |0〉 state that we want to send\n    /// the state of message to.\n    operation Teleport(message : Qubit, target : Qubit) : Unit {\n        // Allocate an auxiliary qubit.\n        use auxiliary = Qubit();\n\n        // Create some entanglement that we can use to send our message.\n        H(auxiliary);\n        CNOT(auxiliary, target);\n\n        // Encode the message into the entangled pair.\n        CNOT(message, auxiliary);\n        H(message);\n\n        // Measure the qubits to extract the classical data we need to decode\n        // the message by applying the corrections on the target qubit\n        // accordingly.\n        if M(auxiliary) == One {\n            X(target);\n        }\n\n        if M(message) == One {\n            Z(target);\n        }\n\n        // Reset auxiliary qubit before releasing.\n        Reset(auxiliary);\n    }\n\n    /// # Summary\n    /// Sets a qubit in state |0⟩ to |+⟩.\n    operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n        H(q);\n    }\n\n    /// # Summary\n    /// Sets a qubit in state |0⟩ to |−⟩.\n    operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        H(q);\n    }\n}\n"
+        "code": "/// # Sample\n/// Quantum Teleportation\n///\n/// # Description\n/// Quantum teleportation provides a way of moving a quantum state from one\n/// location to another without having to move physical particle(s) along with\n/// it. This is done with the help of previously shared quantum entanglement\n/// between the sending and the receiving locations, and classical\n/// communication.\n///\n/// This Q# program implements quantum teleportation.\nnamespace Sample {\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Measurement;\n\n    @EntryPoint()\n    operation Main() : Result[] {\n        // Use the `Teleport` operation to send different quantum states.\n        let stateInitializerBasisTuples = [\n            (\"|0〉\", I, PauliZ),\n            (\"|1〉\", X, PauliZ),\n            (\"|+〉\", SetToPlus, PauliX),\n            (\"|-〉\", SetToMinus, PauliX)\n        ];\n\n        mutable results = [];\n        for (state, initializer, basis) in stateInitializerBasisTuples {\n            // Allocate the message and target qubits.\n            use (message, target) = (Qubit(), Qubit());\n\n            // Initialize the message and show its state using the `DumpMachine`\n            // function.\n            initializer(message);\n            Message($\"Teleporting state {state}\");\n            DumpRegister([message]);\n\n            // Teleport the message and show the quantum state after\n            // teleportation.\n            Teleport(message, target);\n            Message($\"Received state {state}\");\n            DumpRegister([target]);\n\n            // Measure target in the corresponding basis and reset the qubits to\n            // continue teleporting more messages.\n            let result = Measure([basis], [target]);\n            set results += [result];\n            ResetAll([message, target]);\n        }\n\n        return results;\n    }\n\n    /// # Summary\n    /// Sends the state of one qubit to a target qubit by using teleportation.\n    ///\n    /// Notice that after calling Teleport, the state of `message` is collapsed.\n    ///\n    /// # Input\n    /// ## message\n    /// A qubit whose state we wish to send.\n    /// ## target\n    /// A qubit initially in the |0〉 state that we want to send\n    /// the state of message to.\n    operation Teleport(message : Qubit, target : Qubit) : Unit {\n        // Allocate an auxiliary qubit.\n        use auxiliary = Qubit();\n\n        // Create some entanglement that we can use to send our message.\n        H(auxiliary);\n        CNOT(auxiliary, target);\n\n        // Encode the message into the entangled pair.\n        CNOT(message, auxiliary);\n        H(message);\n\n        // Measure the qubits to extract the classical data we need to decode\n        // the message by applying the corrections on the target qubit\n        // accordingly.\n        if M(auxiliary) == One {\n            X(target);\n        }\n\n        if M(message) == One {\n            Z(target);\n        }\n\n        // Reset auxiliary qubit before releasing.\n        Reset(auxiliary);\n    }\n\n    /// # Summary\n    /// Sets a qubit in state |0⟩ to |+⟩.\n    operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n        H(q);\n    }\n\n    /// # Summary\n    /// Sets a qubit in state |0⟩ to |−⟩.\n    operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n        X(q);\n        H(q);\n    }\n}\n"
     },
     {
         "title": "Random Bit",
@@ -37,7 +37,7 @@ export default [
     {
         "title": "Random Number Generator (Advanced)",
         "shots": 1000,
-        "code": "/// # Sample\n/// Quantum Random Number Generator\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// in superposition and then using the measurement results as random bits.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Math;\n\n    @EntryPoint()\n    operation Main() : Int {\n        let max = 100;\n        Message($\"Sampling a random number between 0 and {max}: \");\n\n        // Generate random number in the 0..max range.\n        return GenerateRandomNumberInRange(max);\n    }\n\n    /// # Summary\n    /// Generates a random number between 0 and `max`.\n    operation GenerateRandomNumberInRange(max : Int) : Int {\n        // Determine the number of bits needed to represent `max` and store it\n        // in the `nBits` variable. Then generate `nBits` random bits which will\n        // represent the generated random number.\n        mutable bits = [];\n        let nBits = BitSizeI(max);\n        for idxBit in 1..nBits {\n            set bits += [GenerateRandomBit()];\n        }\n        let sample = ResultArrayAsInt(bits);\n\n        // Return random number if it is within the requested range.\n        // Generate it again if it is outside the range.\n        return sample > max ? GenerateRandomNumberInRange(max) | sample;\n    }\n\n    /// # Summary\n    /// Generates a random bit.\n    operation GenerateRandomBit() : Result {\n        // Allocate a qubit.\n        use q = Qubit();\n\n        // Set the qubit into superposition of 0 and 1 using the Hadamard\n        // operation `H`.\n        H(q);\n\n        // At this point the qubit `q` has 50% chance of being measured in the\n        // |0〉 state and 50% chance of being measured in the |1〉 state.\n        // Measure the qubit value using the `M` operation, and store the\n        // measurement value in the `result` variable.\n        let result = M(q);\n\n        // Reset qubit to the |0〉 state.\n        // Qubits must be in the |0〉 state by the time they are released.\n        Reset(q);\n\n        // Return the result of the measurement.\n        return result;\n\n        // Note that Qubit `q` is automatically released at the end of the block.\n    }\n}\n"
+        "code": "/// # Sample\n/// Quantum Random Number Generator\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// in superposition and then using the measurement results as random bits.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Intrinsic;\n    open Microsoft.Quantum.Math;\n\n    @EntryPoint()\n    operation Main() : Int {\n        let max = 100;\n        Message($\"Sampling a random number between 0 and {max}:\");\n\n        // Generate random number in the 0..max range.\n        return GenerateRandomNumberInRange(max);\n    }\n\n    /// # Summary\n    /// Generates a random number between 0 and `max`.\n    operation GenerateRandomNumberInRange(max : Int) : Int {\n        // Determine the number of bits needed to represent `max` and store it\n        // in the `nBits` variable. Then generate `nBits` random bits which will\n        // represent the generated random number.\n        mutable bits = [];\n        let nBits = BitSizeI(max);\n        for idxBit in 1..nBits {\n            set bits += [GenerateRandomBit()];\n        }\n        let sample = ResultArrayAsInt(bits);\n\n        // Return random number if it is within the requested range.\n        // Generate it again if it is outside the range.\n        return sample > max ? GenerateRandomNumberInRange(max) | sample;\n    }\n\n    /// # Summary\n    /// Generates a random bit.\n    operation GenerateRandomBit() : Result {\n        // Allocate a qubit.\n        use q = Qubit();\n\n        // Set the qubit into superposition of 0 and 1 using the Hadamard\n        // operation `H`.\n        H(q);\n\n        // At this point the qubit `q` has 50% chance of being measured in the\n        // |0〉 state and 50% chance of being measured in the |1〉 state.\n        // Measure the qubit value using the `M` operation, and store the\n        // measurement value in the `result` variable.\n        let result = M(q);\n\n        // Reset qubit to the |0〉 state.\n        // Qubits must be in the |0〉 state by the time they are released.\n        Reset(q);\n\n        // Return the result of the measurement.\n        return result;\n\n        // Note that Qubit `q` is automatically released at the end of the block.\n    }\n}\n"
     },
     {
         "title": "Deutsch-Jozsa",
@@ -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.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Random;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Unstable.Arithmetic;\n    open Microsoft.Quantum.Arrays;\n\n    @EntryPoint()\n    operation 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`\n    operation 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`.\n    function 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.\n    function 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`\n    operation 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.\n    operation 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`.\n    internal 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\n    internal 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\n    internal 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}\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.\nnamespace Sample {\n    open Microsoft.Quantum.Convert;\n    open Microsoft.Quantum.Diagnostics;\n    open Microsoft.Quantum.Random;\n    open Microsoft.Quantum.Math;\n    open Microsoft.Quantum.Unstable.Arithmetic;\n    open Microsoft.Quantum.Arrays;\n\n    @EntryPoint()\n    operation 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`\n    operation 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`.\n    function 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.\n    function 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`\n    operation 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.\n    operation 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`.\n    internal 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\n    internal 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\n    internal 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}\n"
     },
     {
         "title": "Dynamics (Resource Estimation)",

package/docs/Microsoft.Quantum.Arrays/All.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.All
 title: All function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Any.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Any
 title: Any function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Chunks.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Chunks
 title: Chunks function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/CircularlyShifted.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.CircularlyShifted
 title: CircularlyShifted function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/ColumnAt.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.ColumnAt
 title: ColumnAt function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Count.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Count
 title: Count function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Diagonal.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Diagonal
 title: Diagonal function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/DrawMany.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.DrawMany
 title: DrawMany operation
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Enumerated.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Enumerated
 title: Enumerated function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Excluding.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Excluding
 title: Excluding function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Filtered.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Filtered
 title: Filtered function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/FlatMapped.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.FlatMapped
 title: FlatMapped function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Flattened.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Flattened
 title: Flattened function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Fold.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Fold
 title: Fold function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/ForEach.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.ForEach
 title: ForEach operation
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Head.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Head
 title: Head function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/HeadAndRest.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.HeadAndRest
 title: HeadAndRest function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IndexOf.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IndexOf
 title: IndexOf function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IndexRange.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IndexRange
 title: IndexRange function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Interleaved.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Interleaved
 title: Interleaved function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsEmpty.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsEmpty
 title: IsEmpty function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsRectangularArray.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsRectangularArray
 title: IsRectangularArray function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsSorted.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsSorted
 title: IsSorted function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/IsSquareArray.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.IsSquareArray
 title: IsSquareArray function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Mapped.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Mapped
 title: Mapped function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/MappedByIndex.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.MappedByIndex
 title: MappedByIndex function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/MappedOverRange.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.MappedOverRange
 title: MappedOverRange function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Most.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Most
 title: Most function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/MostAndTail.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.MostAndTail
 title: MostAndTail function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Padded.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Padded
 title: Padded function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Partitioned.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Partitioned
 title: Partitioned function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Rest.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Rest
 title: Rest function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Reversed.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Reversed
 title: Reversed function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/SequenceI.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.SequenceI
 title: SequenceI function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/SequenceL.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.SequenceL
 title: SequenceL function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Sorted.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Sorted
 title: Sorted function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Subarray.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Subarray
 title: Subarray function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Swapped.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Swapped
 title: Swapped function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Tail.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Tail
 title: Tail function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Transposed.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Transposed
 title: Transposed function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Unzipped.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Unzipped
 title: Unzipped function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Where.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Where
 title: Where function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Windows.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Windows
 title: Windows function
-ms.date: 06/26/2024 12:00:00 AM
+ms.date: 07/09/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays