Polishing rng management in noise models

Author: ciaranra

crates/pecos-derive/Cargo.toml

@@ -10,3 +10,6 @@ proc-macro = true
 [dependencies]
 syn.workspace = true
 quote.workspace = true
+
+[dev-dependencies]
+syn = { version = "2", features = ["full"] }

crates/pecos-engines/examples/biased_measurement_example.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+
 use pecos_engines::Engine;
 use pecos_engines::byte_message::ByteMessage;
 use pecos_engines::engines::noise::BiasedMeasurementNoise;
@@ -16,12 +18,12 @@ fn main() {
     // Create a quantum engine with 1 qubit
     let quantum = Box::new(StateVecEngine::new(1));
 
-    example1_different_bias_levels(&circ, quantum.clone());
+    example1_different_bias_levels(&circ, &quantum);
     example2_with_seed(&circ);
     example3_bell_state();
 }
 
-fn example1_different_bias_levels(circ: &ByteMessage, quantum: Box<StateVecEngine>) {
+fn example1_different_bias_levels(circ: &ByteMessage, quantum: &StateVecEngine) {
     // === EXAMPLE 1: Different bias levels ===
     println!("Example 1: Testing different bias levels with 10,000 shots");
     println!("{:-^80}", "");
@@ -49,7 +51,7 @@ fn example1_different_bias_levels(circ: &ByteMessage, quantum: Box<StateVecEngin
     for (p_flip_0, p_flip_1, desc) in configs {
         // Create the biased measurement noise model
         let noise = Box::new(BiasedMeasurementNoise::new(p_flip_0, p_flip_1));
-        let mut system = QuantumSystem::new(noise, quantum.clone());
+        let mut system = QuantumSystem::new(noise, Box::new(quantum.clone()));
 
         // For deterministic testing, set a fixed seed
         system.set_seed(42).expect("Failed to set seed");
@@ -81,8 +83,10 @@ fn example1_different_bias_levels(circ: &ByteMessage, quantum: Box<StateVecEngin
         // For a 50/50 input with H gate:
         // Expected 0s = 50% * (1-p_flip_0) + 50% * p_flip_1
         // Expected 1s = 50% * p_flip_0 + 50% * (1-p_flip_1)
-        let expected_0 = ((50.0 * (1.0 - p_flip_0) + 50.0 * p_flip_1) as f64).round() as usize;
-        let expected_1 = ((50.0 * p_flip_0 + 50.0 * (1.0 - p_flip_1)) as f64).round() as usize;
+        let calc_0: f64 = 50.0 * (1.0 - p_flip_0) + 50.0 * p_flip_1;
+        let expected_0 = calc_0.round() as usize;
+        let calc_1: f64 = 50.0 * p_flip_0 + 50.0 * (1.0 - p_flip_1);
+        let expected_1 = calc_1.round() as usize;
 
         println!(
             "{:<30} | {:<10} | {:<10} | {:<10} | {:<10}",
@@ -131,8 +135,10 @@ fn example2_with_seed(circ: &ByteMessage) {
     // Calculate expected results for this configuration
     let p_flip_0 = 0.4;
     let p_flip_1 = 0.1;
-    let expected_0 = ((50.0 * (1.0 - p_flip_0) + 50.0 * p_flip_1) as f64).round() as usize;
-    let expected_1 = ((50.0 * p_flip_0 + 50.0 * (1.0 - p_flip_1)) as f64).round() as usize;
+    let calc_0: f64 = 50.0 * (1.0 - p_flip_0) + 50.0 * p_flip_1;
+    let expected_0 = calc_0.round() as usize;
+    let calc_1: f64 = 50.0 * p_flip_0 + 50.0 * (1.0 - p_flip_1);
+    let expected_1 = calc_1.round() as usize;
 
     println!("Builder pattern with p_flip_0 = 0.4, p_flip_1 = 0.1");
     println!("  Expected results: 0: {expected_0}%, 1: {expected_1}%");

crates/pecos-engines/examples/run_noisy_circ.rs

@@ -1,6 +1,6 @@
 use pecos_engines::byte_message::ByteMessage;
 use pecos_engines::engines::quantum::StateVecEngine;
-use pecos_engines::{Engine, GeneralDepolarizingNoise};
+use pecos_engines::{DepolarizingNoise, Engine};
 use pecos_engines::{EngineSystem, QuantumSystem};
 
 fn main() {
@@ -12,7 +12,7 @@ fn main() {
         .build();
 
     let quantum = Box::new(StateVecEngine::new(2));
-    let noise = Box::new(GeneralDepolarizingNoise::new(0.1, 0.1, 0.1, 0.1));
+    let noise = Box::new(DepolarizingNoise::new(0.1, 0.1, 0.1, 0.1));
 
     let mut system = QuantumSystem::new(noise, quantum);
 

crates/pecos-engines/src/core/shot_results.rs

@@ -212,9 +212,9 @@ impl fmt::Display for ShotResults {
 
             // Print any other keys (except measurement_ keys and result_X keys)
             for (key, value) in shot {
-                if !key.starts_with("measurement_") && 
+                if !key.starts_with("measurement_") &&
                    !key.starts_with("result_") &&  // Skip result_X keys
-                   key != "result" && 
+                   key != "result" &&
                    !key.starts_with('q')
                 {
                     if first {

crates/pecos-engines/src/engines/hybrid/builder.rs

@@ -137,7 +137,7 @@ impl HybridEngineBuilder {
     /// The builder for method chaining
     #[must_use]
     pub fn with_depolarizing_noise(mut self, probability: f64) -> Self {
-        self.noise_model = Some(Box::new(DepolarizingNoise::new_with_options(probability)));
+        self.noise_model = Some(Box::new(DepolarizingNoise::new_uniform(probability)));
         self.quantum_system = None; // Reset quantum_system as it's now invalid
         self
     }

crates/pecos-engines/src/engines/monte_carlo/builder.rs

@@ -237,7 +237,7 @@ impl MonteCarloEngineBuilder {
     /// The builder for method chaining
     #[must_use]
     pub fn with_depolarizing_noise(self, probability: f64) -> Self {
-        self.with_noise_model(Box::new(DepolarizingNoise::new_with_options(probability)))
+        self.with_noise_model(Box::new(DepolarizingNoise::new_uniform(probability)))
     }
 
     /// Set the quantum system

crates/pecos-engines/src/engines/monte_carlo/engine.rs

@@ -423,12 +423,12 @@ impl MonteCarloEngine {
             // If a seed is provided, create a noise model with the seed
             let noise_seed = derive_seed(s, "noise_model");
             DepolarizingNoiseBuilder::new()
-                .with_probability(p)
+                .with_uniform_probability(p)
                 .with_seed(noise_seed)
                 .build()
         } else {
             // Otherwise, create a noise model without a specific seed
-            Box::new(crate::engines::noise::DepolarizingNoise::new(p))
+            Box::new(crate::engines::noise::DepolarizingNoise::new_uniform(p))
         };
 
         // Create a quantum engine with the same number of qubits as the classical engine

crates/pecos-engines/src/engines/noise.rs

@@ -1,12 +1,16 @@
+//! Quantum noise models for realistic quantum computation simulation
+//!
+//! This module provides various noise models that can be used to simulate
+//! realistic quantum computation with errors. Each noise model implements
+//! the `NoiseModel` trait and can be used with the quantum engines.
+
 pub mod biased_measurement;
 pub mod depolarizing;
-pub mod general_depolarizing;
 pub mod pass_through;
 pub mod utils;
 
 pub use biased_measurement::BiasedMeasurementNoise;
 pub use depolarizing::DepolarizingNoise;
-pub use general_depolarizing::GeneralDepolarizingNoise;
 pub use pass_through::PassThroughNoise;
 pub use utils::{NoiseRng, NoiseUtils, ProbabilityValidator};
 
@@ -33,26 +37,8 @@ pub trait NoiseModel:
     + Send
     + Sync
     + Any
+    + RngManageable<Rng = ChaCha8Rng>
 {
-    /// Set a specific seed for the random number generator
-    ///
-    /// This method allows for deterministic behavior by setting a specific seed
-    /// for the random number generator used by the noise model.
-    ///
-    /// # Arguments
-    /// * `seed` - Seed value for the random number generator
-    ///
-    /// # Returns
-    /// Result indicating success or failure
-    ///
-    /// # Errors
-    /// Returns a `QueueError` if setting the seed fails
-    fn set_seed(&mut self, seed: u64) -> Result<(), QueueError> {
-        // Default implementation for noise models that don't use randomness
-        let _ = seed;
-        Ok(())
-    }
-
     /// Returns a reference to self as Any
     ///
     /// This allows for type-checking and downcasting without requiring
@@ -136,12 +122,10 @@ impl RngManageable for BaseNoiseModel {
     }
 
     fn rng(&self) -> &Self::Rng {
-        // Delegate to the NoiseRng implementation, which will panic
         self.rng.rng()
     }
 
     fn rng_mut(&mut self) -> &mut Self::Rng {
-        // Delegate to the NoiseRng implementation, which will panic
         self.rng.rng_mut()
     }
 }
@@ -188,7 +172,6 @@ mod tests {
     use super::*;
     use crate::byte_message::ByteMessageBuilder;
     use crate::engines::noise::biased_measurement::BiasedMeasurementNoise;
-    use crate::engines::noise::depolarizing::DepolarizingNoise;
 
     #[test]
     fn test_noise_model_biased_measurement() {
@@ -239,7 +222,7 @@ mod tests {
     #[test]
     fn test_noise_model_depolarizing() {
         // Create a depolarizing noise model
-        let mut noise_model = DepolarizingNoise::new(0.1);
+        let mut noise_model = DepolarizingNoise::new_uniform(0.1);
 
         // Create a quantum operation message
         let mut builder = ByteMessageBuilder::new();