Support NoiseConfig for Q# and OpenQASM on sparse simulation (#3062)

This change supports granular noise configuration for the mechanisms
that use sparse state simulator, namely `qsharp.run` and `openqasm.run`.
This brings it up to parity with our QIR-based simulation in the
`NeutralAtomDevice` on cpu and gpu (and clifford).

Author: swernli

Cargo.lock

@@ -15,6 +15,7 @@ log = { workspace = true }
 miette = { workspace = true }
 num-bigint = { workspace = true }
 num-complex = { workspace = true }
+qdk_simulators =  { path = "../../simulators" }
 qsc_codegen = { path = "../qsc_codegen" }
 qsc_data_structures = { path = "../qsc_data_structures" }
 qsc_doc_gen = { path = "../qsc_doc_gen" }

source/compiler/qsc/Cargo.toml

@@ -24,6 +24,7 @@ use debug::format_call_stack;
 use miette::Diagnostic;
 use num_bigint::BigUint;
 use num_complex::Complex;
+use qdk_simulators::noise_config::NoiseConfig;
 use qsc_circuit::{
     Circuit, CircuitTracer, TracerConfig,
     operations::{entry_expr_for_qubit_operation, qubit_param_info},
@@ -833,18 +834,28 @@ impl Interpreter {
 
     // Invokes the given callable with the given arguments using the current compilation but with a fresh
     // environment and simulator configured with the given noise, if any.
+    #[allow(clippy::too_many_arguments)]
     pub fn invoke_with_noise(
         &mut self,
         receiver: &mut impl Receiver,
         callable: Value,
         args: Value,
         noise: Option<PauliNoise>,
         qubit_loss: Option<f64>,
+        noise_config: Option<NoiseConfig<f64, f64>>,
         seed: Option<u64>,
     ) -> InterpretResult {
+        let qubit_loss = if noise_config.is_none() {
+            qubit_loss
+        } else {
+            None
+        };
         let mut sim = match noise {
             Some(noise) => SparseSim::new_with_noise(&noise),
-            None => SparseSim::new(),
+            None => match noise_config {
+                Some(config) => SparseSim::new_with_noise_config(config.into()),
+                None => SparseSim::new(),
+            },
         };
         if let Some(loss) = qubit_loss {
             sim.set_loss(loss);
@@ -863,11 +874,20 @@ impl Interpreter {
         expr: Option<&str>,
         noise: Option<PauliNoise>,
         qubit_loss: Option<f64>,
+        noise_config: Option<NoiseConfig<f64, f64>>,
         seed: Option<u64>,
     ) -> InterpretResult {
+        let qubit_loss = if noise_config.is_none() {
+            qubit_loss
+        } else {
+            None
+        };
         let mut sim = match noise {
             Some(noise) => SparseSim::new_with_noise(&noise),
-            None => SparseSim::new(),
+            None => match noise_config {
+                Some(config) => SparseSim::new_with_noise_config(config.into()),
+                None => SparseSim::new(),
+            },
         };
         if let Some(loss) = qubit_loss {
             sim.set_loss(loss);

source/compiler/qsc/src/interpret.rs

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