Struct NoiseModel 

pub struct NoiseModel {
    pub single_qubit_errors: HashMap<usize, f64>,
    pub two_qubit_errors: HashMap<(usize, usize), f64>,
    pub t1_times: HashMap<usize, f64>,
    pub t2_times: HashMap<usize, f64>,
    pub readout_fidelities: HashMap<usize, f64>,
    pub gate_times: HashMap<String, f64>,
    pub crosstalk_matrix: Option<Vec<Vec<f64>>>,
}

Noise model for quantum devices

Fields

single_qubit_errors: HashMap<usize, f64>

Single-qubit gate error rates (per qubit)

two_qubit_errors: HashMap<(usize, usize), f64>

Two-qubit gate error rates (per qubit pair)

t1_times: HashMap<usize, f64>

T1 coherence times (microseconds)

t2_times: HashMap<usize, f64>

T2 coherence times (microseconds)

readout_fidelities: HashMap<usize, f64>

Readout fidelities

gate_times: HashMap<String, f64>

Gate execution times (nanoseconds)

crosstalk_matrix: Option<Vec<Vec<f64>>>

Crosstalk matrix

Implementations

impl NoiseModel

pub fn new() -> Self

Create a new empty noise model

Examples found in repository

examples/noise_optimization_demo.rs (line 197)

fn demo_fidelity_comparison() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Fidelity Comparison Across Noise Models ---");

    // Create circuits of different complexity
    let circuits = vec![
        create_simple_circuit()?,
        create_medium_circuit()?,
        create_complex_circuit()?,
    ];

    let noise_models = vec![
        ("Ideal", NoiseModel::new()),
        ("Uniform", NoiseModel::uniform(4)),
        ("IBM-like", NoiseModel::ibm_like(4)),
    ];

    println!(
        "{:<12} {:<8} {:<8} {:<8}",
        "Circuit", "Ideal", "Uniform", "IBM-like"
    );
    println!("{:-<40}", "");

    for (i, circuit) in circuits.iter().enumerate() {
        let circuit_name = match i {
            0 => "Simple",
            1 => "Medium",
            2 => "Complex",
            _ => "Unknown",
        };

        print!("{:<12}", circuit_name);

        for (_, noise_model) in &noise_models {
            let optimizer = NoiseAwareOptimizer::new(noise_model.clone());
            let fidelity = optimizer.estimate_fidelity(circuit);
            print!(" {:<8.4}", fidelity);
        }
        println!();
    }

    println!();
    Ok(())
}

pub fn uniform(num_qubits: usize) -> Self

Create a uniform noise model for testing

Examples found in repository

examples/noise_optimization_demo.rs (line 47)

fn demo_uniform_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Uniform Noise Model ---");

    let noise_model = NoiseModel::uniform(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone());

    println!("Noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate: {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  T1 time: {:.1} μs", noise_model.t1_time(0));
    println!("  T2 time: {:.1} μs", noise_model.t2_time(0));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    if optimized_fidelity > original_fidelity {
        println!(
            "✓ Fidelity improved by {:.4}",
            optimized_fidelity - original_fidelity
        );
    } else {
        println!("→ No fidelity improvement (circuit already optimal)");
    }

    println!();
    Ok(())
}

fn demo_ibm_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- IBM-like Noise Model ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone()).with_coupling_map(coupling_map);

    println!("IBM-like noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate (adjacent): {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  Hadamard gate time: {:.1} ns", noise_model.gate_time("H"));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    println!("Available optimization passes:");
    for pass in optimizer.get_passes() {
        println!("  - {}", pass.name());
    }

    println!();
    Ok(())
}

fn demo_noise_aware_cost_model(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Noise-Aware Cost Analysis ---");

    let uniform_noise = NoiseModel::uniform(4);
    let ibm_noise = NoiseModel::ibm_like(4);

    let uniform_cost_model = NoiseAwareCostModel::new(uniform_noise);
    let ibm_cost_model = NoiseAwareCostModel::new(ibm_noise);

    let uniform_cost = uniform_cost_model.circuit_cost(circuit);
    let ibm_cost = ibm_cost_model.circuit_cost(circuit);

    println!("Circuit costs with different noise models:");
    println!("  Uniform noise model: {:.2}", uniform_cost);
    println!("  IBM-like noise model: {:.2}", ibm_cost);

    // Analyze individual gate costs
    println!("\nGate-by-gate cost analysis (IBM model):");
    for (i, gate) in circuit.gates().iter().enumerate() {
        let gate_cost = ibm_cost_model.gate_cost(gate.as_ref());
        println!("  Gate {}: {} - Cost: {:.2}", i, gate.name(), gate_cost);
    }

    println!();
    Ok(())
}

fn demo_noise_optimization_passes(
    circuit: &Circuit<4>,
) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Individual Optimization Passes ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);

    // Test coherence optimization
    let coherence_opt = CoherenceOptimization::new(noise_model.clone());
    let cost_model = NoiseAwareCostModel::new(noise_model.clone());

    if coherence_opt.should_apply() {
        let coherence_result = coherence_opt.apply(circuit, &cost_model)?;
        println!("✓ Coherence optimization applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After coherence opt: {}", coherence_result.num_gates());
    }

    // Test noise-aware mapping
    let mapping_opt = NoiseAwareMapping::new(noise_model.clone(), coupling_map.clone());
    if mapping_opt.should_apply() {
        let mapping_result = mapping_opt.apply(circuit, &cost_model)?;
        println!("✓ Noise-aware mapping applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After mapping opt: {}", mapping_result.num_gates());
    }

    // Test dynamical decoupling
    let dd_opt = DynamicalDecoupling::new(noise_model.clone());
    if dd_opt.should_apply() {
        let dd_result = dd_opt.apply(circuit, &cost_model)?;
        println!("✓ Dynamical decoupling applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After DD insertion: {}", dd_result.num_gates());
    }

    println!();
    Ok(())
}

fn demo_fidelity_comparison() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Fidelity Comparison Across Noise Models ---");

    // Create circuits of different complexity
    let circuits = vec![
        create_simple_circuit()?,
        create_medium_circuit()?,
        create_complex_circuit()?,
    ];

    let noise_models = vec![
        ("Ideal", NoiseModel::new()),
        ("Uniform", NoiseModel::uniform(4)),
        ("IBM-like", NoiseModel::ibm_like(4)),
    ];

    println!(
        "{:<12} {:<8} {:<8} {:<8}",
        "Circuit", "Ideal", "Uniform", "IBM-like"
    );
    println!("{:-<40}", "");

    for (i, circuit) in circuits.iter().enumerate() {
        let circuit_name = match i {
            0 => "Simple",
            1 => "Medium",
            2 => "Complex",
            _ => "Unknown",
        };

        print!("{:<12}", circuit_name);

        for (_, noise_model) in &noise_models {
            let optimizer = NoiseAwareOptimizer::new(noise_model.clone());
            let fidelity = optimizer.estimate_fidelity(circuit);
            print!(" {:<8.4}", fidelity);
        }
        println!();
    }

    println!();
    Ok(())
}

pub fn ibm_like(num_qubits: usize) -> Self

Create a realistic noise model based on IBM devices

Examples found in repository

examples/noise_optimization_demo.rs (line 86)

fn demo_ibm_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- IBM-like Noise Model ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone()).with_coupling_map(coupling_map);

    println!("IBM-like noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate (adjacent): {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  Hadamard gate time: {:.1} ns", noise_model.gate_time("H"));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    println!("Available optimization passes:");
    for pass in optimizer.get_passes() {
        println!("  - {}", pass.name());
    }

    println!();
    Ok(())
}

fn demo_noise_aware_cost_model(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Noise-Aware Cost Analysis ---");

    let uniform_noise = NoiseModel::uniform(4);
    let ibm_noise = NoiseModel::ibm_like(4);

    let uniform_cost_model = NoiseAwareCostModel::new(uniform_noise);
    let ibm_cost_model = NoiseAwareCostModel::new(ibm_noise);

    let uniform_cost = uniform_cost_model.circuit_cost(circuit);
    let ibm_cost = ibm_cost_model.circuit_cost(circuit);

    println!("Circuit costs with different noise models:");
    println!("  Uniform noise model: {:.2}", uniform_cost);
    println!("  IBM-like noise model: {:.2}", ibm_cost);

    // Analyze individual gate costs
    println!("\nGate-by-gate cost analysis (IBM model):");
    for (i, gate) in circuit.gates().iter().enumerate() {
        let gate_cost = ibm_cost_model.gate_cost(gate.as_ref());
        println!("  Gate {}: {} - Cost: {:.2}", i, gate.name(), gate_cost);
    }

    println!();
    Ok(())
}

fn demo_noise_optimization_passes(
    circuit: &Circuit<4>,
) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Individual Optimization Passes ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);

    // Test coherence optimization
    let coherence_opt = CoherenceOptimization::new(noise_model.clone());
    let cost_model = NoiseAwareCostModel::new(noise_model.clone());

    if coherence_opt.should_apply() {
        let coherence_result = coherence_opt.apply(circuit, &cost_model)?;
        println!("✓ Coherence optimization applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After coherence opt: {}", coherence_result.num_gates());
    }

    // Test noise-aware mapping
    let mapping_opt = NoiseAwareMapping::new(noise_model.clone(), coupling_map.clone());
    if mapping_opt.should_apply() {
        let mapping_result = mapping_opt.apply(circuit, &cost_model)?;
        println!("✓ Noise-aware mapping applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After mapping opt: {}", mapping_result.num_gates());
    }

    // Test dynamical decoupling
    let dd_opt = DynamicalDecoupling::new(noise_model.clone());
    if dd_opt.should_apply() {
        let dd_result = dd_opt.apply(circuit, &cost_model)?;
        println!("✓ Dynamical decoupling applied");
        println!("  Original gates: {}", circuit.num_gates());
        println!("  After DD insertion: {}", dd_result.num_gates());
    }

    println!();
    Ok(())
}

fn demo_fidelity_comparison() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Fidelity Comparison Across Noise Models ---");

    // Create circuits of different complexity
    let circuits = vec![
        create_simple_circuit()?,
        create_medium_circuit()?,
        create_complex_circuit()?,
    ];

    let noise_models = vec![
        ("Ideal", NoiseModel::new()),
        ("Uniform", NoiseModel::uniform(4)),
        ("IBM-like", NoiseModel::ibm_like(4)),
    ];

    println!(
        "{:<12} {:<8} {:<8} {:<8}",
        "Circuit", "Ideal", "Uniform", "IBM-like"
    );
    println!("{:-<40}", "");

    for (i, circuit) in circuits.iter().enumerate() {
        let circuit_name = match i {
            0 => "Simple",
            1 => "Medium",
            2 => "Complex",
            _ => "Unknown",
        };

        print!("{:<12}", circuit_name);

        for (_, noise_model) in &noise_models {
            let optimizer = NoiseAwareOptimizer::new(noise_model.clone());
            let fidelity = optimizer.estimate_fidelity(circuit);
            print!(" {:<8.4}", fidelity);
        }
        println!();
    }

    println!();
    Ok(())
}

pub fn single_qubit_error(&self, qubit: usize) -> f64

Get error rate for a single-qubit gate

Examples found in repository

examples/noise_optimization_demo.rs (line 53)

fn demo_uniform_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Uniform Noise Model ---");

    let noise_model = NoiseModel::uniform(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone());

    println!("Noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate: {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  T1 time: {:.1} μs", noise_model.t1_time(0));
    println!("  T2 time: {:.1} μs", noise_model.t2_time(0));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    if optimized_fidelity > original_fidelity {
        println!(
            "✓ Fidelity improved by {:.4}",
            optimized_fidelity - original_fidelity
        );
    } else {
        println!("→ No fidelity improvement (circuit already optimal)");
    }

    println!();
    Ok(())
}

fn demo_ibm_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- IBM-like Noise Model ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone()).with_coupling_map(coupling_map);

    println!("IBM-like noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate (adjacent): {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  Hadamard gate time: {:.1} ns", noise_model.gate_time("H"));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    println!("Available optimization passes:");
    for pass in optimizer.get_passes() {
        println!("  - {}", pass.name());
    }

    println!();
    Ok(())
}

pub fn two_qubit_error(&self, q1: usize, q2: usize) -> f64

Get error rate for a two-qubit gate

Examples found in repository

examples/noise_optimization_demo.rs (line 57)

fn demo_uniform_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Uniform Noise Model ---");

    let noise_model = NoiseModel::uniform(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone());

    println!("Noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate: {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  T1 time: {:.1} μs", noise_model.t1_time(0));
    println!("  T2 time: {:.1} μs", noise_model.t2_time(0));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    if optimized_fidelity > original_fidelity {
        println!(
            "✓ Fidelity improved by {:.4}",
            optimized_fidelity - original_fidelity
        );
    } else {
        println!("→ No fidelity improvement (circuit already optimal)");
    }

    println!();
    Ok(())
}

fn demo_ibm_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- IBM-like Noise Model ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone()).with_coupling_map(coupling_map);

    println!("IBM-like noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate (adjacent): {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  Hadamard gate time: {:.1} ns", noise_model.gate_time("H"));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    println!("Available optimization passes:");
    for pass in optimizer.get_passes() {
        println!("  - {}", pass.name());
    }

    println!();
    Ok(())
}

pub fn t1_time(&self, qubit: usize) -> f64

Get T1 time for a qubit

Examples found in repository

examples/noise_optimization_demo.rs (line 59)

fn demo_uniform_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Uniform Noise Model ---");

    let noise_model = NoiseModel::uniform(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone());

    println!("Noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate: {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  T1 time: {:.1} μs", noise_model.t1_time(0));
    println!("  T2 time: {:.1} μs", noise_model.t2_time(0));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    if optimized_fidelity > original_fidelity {
        println!(
            "✓ Fidelity improved by {:.4}",
            optimized_fidelity - original_fidelity
        );
    } else {
        println!("→ No fidelity improvement (circuit already optimal)");
    }

    println!();
    Ok(())
}

pub fn t2_time(&self, qubit: usize) -> f64

Get T2 time for a qubit

Examples found in repository

examples/noise_optimization_demo.rs (line 60)

fn demo_uniform_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Uniform Noise Model ---");

    let noise_model = NoiseModel::uniform(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone());

    println!("Noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate: {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  T1 time: {:.1} μs", noise_model.t1_time(0));
    println!("  T2 time: {:.1} μs", noise_model.t2_time(0));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    if optimized_fidelity > original_fidelity {
        println!(
            "✓ Fidelity improved by {:.4}",
            optimized_fidelity - original_fidelity
        );
    } else {
        println!("→ No fidelity improvement (circuit already optimal)");
    }

    println!();
    Ok(())
}

pub fn gate_time(&self, gate_name: &str) -> f64

Get gate execution time

Examples found in repository

examples/noise_optimization_demo.rs (line 61)

fn demo_uniform_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Uniform Noise Model ---");

    let noise_model = NoiseModel::uniform(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone());

    println!("Noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate: {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  T1 time: {:.1} μs", noise_model.t1_time(0));
    println!("  T2 time: {:.1} μs", noise_model.t2_time(0));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    if optimized_fidelity > original_fidelity {
        println!(
            "✓ Fidelity improved by {:.4}",
            optimized_fidelity - original_fidelity
        );
    } else {
        println!("→ No fidelity improvement (circuit already optimal)");
    }

    println!();
    Ok(())
}

fn demo_ibm_noise(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- IBM-like Noise Model ---");

    let noise_model = NoiseModel::ibm_like(4);
    let coupling_map = CouplingMap::linear(4);
    let optimizer = NoiseAwareOptimizer::new(noise_model.clone()).with_coupling_map(coupling_map);

    println!("IBM-like noise characteristics:");
    println!(
        "  Single-qubit error rate: {:.2e}",
        noise_model.single_qubit_error(0)
    );
    println!(
        "  Two-qubit error rate (adjacent): {:.2e}",
        noise_model.two_qubit_error(0, 1)
    );
    println!("  Hadamard gate time: {:.1} ns", noise_model.gate_time("H"));
    println!("  CNOT gate time: {:.1} ns", noise_model.gate_time("CNOT"));

    let original_fidelity = optimizer.estimate_fidelity(circuit);
    println!("\nOriginal circuit fidelity: {:.4}", original_fidelity);

    let optimized = optimizer.optimize(circuit)?;
    let optimized_fidelity = optimizer.estimate_fidelity(&optimized);
    println!("Optimized circuit fidelity: {:.4}", optimized_fidelity);

    println!("Available optimization passes:");
    for pass in optimizer.get_passes() {
        println!("  - {}", pass.name());
    }

    println!();
    Ok(())
}

pub fn gate_error_probability(&self, gate: &dyn GateOp) -> f64

Calculate error probability for a gate

Trait Implementations

impl Clone for NoiseModel

fn clone(&self) -> NoiseModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NoiseModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NoiseModel

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NoiseModel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NoiseModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.