Struct TwoQubitOptimization 

pub struct TwoQubitOptimization { /* private fields */ }

Two-qubit gate optimization

Implementations

impl TwoQubitOptimization

pub fn new(use_kak_decomposition: bool, optimize_cnots: bool) -> Self

Examples found in repository

examples/optimization_demo.rs (line 231)

fn benchmark_optimization_passes(circuit: &Circuit<4>) {
    println!("\nDemo 5: Pass Benchmarking");
    println!("-------------------------");

    // Benchmark individual passes
    let passes: Vec<(&str, Box<dyn OptimizationPass>)> = vec![
        ("Gate Cancellation", Box::new(GateCancellation::new(false))),
        ("Rotation Merging", Box::new(RotationMerging::new(1e-10))),
        ("Gate Commutation", Box::new(GateCommutation::new(5))),
        ("Template Matching", Box::new(TemplateMatching::new())),
        (
            "Two-Qubit Opt",
            Box::new(TwoQubitOptimization::new(false, true)),
        ),
    ];

    let cost_model = AbstractCostModel::default();

    for (name, pass) in passes {
        let start = Instant::now();

        match pass.apply(circuit, &cost_model) {
            Ok(_) => {
                let duration = start.elapsed();
                println!("  {}: {:?}", name, duration);
            }
            Err(e) => {
                println!("  {} failed: {:?}", name, e);
            }
        }
    }

    // Benchmark full optimization
    println!("\nFull Optimization Benchmark:");
    let start = Instant::now();
    let mut optimizer = CircuitOptimizer2::<4>::with_level(OptimizationLevel::Heavy);

    match optimizer.optimize(circuit) {
        Ok(report) => {
            let duration = start.elapsed();
            println!("  Total time: {:?}", duration);
            println!(
                "  Gates reduced: {} → {}",
                report.initial_metrics.gate_count, report.final_metrics.gate_count
            );

            // Show detailed report
            println!("\nDetailed Report:");
            println!("{}", report.detailed_report());
        }
        Err(e) => {
            println!("  Benchmark failed: {:?}", e);
        }
    }
}

Trait Implementations

impl OptimizationPass for TwoQubitOptimization

fn name(&self) -> &str

Name of the optimization pass

fn apply_to_gates( &self, gates: Vec<Box<dyn GateOp>>, _cost_model: &dyn CostModel, ) -> QuantRS2Result<Vec<Box<dyn GateOp>>>

Apply the optimization pass to a gate list

fn should_apply(&self) -> bool

Check if this pass should be applied