Struct TemplateMatching 

pub struct TemplateMatching { /* private fields */ }

Template matching optimization

Implementations

impl TemplateMatching

pub fn new() -> Self

Examples found in repository

examples/optimization_demo.rs (line 151)

fn demo_custom_optimization(circuit: &Circuit<4>) {
    println!("\nDemo 3: Custom Optimization Pipeline");
    println!("------------------------------------");

    // Create a custom pass manager
    let mut pass_manager = PassManager::new();

    // Configure with specific passes
    let config = PassConfig {
        max_iterations: 5,
        aggressive: true,
        level: OptimizationLevel::Custom,
        ..Default::default()
    };
    pass_manager.configure(config.clone());

    // Add specific passes in a custom order
    pass_manager.add_pass(Box::new(GateCancellation::new(true)));
    pass_manager.add_pass(Box::new(RotationMerging::new(1e-10)));
    pass_manager.add_pass(Box::new(GateCommutation::new(10)));
    pass_manager.add_pass(Box::new(TemplateMatching::new()));

    // Create optimizer with custom configuration
    let mut optimizer = CircuitOptimizer2::<4>::new();
    optimizer.configure(config);

    match optimizer.optimize(circuit) {
        Ok(report) => {
            println!("Custom optimization results:");
            report.print_summary();
        }
        Err(e) => {
            println!("Custom optimization failed: {:?}", e);
        }
    }
}

fn demo_gate_properties() {
    println!("\nDemo 4: Gate Properties");
    println!("-----------------------");

    // Show properties of various gates
    let gates = vec!["H", "X", "CNOT", "Toffoli"];

    for gate_name in gates {
        let props = match gate_name {
            "H" | "X" => GateProperties::single_qubit(gate_name),
            "CNOT" => GateProperties::two_qubit(gate_name),
            "Toffoli" => GateProperties::multi_qubit(gate_name, 3),
            _ => continue,
        };

        println!("\n{} Gate Properties:", gate_name);
        println!("  Native: {}", props.is_native);
        println!("  Duration: {:.1} ns", props.cost.duration_ns);
        println!("  Error rate: {:.6}", props.error.error_rate);
        println!("  Self-inverse: {}", props.is_self_inverse);
        println!("  Diagonal: {}", props.is_diagonal);
        println!("  Decompositions: {}", props.decompositions.len());
    }

    // Show commutation relations
    println!("\nCommutation Relations:");
    let comm_table = CommutationTable::new();

    let gate_pairs = vec![
        ("X", "Y"),
        ("X", "Z"),
        ("Z", "Z"),
        ("Z", "RZ"),
        ("CNOT", "CNOT"),
    ];

    for (g1, g2) in gate_pairs {
        println!(
            "  {} ↔ {}: {}",
            g1,
            g2,
            if comm_table.commutes(g1, g2) {
                "✓"
            } else {
                "✗"
            }
        );
    }
    println!();
}

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);
        }
    }
}

pub fn with_templates(templates: Vec<CircuitTemplate>) -> Self

impl TemplateMatching

pub fn with_advanced_templates() -> Self

Create an advanced template matcher with more sophisticated patterns

pub fn for_hardware(hardware: &str) -> Self

Create a template matcher for specific hardware

Trait Implementations

impl Default for TemplateMatching

fn default() -> Self

Returns the “default value” for a type.

impl OptimizationPass for TemplateMatching

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