Struct ClassicalCondition 

pub struct ClassicalCondition {
    pub lhs: ClassicalValue,
    pub op: ComparisonOp,
    pub rhs: ClassicalValue,
}

A condition that gates execution based on classical values

Fields

lhs: ClassicalValue

Left-hand side of the comparison

op: ComparisonOp

Comparison operator

rhs: ClassicalValue

Right-hand side of the comparison

Implementations

impl ClassicalCondition

pub fn equals(lhs: ClassicalValue, rhs: ClassicalValue) -> Self

Create a new equality condition

Examples found in repository

examples/advanced_features_demo.rs (lines 127-130)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== QuantRS2 Circuit Advanced Features Demo ===\n");

    // 1. Basic circuit creation
    println!("1. Creating a basic quantum circuit:");
    let mut circuit = Circuit::<3>::new();
    circuit.add_gate(Hadamard { target: QubitId(0) })?;
    circuit.add_gate(CNOT {
        control: QubitId(0),
        target: QubitId(1),
    })?;
    circuit.add_gate(CNOT {
        control: QubitId(1),
        target: QubitId(2),
    })?;
    println!("   Circuit with {} gates created", circuit.gates().len());

    // 2. ZX-calculus optimization
    println!("\n2. ZX-calculus optimization:");
    let zx_optimizer = ZXOptimizer::new();
    let zx_diagram = zx_optimizer.circuit_to_zx(&circuit)?;
    println!(
        "   ZX diagram with {} nodes created",
        zx_diagram.nodes.len()
    );

    // 3. SciRS2 graph analysis
    println!("\n3. SciRS2 graph analysis:");
    let mut analyzer = SciRS2CircuitAnalyzer::new();
    let analysis = analyzer.analyze_circuit(&circuit)?;
    println!(
        "   Graph metrics: {} nodes, {} edges",
        analysis.metrics.num_nodes, analysis.metrics.num_edges
    );
    println!("   Communities detected: {}", analysis.communities.len());

    // 4. ML-based optimization
    println!("\n4. ML-based circuit optimization:");
    let ml_strategy = MLStrategy::NeuralNetwork {
        architecture: vec![32, 16, 8],
        learning_rate: 0.001,
        epochs: 10,
        batch_size: 16,
    };
    let mut ml_optimizer = MLCircuitOptimizer::new(ml_strategy);
    let ml_result = ml_optimizer.optimize(&circuit)?;
    println!(
        "   ML optimization completed in {:?}",
        ml_result.optimization_time
    );

    // 5. Fault-tolerant compilation
    println!("\n5. Fault-tolerant compilation:");
    let code = QECCode::SteaneCode;
    let ft_compiler = FaultTolerantCompiler::new(code);
    let ft_circuit = ft_compiler.compile(&circuit)?;
    println!(
        "   Fault-tolerant circuit: {} physical qubits, {} magic states",
        ft_circuit.physical_qubit_count, ft_circuit.magic_state_requirements
    );

    // 6. Photonic circuit conversion
    println!("\n6. Photonic quantum computation:");
    let photonic_circuit = PhotonicConverter::quantum_to_photonic(&circuit)?;
    println!(
        "   Photonic circuit: {} modes, {} gates",
        photonic_circuit.num_modes,
        photonic_circuit.gates.len()
    );

    // 7. Topological quantum computation
    println!("\n7. Topological quantum computation:");
    let anyon_model = AnyonModel::fibonacci();
    let topo_compiler = TopologicalCompiler::new(anyon_model);
    let topo_circuit = topo_compiler.compile_quantum_circuit(&circuit)?;
    println!(
        "   Topological circuit: {} anyons, {} braiding operations",
        topo_circuit.anyon_count(),
        topo_circuit.total_braiding_operations()
    );

    // 8. Circuit-to-simulator interface
    println!("\n8. Circuit compilation for simulators:");
    let mut compiler = CircuitCompiler::new();
    compiler.add_target(CompilationTarget {
        backend: SimulatorBackend::StateVector {
            max_qubits: 20,
            use_gpu: false,
            memory_optimization: MemoryOptimization::Basic,
        },
        optimization_level: SimulatorOptimizationLevel::Basic,
        instruction_set: InstructionSet::Universal,
        parallel_execution: true,
        batch_size: Some(10),
    });

    let compiled = compiler.compile(&circuit)?;
    println!(
        "   Compiled circuit: {} instructions, estimated memory: {} bytes",
        compiled.instructions.len(),
        compiled.resources.memory_bytes
    );

    // 9. Mid-circuit measurements and feed-forward
    println!("\n9. Mid-circuit measurements and feed-forward:");
    let mut measurement_circuit = MeasurementCircuit::<2>::new();
    measurement_circuit.add_gate(Box::new(Hadamard { target: QubitId(0) }))?;
    let bit = measurement_circuit.measure(QubitId(0))?;

    let condition = ClassicalCondition::equals(
        ClassicalValue::Integer(bit as u64),
        ClassicalValue::Integer(1),
    );
    measurement_circuit.add_conditional(condition, Box::new(PauliX { target: QubitId(1) }))?;
    println!(
        "   Measurement circuit with {} operations created",
        measurement_circuit.num_operations()
    );

    // 10. Cross-talk aware scheduling
    println!("\n10. Cross-talk aware scheduling:");
    let crosstalk_model = CrosstalkModel::uniform(3, 0.05);
    let scheduler = CrosstalkScheduler::new(crosstalk_model);
    let schedule = scheduler.schedule(&circuit)?;
    println!(
        "   Scheduled into {} time slices, total crosstalk: {:.3}",
        schedule.time_slices.len(),
        schedule.total_crosstalk
    );

    println!("\n=== Demo completed successfully! ===");
    Ok(())
}

pub fn register_equals(register: &str, value: u64) -> Self

Check if a register equals a specific value

Examples found in repository

examples/classical_control_demo.rs (line 34)

fn simple_conditional() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 1: Simple Conditional Operation");
    println!("--------------------------------------");

    // Create a circuit with classical control
    let circuit = ClassicalCircuitBuilder::<2>::new()
        .classical_register("c", 2)?
        .gate(Hadamard { target: QubitId(0) })?
        .measure(QubitId(0), "c", 0)?
        .conditional(
            ClassicalCondition::register_equals("c", 1),
            PauliX { target: QubitId(1) },
        )?
        .build();

    println!(
        "Created circuit with {} operations",
        circuit.num_operations()
    );
    println!("Circuit applies X to qubit 1 if qubit 0 measures to |1⟩\n");

    Ok(())
}

/// Quantum teleportation with classical communication
fn quantum_teleportation() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 2: Quantum Teleportation");
    println!("--------------------------------");

    // Create Bell pair between qubits 1 and 2
    let mut circuit = Circuit::<3>::new();
    circuit.h(1)?;
    circuit.cnot(1, 2)?;

    // Convert to classical circuit for measurements
    let mut classical_circuit = circuit.with_classical_control();
    classical_circuit.add_classical_register("alice", 2)?;

    // Alice's operations
    classical_circuit.add_gate(quantrs2_core::gate::multi::CNOT {
        control: QubitId(0),
        target: QubitId(1),
    })?;
    classical_circuit.add_gate(Hadamard { target: QubitId(0) })?;

    // Alice measures her qubits
    classical_circuit.measure(QubitId(0), "alice", 0)?;
    classical_circuit.measure(QubitId(1), "alice", 1)?;

    // Bob applies corrections based on Alice's measurements
    classical_circuit.add_conditional(
        ClassicalCondition {
            lhs: ClassicalValue::Register("alice".to_string()),
            op: ComparisonOp::Equal,
            rhs: ClassicalValue::Integer(0b01),
        },
        PauliX { target: QubitId(2) },
    )?;

    classical_circuit.add_conditional(
        ClassicalCondition {
            lhs: ClassicalValue::Register("alice".to_string()),
            op: ComparisonOp::Equal,
            rhs: ClassicalValue::Integer(0b10),
        },
        PauliZ { target: QubitId(2) },
    )?;

    classical_circuit.add_conditional(
        ClassicalCondition {
            lhs: ClassicalValue::Register("alice".to_string()),
            op: ComparisonOp::Equal,
            rhs: ClassicalValue::Integer(0b11),
        },
        PauliX { target: QubitId(2) }, // In reality, this would be X then Z
    )?;

    println!(
        "Created teleportation circuit with {} operations",
        classical_circuit.num_operations()
    );
    println!("Bob's qubit 2 receives the state that was on Alice's qubit 0\n");

    Ok(())
}

/// Adaptive phase estimation using conditional rotations
fn adaptive_phase_estimation() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 3: Adaptive Phase Estimation");
    println!("-----------------------------------");

    let circuit = ClassicalCircuitBuilder::<4>::new()
        .classical_register("phase_bits", 3)?
        // First estimation round
        .gate(Hadamard { target: QubitId(0) })?
        .gate(quantrs2_core::gate::multi::CRZ {
            control: QubitId(0),
            target: QubitId(3),
            theta: std::f64::consts::PI,
        })?
        .gate(Hadamard { target: QubitId(0) })?
        .measure(QubitId(0), "phase_bits", 0)?
        // Second round (adaptive based on first measurement)
        .gate(Hadamard { target: QubitId(1) })?
        .conditional(
            ClassicalCondition::register_equals("phase_bits", 1),
            quantrs2_core::gate::single::Phase { target: QubitId(1) }
        )?
        .gate(quantrs2_core::gate::multi::CRZ {
            control: QubitId(1),
            target: QubitId(3),
            theta: std::f64::consts::PI / 2.0,
        })?
        .gate(Hadamard { target: QubitId(1) })?
        .measure(QubitId(1), "phase_bits", 1)?
        // Third round (adaptive based on previous measurements)
        .gate(Hadamard { target: QubitId(2) })?
        // Apply phase corrections based on previous measurements
        .conditional(
            ClassicalCondition {
                lhs: ClassicalValue::Register("phase_bits".to_string()),
                op: ComparisonOp::GreaterEqual,
                rhs: ClassicalValue::Integer(1),
            },
            quantrs2_core::gate::single::RotationZ {
                target: QubitId(2),
                theta: -std::f64::consts::PI / 4.0,
            }
        )?
        .gate(quantrs2_core::gate::multi::CRZ {
            control: QubitId(2),
            target: QubitId(3),
            theta: std::f64::consts::PI / 4.0,
        })?
        .gate(Hadamard { target: QubitId(2) })?
        .measure(QubitId(2), "phase_bits", 2)?
        .build();

    println!(
        "Created adaptive phase estimation circuit with {} operations",
        circuit.num_operations()
    );
    println!("The circuit adaptively estimates the phase using 3 rounds of measurement\n");

    // Demonstrate builder pattern
    println!("Alternative: Using standard circuit with conversion");
    let mut standard_circuit = Circuit::<4>::new();
    standard_circuit.h(0)?;
    standard_circuit.h(1)?;
    standard_circuit.h(2)?;

    let classical = standard_circuit.with_classical_control();
    println!("Converted standard circuit to classical control\n");

    Ok(())
}

examples/measurement_demo.rs (line 35)

fn demo_basic_measurement() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Basic Mid-Circuit Measurement ---");

    let mut circuit = MeasurementCircuit::<3>::new();

    // Create superposition
    circuit.add_gate(Box::new(Hadamard { target: QubitId(0) }))?;

    // Measure qubit 0
    let bit0 = circuit.measure(QubitId(0))?;
    println!("Measured qubit 0 -> classical bit {}", bit0);

    // Apply X gate to qubit 1 conditioned on measurement
    let condition = ClassicalCondition::register_equals("default", 1);
    circuit.add_conditional(condition, Box::new(PauliX { target: QubitId(1) }))?;

    println!("Circuit has {} operations", circuit.num_operations());
    println!("Circuit has {} measurements\n", circuit.num_measurements());

    Ok(())
}

fn demo_feed_forward() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Feed-Forward Control ---");

    let (builder, bit) = MeasurementCircuitBuilder::<4>::new()
        // Prepare Bell state
        .gate(Box::new(Hadamard { target: QubitId(0) }))?
        .gate(Box::new(CNOT { control: QubitId(0), target: QubitId(1) }))?
        // Measure first qubit
        .measure(QubitId(0))?;

    let circuit = builder
        // Apply correction based on measurement
        .when(
            ClassicalCondition::register_equals("default", 1),
            Box::new(PauliX { target: QubitId(1) })
        )?
        // Add barrier for synchronization
        .barrier(vec![QubitId(1), QubitId(2)])?
        // Continue with more operations
        .gate(Box::new(Hadamard { target: QubitId(2) }))?
        .build();

    // Analyze dependencies
    let deps = circuit.analyze_dependencies();
    println!("Found {} measurements", deps.num_measurements());
    println!("Has feed-forward: {}", deps.has_feed_forward());

    for (meas_idx, ff_idx) in &deps.feed_forward_deps {
        println!("Operation {} depends on measurement {}", ff_idx, meas_idx);
    }

    println!();
    Ok(())
}

fn demo_quantum_teleportation() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Quantum Teleportation Protocol ---");

    let mut circuit = MeasurementCircuit::<3>::new();

    // Prepare state to teleport on qubit 0 (|ψ⟩ = α|0⟩ + β|1⟩)
    // For demo, use |+⟩ state
    circuit.add_gate(Box::new(Hadamard { target: QubitId(0) }))?;

    // Create Bell pair between qubits 1 and 2
    circuit.add_gate(Box::new(Hadamard { target: QubitId(1) }))?;
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(1),
        target: QubitId(2),
    }))?;

    println!("Prepared Bell pair and state to teleport");

    // Bell measurement on qubits 0 and 1
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(0),
        target: QubitId(1),
    }))?;
    circuit.add_gate(Box::new(Hadamard { target: QubitId(0) }))?;

    // Measure qubits 0 and 1
    let bit0 = circuit.measure(QubitId(0))?;
    let bit1 = circuit.measure(QubitId(1))?;

    println!("Performed Bell measurement");

    // Apply corrections to qubit 2 based on measurements
    circuit.add_conditional(
        ClassicalCondition::register_equals("default", 1),
        Box::new(PauliX { target: QubitId(2) }),
    )?;

    circuit.add_conditional(
        ClassicalCondition::register_equals("default", 1),
        Box::new(PauliZ { target: QubitId(2) }),
    )?;

    println!("Applied classical corrections");
    println!(
        "Teleportation circuit has {} operations",
        circuit.num_operations()
    );

    println!();
    Ok(())
}

fn demo_error_correction() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Simple Error Correction ---");

    let mut circuit = MeasurementCircuit::<5>::new();

    // Encode logical qubit using repetition code
    // |0⟩ -> |000⟩, |1⟩ -> |111⟩

    // Prepare initial state (for demo, use |1⟩)
    circuit.add_gate(Box::new(PauliX { target: QubitId(0) }))?;

    // Encode
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(0),
        target: QubitId(1),
    }))?;
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(0),
        target: QubitId(2),
    }))?;

    println!("Encoded logical qubit");

    // Simulate error (bit flip on qubit 1)
    circuit.add_gate(Box::new(PauliX { target: QubitId(1) }))?;
    println!("Introduced error on qubit 1");

    // Syndrome measurement using ancillas
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(0),
        target: QubitId(3),
    }))?;
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(1),
        target: QubitId(3),
    }))?;

    circuit.add_gate(Box::new(CNOT {
        control: QubitId(1),
        target: QubitId(4),
    }))?;
    circuit.add_gate(Box::new(CNOT {
        control: QubitId(2),
        target: QubitId(4),
    }))?;

    // Measure syndrome
    let syndrome1 = circuit.measure(QubitId(3))?;
    let syndrome2 = circuit.measure(QubitId(4))?;

    println!("Measured error syndrome");

    // Decode syndrome and apply correction
    // Note: In a full implementation, we would need compound conditions
    // For now, apply simple conditional corrections based on syndrome bits

    // Apply correction based on first syndrome bit
    circuit.add_conditional(
        ClassicalCondition::register_equals("default", 1),
        Box::new(PauliX { target: QubitId(1) }),
    )?;

    println!("Applied error correction");
    println!("Total operations: {}", circuit.num_operations());

    // Reset ancillas for reuse
    circuit.reset(QubitId(3))?;
    circuit.reset(QubitId(4))?;

    println!();
    Ok(())
}

Trait Implementations

impl Clone for ClassicalCondition

fn clone(&self) -> ClassicalCondition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClassicalCondition

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

Formats the value using the given formatter.