Improved noise model

src/lib.rs

@@ -1,19 +1,21 @@
 uniffi::include_scaffolding!("qsharp-bridge");
 
-use crate::sim::qir;
+use crate::noise::Noise;
+use crate::noise::PauliNoiseDistribution;
+use crate::qasm::QasmGenerationOptions;
+use crate::qasm::QasmResetBehavior;
+use crate::qasm::qasm2;
+use crate::qasm::qasm2_expression;
+use crate::sim::ExecutionOptions;
+use crate::sim::ExecutionState;
+use crate::sim::QsError;
+use crate::sim::QubitState;
 use crate::sim::estimate;
 use crate::sim::estimate_expression;
-use crate::sim::qasm2;
-use crate::sim::qasm2_expression;
+use crate::sim::qir;
 use crate::sim::run_qs;
 use crate::sim::run_qs_with_options;
-use crate::sim::ExecutionState;
-use crate::sim::QsError;
-use crate::sim::QubitState;
-use crate::sim::ExecutionOptions;
-use crate::sim::PauliDistribution;
-use crate::qasm::QasmGenerationOptions;
-use crate::qasm::QasmResetBehavior;
 
+pub mod noise;
+pub mod qasm;
 pub mod sim;
-pub mod qasm;

src/noise.rs

@@ -0,0 +1,56 @@
+use crate::sim::QsError;
+
+#[derive(Debug, Clone)]
+pub enum Noise {
+    Ideal,
+    Pauli {
+        noise: PauliNoiseDistribution,
+    },
+    BitFlip {
+        p: f64,
+    },
+    PhaseFlip {
+        p: f64,
+    },
+    Depolarizing {
+        p: f64,
+    },
+}
+
+impl Noise {
+    pub fn to_distribution(&self) -> Result<PauliNoiseDistribution, QsError> {
+        match self {
+            Noise::Ideal => PauliNoiseDistribution::new(0.0, 0.0, 0.0),
+            Noise::Pauli { noise } => Ok(noise.clone()),
+            Noise::BitFlip { p } => PauliNoiseDistribution::new(*p, 0.0, 0.0),
+            Noise::PhaseFlip { p } => PauliNoiseDistribution::new(0.0, 0.0, *p),
+            Noise::Depolarizing { p } => PauliNoiseDistribution::new(*p / 3.0, *p / 3.0, *p / 3.0),
+        }
+    }
+}
+
+impl Default for Noise {
+    fn default() -> Self {
+        Noise::Ideal
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PauliNoiseDistribution {
+    pub x: f64,
+    pub y: f64,
+    pub z: f64,
+}
+
+impl PauliNoiseDistribution {
+    pub fn new(x: f64, y: f64, z: f64) -> Result<Self, QsError> {
+        if x < 0.0 || y < 0.0 || z < 0.0 || x + y + z > 1.0 {
+            return Err(QsError::ErrorMessage {
+                error_text:
+                    "Invalid Pauli distribution: values must be non-negative and sum to <= 1.0"
+                        .to_string(),
+            });
+        }
+        Ok(Self { x, y, z })
+    }
+}

src/qasm.rs

@@ -1,7 +1,33 @@
 use std::collections::HashSet;
 use num_bigint::BigUint;
 use num_complex::Complex;
-use qsc::{interpret::Value, Backend};
+use qsc::{interpret::{GenericReceiver, Value}, Backend, PackageType, TargetCapabilityFlags};
+
+use crate::sim::{create_interpreter, QsError};
+
+pub fn qasm2(source: &str, generation_options: QasmGenerationOptions) -> Result<String, QsError> {
+    let mut stdout = vec![];
+    let mut out = GenericReceiver::new(&mut stdout);
+    let mut backend = Qasm2Backend::new(generation_options);
+
+    let mut interpreter = create_interpreter(Some(source), PackageType::Exe, TargetCapabilityFlags::empty())?;
+    let _ = interpreter.eval_entry_with_sim(&mut backend, &mut out)?;
+
+    let qasm = backend.get_qasm().map_err(|errors| QsError::ErrorMessage { error_text: errors.join(", ") })?;
+    Ok(qasm)
+}
+
+pub fn qasm2_expression(expression: &str, generation_options: QasmGenerationOptions) -> Result<String, QsError> {
+    let mut stdout = vec![];
+    let mut out = GenericReceiver::new(&mut stdout);
+    let mut backend = Qasm2Backend::new(generation_options);
+
+    let mut interpreter = create_interpreter(None, PackageType::Lib, TargetCapabilityFlags::empty())?;
+    let _ = interpreter.run_with_sim(&mut backend, &mut out, Some(expression))?;
+
+    let qasm = backend.get_qasm().map_err(|errors| QsError::ErrorMessage { error_text: errors.join(", ") })?;
+    Ok(qasm)
+}
 
 pub(crate) struct Qasm2Backend {
     code: Vec<String>,

src/qsharp-bridge.udl

@@ -33,20 +33,32 @@ enum QasmResetBehavior {
     "Error"
 };
 
-dictionary PauliDistribution {
+[Enum]
+interface Noise {
+    Ideal();
+    Pauli(PauliNoiseDistribution noise);
+    BitFlip(f64 p);
+    PhaseFlip(f64 p);
+    Depolarizing(f64 p);
+};
+
+dictionary PauliNoiseDistribution {
     f64 x;
     f64 y;
     f64 z;
 };
 
 interface ExecutionOptions {
-    constructor(u32 shots, PauliDistribution noise);
+    constructor(u32 shots, Noise noise, f64? qubit_loss);
 
     [Name=from_shots]
     constructor(u32 shots);
 
     [Name=from_noise]
-    constructor(PauliDistribution noise);
+    constructor(Noise noise);
+
+    [Name=from_qubit_loss]
+    constructor(f64 qubit_loss);
 };
 
 [Error]