Add loss policies to NoiseConfig to express different kinds of behavior on lost qubits

source/compiler/qsc_eval/src/backend/noise_tests.rs

@@ -10,7 +10,7 @@ use crate::{
 use expect_test::{Expect, expect};
 use num_bigint::BigUint;
 use num_complex::Complex;
-use qdk_simulators::noise_config::{NoiseConfig, NoiseTable, encode_pauli};
+use qdk_simulators::noise_config::{LossPolicy, NoiseConfig, NoiseTable, encode_pauli};
 use std::fmt::Write;
 
 #[test]
@@ -258,6 +258,7 @@ fn noise_config_with_single_qubit_fault(
         qubits: 1,
         pauli_strings: vec![encode_pauli(pauli)],
         probabilities: vec![1.0],
+        on_loss: LossPolicy::Skip,
     };
     set_gate(&mut config, table);
     config
@@ -274,6 +275,7 @@ fn noise_config_with_two_qubit_fault(
         qubits: 2,
         pauli_strings: vec![encode_pauli(pauli)],
         probabilities: vec![1.0],
+        on_loss: LossPolicy::Skip,
     };
     set_gate(&mut config, table);
     config
@@ -525,6 +527,7 @@ fn noise_config_mz_with_loss() {
     let mut config = NoiseConfig::NOISELESS;
     config.mz = NoiseTable {
         qubits: 1,
+        on_loss: LossPolicy::Skip,
         pauli_strings: vec![encode_pauli("L")],
         probabilities: vec![1.0],
     };
@@ -545,6 +548,7 @@ fn noise_config_gate_loss_causes_measurement_loss() {
     let mut config = NoiseConfig::NOISELESS;
     config.x = NoiseTable {
         qubits: 1,
+        on_loss: LossPolicy::Skip,
         pauli_strings: vec![encode_pauli("L")],
         probabilities: vec![1.0],
     };

source/qdk_package/qdk/_native.pyi

@@ -868,6 +868,25 @@ class QirInstruction: ...
 class IdleNoiseParams:
     s_probability: float
 
+class LossPolicy(Enum):
+    """
+    Specifies the behavior of a multi-qubit gate when at least one of its
+    qubit operands is lost.
+    """
+
+    # If any operand of a gate is lost, skip the gate entirely.
+    SKIP: int
+    # If any operand of a gate is lost, propagate the loss to the other operands.
+    PROPAGATE: int
+    # For multi-qubit rotations, degrade the unitary to its single-qubit version
+    # on the surviving operand (e.g. rxx -> rx). Falls back to SKIP for gates with
+    # no single-qubit reduction (cx, cy, cz, swap, and single-qubit gates).
+    DEGRADE: int
+    # Skip the gate and instead apply an S adjoint to each surviving operand.
+    RESIDUAL_S_DAGGER: int
+    # Apply the unitary anyway, ignoring the loss.
+    APPLY_ANYWAY: int
+
 class NoiseTable:
     # Deprecated. Setting `loss` distributes the per-qubit loss probability
     # across the correlated loss fault strings ('L' for a single-qubit
@@ -876,6 +895,7 @@ class NoiseTable:
     # `loss` reconstructs that per-qubit probability. Prefer setting the loss
     # fault strings directly via `set_pauli_noise`.
     loss: float
+    on_loss: LossPolicy
 
     def __init__(self, num_qubits: int):
         """

source/qdk_package/qdk/simulation/__init__.py

@@ -15,6 +15,10 @@
   to individual gate intrinsics to model depolarizing, bit-flip, phase-flip,
   or correlated noise channels.
 
+- :class:`~qdk.simulation.LossPolicy` — selects how a gate behaves when one of
+  its qubit operands is lost. Assign it to a noise table's ``on_loss`` attribute
+  (e.g. ``noise.cx.on_loss = LossPolicy.SKIP``).
+
 - :func:`~qdk.simulation.run_qir` — simulates QIR as given in one of
   three backend simulators: clifford, gpu or cpu.
 
@@ -26,7 +30,7 @@
 """
 
 from .._device._atom import NeutralAtomDevice
-from ._simulation import NoiseConfig, run_qir
+from ._simulation import NoiseConfig, LossPolicy, run_qir
 from ._noisy_simulator import (
     NoisySimulatorError,
     DensityMatrixSimulator,
@@ -40,6 +44,7 @@
 __all__ = [
     "NeutralAtomDevice",
     "NoiseConfig",
+    "LossPolicy",
     "run_qir",
     "NoisySimulatorError",
     "Operation",

source/qdk_package/qdk/simulation/_simulation.py

@@ -15,6 +15,7 @@
     run_cpu_adaptive,
     run_cpu_full_state,
     NoiseConfig,
+    LossPolicy,
     GpuContext,
     try_create_gpu_adapter,
     Result,

source/qdk_package/src/interpreter.rs

@@ -23,7 +23,7 @@ use crate::{
     },
     noisy_simulator::register_noisy_simulator_submodule,
     qir_simulation::{
-        IdleNoiseParams, NoiseConfig, NoiseTable, QirInstruction, QirInstructionId,
+        IdleNoiseParams, LossPolicy, NoiseConfig, NoiseTable, QirInstruction, QirInstructionId,
         cpu_simulators::{
             run_clifford, run_clifford_adaptive, run_cpu_adaptive, run_cpu_full_state,
         },
@@ -104,6 +104,7 @@ fn verify_classes_are_sendable() {
     is_send::<NoiseConfig>();
     is_send::<NoiseTable>();
     is_send::<IdleNoiseParams>();
+    is_send::<LossPolicy>();
 }
 
 #[pymodule]
@@ -133,6 +134,7 @@ fn _native<'a>(py: Python<'a>, m: &Bound<'a, PyModule>) -> PyResult<()> {
     m.add_class::<NoiseConfig>()?;
     m.add_class::<NoiseTable>()?;
     m.add_class::<IdleNoiseParams>()?;
+    m.add_class::<LossPolicy>()?;
     m.add_function(wrap_pyfunction!(physical_estimates, m)?)?;
     m.add_function(wrap_pyfunction!(run_clifford, m)?)?;
     m.add_function(wrap_pyfunction!(try_create_gpu_adapter, m)?)?;

source/qdk_package/src/qir_simulation.rs

@@ -9,7 +9,7 @@ use crate::qir_simulation::correlated_noise::parse_noise_table;
 
 use num_traits::{Float, Unsigned};
 use pyo3::{
-    Bound, FromPyObject, Py, PyRef, PyResult, Python,
+    Bound, FromPyObject, Py, PyAny, PyRef, PyResult, Python,
     exceptions::{PyAttributeError, PyKeyError, PyTypeError, PyValueError},
     pybacked::PyBackedStr,
     pyclass, pymethods,
@@ -88,6 +88,47 @@ pub enum QirInstruction {
     ),
 }
 
+/// Specifies the behavior of a multi-qubit gate when at least one of its
+/// qubit operands is lost. Mirrors [`qdk_simulators::noise_config::LossPolicy`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[pyclass(eq, eq_int, from_py_object, module = "qdk._native")]
+pub enum LossPolicy {
+    #[pyo3(name = "SKIP")]
+    Skip = 0,
+    #[pyo3(name = "PROPAGATE")]
+    Propagate = 1,
+    #[pyo3(name = "DEGRADE")]
+    Degrade = 2,
+    #[pyo3(name = "RESIDUAL_S_DAGGER")]
+    ResidualSDagger = 3,
+    #[pyo3(name = "APPLY_ANYWAY")]
+    ApplyAnyway = 4,
+}
+
+impl From<LossPolicy> for qdk_simulators::noise_config::LossPolicy {
+    fn from(value: LossPolicy) -> Self {
+        match value {
+            LossPolicy::Skip => Self::Skip,
+            LossPolicy::Propagate => Self::Propagate,
+            LossPolicy::Degrade => Self::Degrade,
+            LossPolicy::ResidualSDagger => Self::ResidualSDagger,
+            LossPolicy::ApplyAnyway => Self::ApplyAnyway,
+        }
+    }
+}
+
+impl From<qdk_simulators::noise_config::LossPolicy> for LossPolicy {
+    fn from(value: qdk_simulators::noise_config::LossPolicy) -> Self {
+        match value {
+            qdk_simulators::noise_config::LossPolicy::Skip => Self::Skip,
+            qdk_simulators::noise_config::LossPolicy::Propagate => Self::Propagate,
+            qdk_simulators::noise_config::LossPolicy::Degrade => Self::Degrade,
+            qdk_simulators::noise_config::LossPolicy::ResidualSDagger => Self::ResidualSDagger,
+            qdk_simulators::noise_config::LossPolicy::ApplyAnyway => Self::ApplyAnyway,
+        }
+    }
+}
+
 #[derive(Debug)]
 #[pyclass(module = "qdk._native")]
 pub struct NoiseConfig {
@@ -357,6 +398,8 @@ impl From<qdk_simulators::noise_config::IdleNoiseParams> for IdleNoiseParams {
 #[pyclass(from_py_object, module = "qdk._native")]
 pub struct NoiseTable {
     qubits: u32,
+    #[pyo3(get)]
+    pub on_loss: LossPolicy,
     pauli_noise: FxHashMap<PauliAndLossString, Probability>,
 }
 
@@ -522,6 +565,7 @@ impl NoiseTable {
         NoiseTable {
             qubits: num_qubits,
             pauli_noise: FxHashMap::default(),
+            on_loss: LossPolicy::Skip,
         }
     }
 
@@ -553,11 +597,22 @@ E.g.: `noise_config.cz.IL`"
     ///
     /// for arbitrary pauli fields. Setting an element that was
     /// previously set overrides that entry with the new value.
-    fn __setattr__(&mut self, name: &str, value: Probability) -> PyResult<()> {
-        if name == "loss" {
-            self.set_loss(value)
-        } else {
-            self.set_pauli_noise_elt(&name.to_uppercase(), value)
+    ///
+    /// The `on_loss` attribute is special-cased to accept a `LossPolicy`.
+    fn __setattr__(&mut self, name: &str, value: &Bound<'_, PyAny>) -> PyResult<()> {
+        match name {
+            "on_loss" => {
+                if self.qubits < 2 {
+                    Err(PyAttributeError::new_err(
+                        "Loss policies only apply to multi-qubit gates.".to_string(),
+                    ))
+                } else {
+                    self.on_loss = value.extract::<LossPolicy>()?;
+                    Ok(())
+                }
+            }
+            "loss" => self.set_loss(value.extract::<Probability>()?),
+            _ => self.set_pauli_noise_elt(&name.to_uppercase(), value.extract::<Probability>()?),
         }
     }
 
@@ -649,6 +704,7 @@ impl<T: Float> From<NoiseTable> for qdk_simulators::noise_config::NoiseTable<T>
             qubits: value.qubits,
             pauli_strings,
             probabilities,
+            on_loss: value.on_loss.into(),
         }
     }
 }
@@ -667,6 +723,7 @@ fn from_noise_table_ref<T: Float>(
         qubits: value.qubits,
         pauli_strings,
         probabilities,
+        on_loss: value.on_loss.into(),
     }
 }
 
@@ -686,6 +743,7 @@ impl<T: Float> From<qdk_simulators::noise_config::NoiseTable<T>> for NoiseTable
         NoiseTable {
             qubits: value.qubits,
             pauli_noise,
+            on_loss: value.on_loss.into(),
         }
     }
 }

source/qdk_package/src/qir_simulation/correlated_noise.rs

@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use std::fmt;
 use std::str::FromStr;
 
-use crate::qir_simulation::NoiseTable;
+use crate::qir_simulation::{LossPolicy, NoiseTable};
 
 /// Errors that can occur while parsing a noise-table CSV.
 #[derive(Debug)]
@@ -84,6 +84,7 @@ pub fn parse_noise_table(contents: &str) -> Result<NoiseTable, ParseError> {
         return Ok(NoiseTable {
             qubits: qubits.unwrap_or(0),
             pauli_noise,
+            on_loss: LossPolicy::Skip,
         });
     }
 
@@ -156,6 +157,7 @@ pub fn parse_noise_table(contents: &str) -> Result<NoiseTable, ParseError> {
     Ok(NoiseTable {
         qubits,
         pauli_noise,
+        on_loss: LossPolicy::Skip,
     })
 }