qsharp-lang 1.14.4-dev → 1.14.5-dev

package/dist/samples.generated.js

@@ -4,35 +4,60 @@ export default [
         "shots": 100,
         "code": "// # Sample\n// Getting started\n//\n// # Description\n// This is a minimal Q# program that can be used to start writing Q# code.\n\noperation Main() : Unit {\n    // TODO: Write your Q# code here.\n}\n"
     },
+    {
+        "title": "Quantum Hello World",
+        "shots": 100,
+        "code": "/// # Summary\n/// Quantum Hello World sample\n///\n/// # Description\n/// This is one of the simplest Q# programs that contains quantum part.\n/// This code prints the message then allocates a qubit and immediately measures it.\n/// Since the qubit starts in |0〉 state such measurement will always yield `Zero`.\noperation Main() : Result {\n    // Print the message (when running on a simulator).\n    Message(\"Hello world!\");\n\n    // Allocate a qubit. Qubit is in |0〉 state after allocation.\n    use qubit = Qubit();\n\n    // Measure then reset the qubit. Last statement returns result from `Main`.\n    // Measurement result is `Zero` as the qubit is in |0〉 state.\n    MResetZ(qubit)\n\n    // Note, that `qubit` is automatically deallocated at the end of the block.\n}\n"
+    },
+    {
+        "title": "Measurement",
+        "shots": 100,
+        "code": "/// # Summary\n/// Measurement sample\n///\n/// # Description\n/// This Q# program demonstrates how to perform measurements in Z basis.\n///\n/// # Remarks\n/// Quantum measurement is an irreversible operation in which a quantum system\n/// is manipulated to yield a numerical result. Measuring a quantum system\n/// generally changes the quantum state that describes that system.\noperation Main() : (Result, Result[]) {\n    // Allocate a qubit. Qubit is in |0〉 state after allocation.\n    use q = Qubit();\n    // Flip the state. Qubit is in |1〉 state now.\n    X(q);\n\n    // The `MResetZ` operation performs a measurement of a single qubit in the\n    // computational basis, also known as the Pauli Z basis. Then it resets\n    // the qubit to |0〉 state. `MResetZ` may be more efficient than measuring\n    // a qubit and resetting it using two separate operations.\n    let result = MResetZ(q);\n\n    // Allocate a two-qubit array (or register).\n    use qs = Qubit[2];\n\n    // The `MResetEachZ` operation measures each qubit in an array in the\n    // computational basis and resets each qubit to |0〉 state. It returns\n    // an array of `Result` values.\n    let results = MResetEachZ(qs);\n\n    // Return all results. In Q#, the result of a measurement is a value\n    // of the type `Result`, that is, `One` or `Zero`.\n    (result, results)\n}\n"
+    },
     {
         "title": "Superposition",
         "shots": 100,
-        "code": "/// # Sample\n/// Superposition\n///\n/// # Description\n/// This Q# program sets a qubit in a superposition of the computational basis\n/// states |0〉 and |1〉 by applying a Hadamard transformation.\noperation Main() : Result {\n    // Qubits are only accessible for the duration of the scope where they\n    // are allocated and are automatically released at the end of the scope.\n    use qubit = Qubit();\n\n    // Set the qubit in superposition by applying a Hadamard transformation.\n    H(qubit);\n\n    // Measure the qubit. There is a 50% probability of measuring either\n    // `Zero` or `One`.\n    let result = M(qubit);\n\n    // Reset the qubit so it can be safely released.\n    Reset(qubit);\n    return result;\n}\n"
+        "code": "/// # Summary\n/// Superposition sample\n///\n/// # Description\n/// This Q# program sets a qubit in a superposition of the computational basis\n/// states |0〉 and |1〉 by applying a Hadamard transformation.\noperation Main() : Result {\n    // Allocate a qubit. Qubit is in |0〉 state after allocation.\n    use qubit = Qubit();\n    // Qubits are only accessible for the duration of the scope where they\n    // are allocated and are automatically released at the end of the scope.\n\n    // Set the qubit in superposition by applying a Hadamard transformation.\n    H(qubit);\n\n    // Show the quantum state (when running on a simulator).\n    Std.Diagnostics.DumpMachine();\n\n    // Measure then reset the qubit. Return the result.\n    // There is a 50% probability of measuring either `Zero` or `One`.\n    MResetZ(qubit)\n}\n"
     },
     {
         "title": "Entanglement",
         "shots": 100,
-        "code": "/// # Sample\n/// Entanglement\n///\n/// # Description\n/// Qubits are said to be entangled when the state of each one of them cannot be\n/// described independently from the state of the others.\n///\n/// This Q# program entangles two qubits.\nimport Std.Diagnostics.*;\n\noperation Main() : (Result, Result) {\n    // Allocate the two qubits that will be entangled.\n    use (q1, q2) = (Qubit(), Qubit());\n\n    // Set the first qubit in superposition by calling the `H` operation,\n    // which applies a Hadamard transformation to the qubit.\n    // Then, entangle the two qubits using the `CNOT` operation.\n    H(q1);\n    CNOT(q1, q2);\n\n    // Show the entangled state using the `DumpMachine` function.\n    DumpMachine();\n\n    // Measurements of entangled qubits are always correlated.\n    let (m1, m2) = (M(q1), M(q2));\n    Reset(q1);\n    Reset(q2);\n    return (m1, m2);\n}\n"
+        "code": "/// # Summary\n/// Entanglement sample\n///\n/// # Description\n/// This Q# program entangles two qubits and measures them.\n///\n/// # Remarks\n/// Qubits are said to be entangled when the state of each one of them\n/// cannot be described independently from the state of the others.\noperation Main() : Result[] {\n    // Allocate the two qubits that will be entangled.\n    use q1 = Qubit();\n    use q2 = Qubit();\n\n    // Set the first qubit in superposition by calling the `H` operation,\n    // which applies a Hadamard transformation to the qubit.\n    H(q1);\n    // Entangle the two qubits using the `CNOT` operation.\n    CNOT(q1, q2);\n\n    // Show the entangled state using the `DumpMachine` function.\n    // Note that the state is a superposition of |00〉 and |11〉,\n    // but not |01〉 and |10〉.\n    Std.Diagnostics.DumpMachine();\n\n    // Create an array (register) out of the two qubits, measure each qubit,\n    // reset each qubit, return the array of measurement results.\n    MResetEachZ([q1, q2])\n}\n"
     },
     {
-        "title": "Bell States",
+        "title": "Bell Pair",
         "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.\nimport Std.Diagnostics.*;\n\noperation Main() : (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        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.\noperation 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.\noperation 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.\noperation 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.\noperation 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"
+        "code": "/// # Summary\n/// Bell Pair sample\n///\n/// # Description\n/// Bell pairs are specific quantum states of two qubits that represent\n/// the simplest (and maximal) examples of quantum entanglement. This sample\n/// prepares |Φ⁺⟩ = (|00⟩+|11⟩)/√2. For other Bell states see BellStates.qs\n///\n/// # References\n/// - [Bell state](https://en.wikipedia.org/wiki/Bell_state)\noperation Main() : (Result, Result) {\n    // Allocate the two qubits that will be used to create a Bell pair.\n    use (q1, q2) = (Qubit(), Qubit());\n\n    // Create Bell pair by calling `PrepareBellPair` operation defined below.\n    PrepareBellPair(q1, q2);\n\n    // Show the state of qubits using the `DumpMachine` function.\n    Std.Diagnostics.DumpMachine();\n\n    // Measure the two qubits and reset them. Return measurement results.\n    (MResetZ(q1), MResetZ(q2))\n}\n\n/// # Summary\n/// Prepare Bell pair |Φ⁺⟩ = (|00⟩+|11⟩)/√2 on two qubits.\n/// Qubits are assumed to be in |00⟩ state.\noperation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {\n    // Set qubit `q1` in superposition of |0⟩ and |1⟩ by applying a Hadamard gate.\n    H(q1);\n\n    // Entangle the two qubits `q1` and `q2` using the `CNOT` gate.\n    CNOT(q1, q2);\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.\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Measurement.*;\n\noperation 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        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.\noperation 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 |+⟩.\noperation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n    H(q);\n}\n\n/// # Summary\n/// Sets a qubit in state |0⟩ to |−⟩.\noperation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n    X(q);\n    H(q);\n}\n"
+        "title": "Bell States",
+        "shots": 100,
+        "code": "/// # Summary\n/// Bell States sample\n///\n/// # Description\n/// This Q# sample shows how to prepare the four different Bell states.\n///\n/// # Remarks\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/// # References\n/// - [Bell state](https://en.wikipedia.org/wiki/Bell_state)\noperation Main() : (Result, Result)[] {\n    // Prepare and measure each pair. Return an array of these results.\n    [\n        PrepareAndMeasurePair(PreparePhiPlus, \"|Φ+〉\"),\n        PrepareAndMeasurePair(PreparePhiMinus, \"|Φ-〉\"),\n        PrepareAndMeasurePair(PreparePsiPlus, \"|Ψ+〉\"),\n        PrepareAndMeasurePair(PreparePsiMinus, \"|Ψ-〉\")\n    ]\n}\n\n/// # Summary\n/// Allocates a pair of qubits, prepares them using `preparation` operation,\n/// Then measures and resets them. Returns a pair of results.\noperation PrepareAndMeasurePair(\n    preparation : Qubit[] => Unit,\n    name : String\n) : (Result, Result) {\n    // Allocate a pair of qubits\n    use pair = Qubit[2];\n    // Prepare them using the preparation operation\n    preparation(pair);\n    // Show the name of the prepared state\n    Message($\"Bell state {name}:\");\n    // Show the prepared state\n    Std.Diagnostics.DumpMachine();\n    // Measure, reset and return\n    (MResetZ(pair[0]), MResetZ(pair[1]))\n}\n\n/// # Summary\n/// Prepares |Φ+⟩ = (|00⟩+|11⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePhiPlus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    CNOT(register[0], register[1]); // (|00〉 + |11〉)/sqrt(2)\n}\n\n/// # Summary\n/// Prepares |Φ−⟩ = (|00⟩-|11⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePhiMinus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    Z(register[0]);                 // |-0〉\n    CNOT(register[0], register[1]); // (|00〉 - |11〉)/sqrt(2)\n}\n\n/// # Summary\n/// Prepares |Ψ+⟩ = (|01⟩+|10⟩)/√2 state assuming `register` is in |00⟩ state.\noperation PreparePsiPlus(register : Qubit[]) : Unit {\n    H(register[0]);                 // |+0〉\n    X(register[1]);                 // |+1〉\n    CNOT(register[0], register[1]); // (|01〉 + |10〉)/sqrt(2)\n}\n\n/// # Summary\n/// Prepares |Ψ−⟩ = (|01⟩-|10⟩)/√2 state assuming `register` is in |00⟩ state.\noperation 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]); // (|01〉 - |10〉)/sqrt(2)\n}\n"
     },
     {
-        "title": "Random Bit",
+        "title": "Cat States",
         "shots": 100,
-        "code": "/// # Sample\n/// Random Bit\n///\n/// # Description\n/// This Q# program generates a random bit by setting a qubit in a superposition\n/// of the computational basis states |0〉 and |1〉, and returning the measurement\n/// result.\noperation Main() : Result {\n    // Qubits are only accessible for the duration of the scope where they\n    // are allocated and are automatically released at the end of the scope.\n    use qubit = Qubit();\n\n    // Set the qubit in superposition by applying a Hadamard transformation.\n    H(qubit);\n\n    // Measure the qubit. There is a 50% probability of measuring either\n    // `Zero` or `One`.\n    let result = M(qubit);\n\n    // Reset the qubit so it can be safely released.\n    Reset(qubit);\n    return result;\n}\n"
+        "code": "/// # Summary\n/// Greenberger–Horne–Zeilinger state sample\n///\n/// # Description\n/// This Q# program shows how to prepare a generalized Greenberger–Horne–Zeilinger\n/// state (aka Cat state) in a register of 5 qubits.\n///\n/// # Remarks\n/// The Greenberger–Horne–Zeilinger state, or GHZ state, aka Cat state,\n/// is a state defined as: |GHZ〉 = (|0...0〉 + |1...1〉)/√2.\n///\n/// The GHZ state is said to be a maximally entangled state, a multi-qubit\n/// state where the state of any one qubit is not separable from the state\n/// of any of the other qubits.\n///\n/// # References\n/// - [Greenberger–Horne–Zeilinger state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state)\n/// - [Cat state](https://en.wikipedia.org/wiki/Cat_state)\noperation Main() : Result[] {\n    // Allocate 5 qubits for Cat₅ state.\n    use cat5 = Qubit[5];\n    // Prepare a Cat₅ state in the register.\n    PrepareGHZState(cat5);\n    // Show the Cat₅ state.\n    Std.Diagnostics.DumpMachine();\n    // Measure and reset qubits. Return results.\n    MResetEachZ(cat5)\n}\n\n/// # Summary\n/// Prepares GHZ state (|0...0〉 + |1...1〉) / √2 (aka Cat state) in `qs` register.\n/// All qubits are assumed to be in |0〉 state on input.\noperation PrepareGHZState(qs : Qubit[]) : Unit {\n    Std.Diagnostics.Fact(Length(qs) > 0, \"Qubit register must not be empty.\");\n\n    // Set the first qubit into a (|0〉 + |1〉) / √2 superposition.\n    H(qs[0]);\n\n    // Then apply a CNOT to the remaining qubits using the first qubit as control.\n    // This entangles first qubit with all the other qubits in the register.\n    for q in qs[1...] {\n        CNOT(qs[0], q);\n    }\n}\n"
     },
     {
-        "title": "Random Number Generator",
+        "title": "Random Bits",
         "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.\nimport Std.Measurement.*;\nimport Std.Intrinsic.*;\n\noperation Main() : Result[] {\n    // Generate 5-bit random number.\n    let nBits = 5;\n    return GenerateNRandomBits(nBits);\n}\n\n/// # Summary\n/// Generates N random bits.\noperation GenerateNRandomBits(nBits : Int) : Result[] {\n    // Allocate N qubits.\n    use register = Qubit[nBits];\n\n    // Set the qubits into superposition of 0 and 1 using the Hadamard\n    // operation `H`.\n    for qubit in register {\n        H(qubit);\n    }\n\n    // At this point each has 50% chance of being measured in the |0〉 state\n    // and 50% chance of being measured in the |1〉 state.\n    // Measure each qubit and reset them all so they can be safely\n    // deallocated.\n    let results = MResetEachZ(register);\n    return results;\n}\n"
+        "code": "/// # Summary\n/// Simple Quantum Random Number Generator sample\n///\n/// # Description\n/// This program implements a quantum random number generator by setting qubits\n/// into superposition and then using the measurement results as random bits.\n/// This is equivalent to generating a random number in the range of 0..2ᴺ-1.\noperation Main() : Result[] {\n    // Generate a 5-bit random number.\n    GenerateNRandomBits(5)\n}\n\n/// # Summary\n/// Generates N random bits in the form of `Zero` or `One` results.\noperation GenerateNRandomBits(nBits : Int) : Result[] {\n    // Array for the results\n    mutable results = [];\n    for _ in 1..nBits {\n        // Append next random result to the array\n        results += [GenerateRandomBit()];\n    }\n    results\n}\n\n/// # Summary\n/// Generates a random bit in the form of `Zero` or `One` result.\noperation GenerateRandomBit() : Result {\n    // Allocate a qubit\n    use q = Qubit();\n    // Set the qubit into uniform superposition of |0〉 and |1〉\n    H(q);\n    // Now the qubit has 50% chance of being measured as `One`\n    // and 50% chance of being measured as `Zero`.\n    // Measure and reset the qubit. Return the result.\n    MResetZ(q)\n}\n"
+    },
+    {
+        "title": "Teleportation (Simple).qs",
+        "shots": 100,
+        "code": "/// # Summary\n/// Simple quantum teleportation sample\n///\n/// # Description\n/// This Q# program demonstrates how to teleport quantum state\n/// by communicating two classical bits and using previously entangled qubits.\n/// This code teleports one specific state, but any state can be teleported.\noperation Main() : Bool {\n    // Allocate `qAlice`, `qBob` qubits\n    use (qAlice, qBob) = (Qubit(), Qubit());\n\n    // Entangle `qAlice`, `qBob` qubits\n    H(qAlice);\n    CNOT(qAlice, qBob);\n\n    // From now on qubits `qAlice` and `qBob` will not interact directly.\n\n    // Allocate `qToTeleport` qubit and prepare it to be |𝜓⟩≈0.9394|0⟩−0.3429𝑖|1⟩\n    use qToTeleport = Qubit();\n    Rx(0.7, qToTeleport);\n\n    // Prepare the message by entangling `qToTeleport` and `qAlice` qubits\n    CNOT(qToTeleport, qAlice);\n    H(qToTeleport);\n\n    // Obtain classical measurement results b1 and b2 at Alice's site.\n    let b1 = M(qToTeleport) == One;\n    let b2 = M(qAlice) == One;\n\n    // At this point classical bits b1 and b2 are \"sent\" to the Bob's site.\n\n    // Decode the message by applying adjustments based on classical data b1 and b2.\n    if b1 {\n        Z(qBob);\n    }\n    if b2 {\n        X(qBob);\n    }\n\n    // Make sure that the obtained message is |𝜓⟩≈0.9394|0⟩−0.3429𝑖|1⟩\n    Rx(-0.7, qBob);\n    let correct = Std.Diagnostics.CheckZero(qBob);\n    Message($\"Teleportation successful: {correct}.\");\n\n    // Reset all qubits to |0⟩ state.\n    ResetAll([qAlice, qBob, qToTeleport]);\n\n    // Return indication if the measurement of the state was correct\n    correct\n}\n"
+    },
+    {
+        "title": "JointMeasurement",
+        "shots": 100,
+        "code": "import Std.Diagnostics.*;\n\n/// # Summary\n/// Joint Measurement sample\n///\n/// # Description\n/// This Q# program demonstrates how to use Joint measurements.\n/// Joint measurement, also known as Pauli measurements, are a generalization\n/// of 2-outcome measurements to multiple qubits and other bases.\noperation Main() : (Result, Result[]) {\n    // Prepare an entangled state.\n    use qs = Qubit[2];  // |00〉\n    H(qs[0]);           // (|00〉 + |10〉)/sqrt(2)\n    CNOT(qs[0], qs[1]); // (|00〉 + |11〉)/sqrt(2)\n\n    // Show the quantum state before performing the joint measurement.\n    DumpMachine();\n\n    // The below code uses a joint measurement as a way to check the parity\n    // of the two qubits. In this case, the parity measurement result\n    // will always be `Zero`.\n    // Notice how the state was not collapsed by the joint measurement\n    // because this state is the eigenvector of the Z⊗Z operator.\n    let parityResult = Measure([PauliZ, PauliZ], qs);\n    DumpMachine();\n\n    // However, if we perform a measurement just on the first qubit, we can\n    // see how the state collapses.\n    let firstQubitResult = M(qs[0]);\n    DumpMachine();\n\n    // Measuring the last qubit does not change the quantum state\n    // since the state of the second qubit collapsed when the first qubit\n    // was measured because they were entangled.\n    let secondQubitResult = M(qs[1]);\n    DumpMachine();\n\n    // Reset qubits before they are released.\n    ResetAll(qs);\n\n    // Return results\n    (parityResult, [firstQubitResult, secondQubitResult])\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.\nimport Std.Diagnostics.*;\nimport Std.Intrinsic.*;\nimport Std.Measurement.*;\n\noperation 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        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.\noperation 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 |+⟩.\noperation SetToPlus(q : Qubit) : Unit is Adj + Ctl {\n    H(q);\n}\n\n/// # Summary\n/// Sets a qubit in state |0⟩ to |−⟩.\noperation SetToMinus(q : Qubit) : Unit is Adj + Ctl {\n    X(q);\n    H(q);\n}\n"
     },
     {
         "title": "Random Number Generator (Advanced)",

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

package/docs/Std.Arrays/ForEach.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.ForEach
 title: ForEach operation
 description: "Q# ForEach operation: Given an array and an operation that is defined for the elements of the array, returns a new array that consists of the images of the original array under the operation."
-ms.date: 03/20/2025
+ms.date: 03/31/2025
 ms.topic: managed-reference
 qsharp.kind: operation
 qsharp.package: __Std__

package/docs/Std.Arrays/Head.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.Head
 title: Head function
 description: "Q# Head function: Returns the first element of the array."
-ms.date: 03/20/2025
+ms.date: 03/31/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__

package/docs/Std.Arrays/HeadAndRest.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arrays.HeadAndRest
 title: HeadAndRest function
 description: "Q# HeadAndRest function: Returns a tuple of first and all remaining elements of the array."
-ms.date: 03/20/2025
+ms.date: 03/31/2025
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.package: __Std__