Merge f681ace into 12e6f5f

Author: swernli

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

@@ -389,6 +389,30 @@ function ConfigurePauliNoise(px : Double, py : Double, pz : Double) : Unit {
     body intrinsic;
 }
 
+/// # Summary
+/// Configures qubit loss during simulation.
+///
+/// # Description
+/// 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 to a qubit.
 ///
@@ -445,6 +469,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,51 @@ 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.
+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)
+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;
@@ -47,6 +49,7 @@ import Std.OpenQASM.Angle.AddAngles;
 import Std.OpenQASM.Angle.SubtractAngles;
 import Std.OpenQASM.Angle.DivideAngleByInt;
 import Std.OpenQASM.Angle.NegAngle;
+import Std.Convert.BoolAsResult;
 
 function ZERO_ANGLE() : Angle {
     return DoubleAsAngle(0., 1);
@@ -633,6 +636,11 @@ operation ccz(ctrl1 : Qubit, ctrl2 : Qubit, target : Qubit) : Unit is Adj + Ctl
     h(target);
 }
 
+operation mresetz_checked(q : Qubit) : Result[] {
+    let (r, b) = MResetZChecked(q);
+    [r, BoolAsResult(b)]
+}
+
 /// 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,

source/compiler/qsc/src/interpret.rs

@@ -577,11 +577,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)
     }
 
@@ -592,11 +596,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)
     }
 

source/compiler/qsc/src/interpret/tests.rs

@@ -24,7 +24,7 @@ mod given_interpreter {
         let mut cursor = Cursor::new(Vec::<u8>::new());
         let mut receiver = CursorReceiver::new(&mut cursor);
         (
-            interpreter.run(&mut receiver, Some(expr), None),
+            interpreter.run(&mut receiver, Some(expr), None, None),
             receiver.dump(),
         )
     }

source/compiler/qsc_circuit/src/builder.rs

@@ -55,17 +55,17 @@ impl Backend for Builder {
         self.push_gate(gate("H", [q]));
     }
 
-    fn m(&mut self, q: usize) -> Self::ResultType {
+    fn m(&mut self, q: usize) -> Option<Self::ResultType> {
         let mapped_q = self.map(q);
         // In the Circuit schema, result id is per-qubit
         let res_id = self.num_measurements_for_qubit(mapped_q);
         let id = self.remapper.m(q);
 
         self.push_gate(measurement_gate(mapped_q.0, res_id));
-        id
+        Some(id)
     }
 
-    fn mresetz(&mut self, q: usize) -> Self::ResultType {
+    fn mresetz(&mut self, q: usize) -> Option<Self::ResultType> {
         let mapped_q = self.map(q);
         // In the Circuit schema, result id is per-qubit
         let res_id = self.num_measurements_for_qubit(mapped_q);
@@ -78,7 +78,7 @@ impl Backend for Builder {
         // a measurement and a reset gate.
         self.push_gate(measurement_gate(mapped_q.0, res_id));
         self.push_gate(ket_gate("0", [mapped_q]));
-        id
+        Some(id)
     }
 
     fn reset(&mut self, q: usize) {