Support for qubit loss

library/core/qir.qs

@@ -27,5 +27,9 @@ namespace QIR.Runtime {
         }
     }
 
-    export __quantum__rt__qubit_allocate, __quantum__rt__qubit_release, AllocateQubitArray, ReleaseQubitArray;
+    function __quantum__rt__read_loss(r : Result) : Bool {
+        body intrinsic;
+    }
+
+    export __quantum__rt__qubit_allocate, __quantum__rt__qubit_release, AllocateQubitArray, ReleaseQubitArray, __quantum__rt__read_loss;
 }

library/std/src/Std/Diagnostics.qs

@@ -390,10 +390,34 @@ function ConfigurePauliNoise(px : Double, py : Double, pz : Double) : Unit {
 }
 
 /// # Summary
-/// Applies configured noise to a qubit.
+/// Configures qubit loss during simulation.
 ///
 /// # Description
-/// This operation applies configured noise to a qubit during simulation. For example,
+/// This function configures qubit loss for simulation. The parameter `p` represents
+/// the probability of a qubit loss during simulation. If `p` is greater than 0.0, the simulator will mark qubits
+/// as lost with the given probability during each operation that acts on them.
+/// Qubits that are lost are reset to the |0⟩ state but are not released. Loss is reported when the qubit is measured,
+/// and then the qubit is considered "reloaded" and can be used again.
+///
+/// # Input
+/// ## p
+/// The probability of a qubit being lost during simulation. Must be between 0.0 and 1.0.
+///
+/// # Remarks
+/// This operation is useful for simulating qubit loss for those modalities where qubit loss is a factor.
+/// Note that the value returned from a measurement of a lost qubit is neither `Zero` nor `One`, but rather a special
+/// value indicating that the qubit was lost. This value cannot be used in comparisons and will cause a runtime
+/// failure if compared to another value.
+/// To perform a measurement that includes a check for qubit loss, use the `MResetZChecked` operation.
+function ConfigureQubitLoss(p : Double) : Unit {
+    body intrinsic;
+}
+
+/// # Summary
+/// Applies configured noise or loss to a qubit.
+///
+/// # Description
+/// This operation applies configured noise and/or loss to a qubit during simulation. For example,
 /// if configured noise is a bit-flip noise with 5% probability, the X gate will be applied
 /// with 5% probability. If no noise is configured, no noise is applied.
 /// This is useful to simulate noise during idle periods. It could also be used to
@@ -402,6 +426,10 @@ function ConfigurePauliNoise(px : Double, py : Double, pz : Double) : Unit {
 /// # Input
 /// ## qubit
 /// The qubit to which noise is applied.
+///
+/// # See Also
+/// - [Std.Diagnostics.ConfigurePauliNoise](xref:Qdk.Std.Diagnostics.ConfigurePauliNoise)
+/// - [Std.Diagnostics.ConfigureQubitLoss](xref:Qdk.Std.Diagnostics.ConfigureQubitLoss)
 operation ApplyIdleNoise(qubit : Qubit) : Unit {
     body intrinsic;
 }
@@ -445,6 +473,7 @@ export
     StartCountingQubits,
     StopCountingQubits,
     ConfigurePauliNoise,
+    ConfigureQubitLoss,
     ApplyIdleNoise,
     BitFlipNoise,
     PhaseFlipNoise,

library/std/src/Std/Measurement.qs

@@ -5,7 +5,8 @@
 import Std.Core.*;
 import Std.Intrinsic.*;
 import Std.Diagnostics.*;
-open QIR.Intrinsic;
+import QIR.Intrinsic.*;
+import QIR.Runtime.*;
 
 /// # Summary
 /// Jointly measures a register of qubits in the Pauli Z basis.
@@ -160,5 +161,56 @@ operation MeasureInteger(target : Qubit[]) : Int {
 
     number
 }
-export MeasureAllZ, MeasureEachZ, MResetEachZ, MResetX, MResetY, MResetZ, MeasureInteger;
 
+/// # Summary
+/// Performs a single-qubit measurement in the Pauli Z basis, resetting the `target` to the |0⟩ state after the measurement.
+/// Additionally, it checks if the measurement result indicates a loss and returns `true` when a loss is detected. If the qubit
+/// is lost, the result value will not be `Zero` or `One` and any use of that result in a comparison will cause a runtime failure.
+/// This operation is not supported on all hardware targets.
+///
+/// # Input
+/// ## target
+/// A single qubit to be measured.
+///
+/// # Output
+/// A tuple containing the measurement result and a Boolean `true` if the result indicates a loss, otherwise `false`.
+///
+/// # Remarks
+/// This operation is useful for detecting qubit loss during execution. During simulation, qubit loss probability can be
+/// configured via the `ConfigureQubitLoss` operation. When compiled to QIR, this uses the `__quantum__rt__read_loss` intrinsic,
+/// which may not be supported on all hardware targets and could result in compilation errors when submitting to those targets.
+///
+/// # See also
+/// - [Std.Measurement.IsLossResult](xref:Qdk.Std.Measurement.IsLossResult)
+/// - [Std.Diagnostics.ConfigureQubitLoss](xref:Qdk.Std.Diagnostics.ConfigureQubitLoss)
+operation MResetZChecked(target : Qubit) : (Result, Bool) {
+    let res = MResetZ(target);
+    (res, IsLossResult(res))
+}
+
+/// # Summary
+/// Checks if the measurement result indicates qubit loss. Such measurement results are not `Zero` or `One`
+/// and using such a result in comparisons causes a runtime failure.
+/// This operation is not supported on all hardware targets.
+///
+/// # Input
+/// ## res
+/// The measurement result to check.
+///
+/// # Output
+/// A Boolean value indicating whether the result indicates a loss (`true`) or not (`false`).
+///
+/// # Remarks
+/// This operation is useful for detecting qubit loss during execution. After measurement result from qubit loss
+/// cannot be used in a comparison, and any attempt to do so will result in a runtime failure. During simulation, qubit loss
+/// probability can be configured via the `ConfigureQubitLoss` operation. When compiled to QIR, this uses the
+/// `__quantum__rt__read_loss` intrinsic, which may not be supported on all hardware targets and could result in compilation errors when submitting to those targets.
+///
+/// # See also
+/// - [Std.Measurement.MResetZChecked](xref:Qdk.Std.Measurement.MResetZChecked)
+/// - [Std.Diagnostics.ConfigureQubitLoss](xref:Qdk.Std.Diagnostics.ConfigureQubitLoss)
+operation IsLossResult(res : Result) : Bool {
+    __quantum__rt__read_loss(res)
+}
+
+export MeasureAllZ, MeasureEachZ, MResetEachZ, MResetX, MResetY, MResetZ, MeasureInteger, MResetZChecked, IsLossResult;

library/std/src/Std/OpenQASM/Intrinsic.qs

@@ -38,6 +38,8 @@ export rxx, ryy, rzz;
 // that Qiskit wont emit correctly.
 export dcx, ecr, r, rzx, cs, csdg, sxdg, csx, rccx, c3sqrtx, c3x, rc3x, xx_minus_yy, xx_plus_yy, ccz;
 
+export mresetz_checked;
+
 export __quantum__qis__barrier__body;
 
 import Std.OpenQASM.Angle.Angle;
@@ -633,6 +635,18 @@ operation ccz(ctrl1 : Qubit, ctrl2 : Qubit, target : Qubit) : Unit is Adj + Ctl
     h(target);
 }
 
+/// A resetting measurement operation that checks for qubit loss.
+/// Returns 0 if the qubit measurement was `Zero`, 1 if it was `One`,
+/// and 2 if the measurement indicated qubit loss.
+operation mresetz_checked(q : Qubit) : Int {
+    let (r, b) = Std.Measurement.MResetZChecked(q);
+    if b {
+        2
+    } else {
+        Std.OpenQASM.Convert.ResultAsInt(r)
+    }
+}
+
 /// The ``BARRIER`` function is used to implement the `barrier` statement in QASM.
 /// The `@SimulatableIntrinsic` attribute is used to mark the operation for QIR
 /// generation.

samples/notebooks/noise.ipynb

@@ -4,15 +4,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Simulating Pauli noise\n",
-    "This notebook shows how to run simulations with Pauli noise, such as bit-flip or depolarizing noise.\n",
+    "# Simulating Pauli noise and Qubit Loss\n",
+    "This notebook shows how to run simulations with Pauli noise, such as bit-flip or depolarizing noise, as well as qubit loss.\n",
     "\n",
     "First, make sure prerequisites are available. Packages `qsharp` and `qsharp_widgets` must be already installed."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "vscode": {
      "languageId": "qsharp"
@@ -101,7 +101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "vscode": {
      "languageId": "qsharp"
@@ -182,6 +182,69 @@
     "result = qsharp.run(\"Cat5()\", 1000, noise=(0.0, 0.1, 0.0))\n",
     "display(qsharp_widgets.Histogram(result))"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Simulating with Qubit Loss\n",
+    "\n",
+    "For some qubit modalities, a qubit may undergo \"loss\" during execution. This means the physical system backing the qubit is unable to be measured or operated on. To test behaviors of an algorithm in the presence of qubit loss, you can use the `qubit_loss` parameter to `qsharp.run` and set the probability of a qubit being lost on each operation. Qubit loss is reported only at measurement time, where a special `Loss` value is returned that is neither `One` nor `Zero`. During simulation, a lost qubit is no longer acted on by gates and remains in the $\\ket{0}$ state until it is measured or reset, at which point the simulation reloads a fresh qubit to support future operations.\n",
+    "\n",
+    "In this example, we'll set the qubit loss probability to high 50% to ensure some qubits are lost during simulation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = qsharp.run(\"BellPair()\", 100, qubit_loss=0.5)\n",
+    "display(qsharp_widgets.Histogram(result))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that the `Loss` value is not usable inside of the simulation, and any comparisons on that value will trigger a runtime failure. To avoid this failure, use `IsLossResult` to check whether the result value corresponds to qubit loss before using it in any branching logic:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "qsharp"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%%qsharp\n",
+    "\n",
+    "operation CheckForLoss() : (Bool, Bool) {\n",
+    "    use q = Qubit();\n",
+    "    H(q);\n",
+    "    let res = MResetZ(q);\n",
+    "    if IsLossResult(res) {\n",
+    "        return (true, false);\n",
+    "    } elif res == One {\n",
+    "        return (false, true);\n",
+    "    } else {\n",
+    "        return (false, false);\n",
+    "    }\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qsharp_widgets.Histogram(qsharp.run(\"CheckForLoss()\", 100, qubit_loss=0.5))"
+   ]
   }
  ],
  "metadata": {
@@ -200,7 +263,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.13"
   }
  },
  "nbformat": 4,

samples/notebooks/openqasm.ipynb

@@ -333,11 +333,73 @@
         "\n",
         "print(compile(parameterized_program, 1.57))"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "31d20b6c",
+      "metadata": {},
+      "source": [
+        "When running an OpenQASM program in simulation with qubit loss, additional `Result.Loss` values may be returned that indicate the measured qubit was lost during execution:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "168c3226",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "init()\n",
+        "\n",
+        "source = \"\"\"\n",
+        "include \"stdgates.inc\";\n",
+        "bit[2] c;\n",
+        "qubit[2] q;\n",
+        "c = measure q;\n",
+        "\"\"\"\n",
+        "\n",
+        "import_openqasm(source, name=\"measure2\")\n",
+        "\n",
+        "from qsharp.code import measure2\n",
+        "\n",
+        "Histogram(run(measure2, shots=1000, qubit_loss=0.1))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4773ac0e",
+      "metadata": {},
+      "source": [
+        "By using the special include `\"qdk.inc\"` you can check for loss at runtime using the `mresetz_checked` function. It returns an integer with two bits to indicate whether or not loss has occurred, such that `0` or `1` correspond to the qubit measurement and `2` corresponds to loss:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "02a97625",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "source = \"\"\"\n",
+        "include \"stdgates.inc\";\n",
+        "include \"qdk.inc\";\n",
+        "qubit q;\n",
+        "output int res;\n",
+        "h q;\n",
+        "res = mresetz_checked(q);\n",
+        "\"\"\"\n",
+        "\n",
+        "import_openqasm(source, name=\"mresetz_checked_example\")\n",
+        "\n",
+        "from qsharp.code import mresetz_checked_example\n",
+        "\n",
+        "Histogram(run(mresetz_checked_example, shots=1000, qubit_loss=0.1))\n"
+      ]
     }
   ],
   "metadata": {
     "kernelspec": {
-      "display_name": ".venv",
+      "display_name": "Python 3",
       "language": "python",
       "name": "python3"
     },
@@ -351,7 +413,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.13.3"
+      "version": "3.11.13"
     }
   },
   "nbformat": 4,

source/compiler/qsc/src/interpret.rs

@@ -578,11 +578,15 @@ impl Interpreter {
         callable: Value,
         args: Value,
         noise: Option<PauliNoise>,
+        qubit_loss: Option<f64>,
     ) -> InterpretResult {
         let mut sim = match noise {
             Some(noise) => SparseSim::new_with_noise(&noise),
             None => SparseSim::new(),
         };
+        if let Some(loss) = qubit_loss {
+            sim.set_loss(loss);
+        }
         self.invoke_with_sim(&mut sim, receiver, callable, args)
     }
 
@@ -593,11 +597,15 @@ impl Interpreter {
         receiver: &mut impl Receiver,
         expr: Option<&str>,
         noise: Option<PauliNoise>,
+        qubit_loss: Option<f64>,
     ) -> InterpretResult {
         let mut sim = match noise {
             Some(noise) => SparseSim::new_with_noise(&noise),
             None => SparseSim::new(),
         };
+        if let Some(loss) = qubit_loss {
+            sim.set_loss(loss);
+        }
         self.run_with_sim(&mut sim, receiver, expr)
     }