Struct CouplingMap 

pub struct CouplingMap { /* private fields */ }

Coupling map representing the connectivity graph of a quantum device

Implementations

impl CouplingMap

pub fn new(num_qubits: usize) -> Self

Create a new coupling map with the specified number of qubits

pub fn add_edge(&mut self, qubit1: usize, qubit2: usize)

Add a bidirectional edge between two qubits

pub fn are_connected(&self, qubit1: usize, qubit2: usize) -> bool

Check if two qubits are directly connected

pub fn neighbors(&self, qubit: usize) -> &[usize]

Get the neighbors of a qubit

pub fn num_qubits(&self) -> usize

Get the number of qubits

Examples found in repository

examples/routing_demo.rs (line 50)

fn demo_linear_coupling(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Linear Device (0-1-2-3) ---");

    let coupling_map = CouplingMap::linear(4);
    println!(
        "Coupling map: linear chain with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());

    // Test SABRE routing
    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map.clone());
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    let stats = routed.statistics();
    println!("  Circuit depth: {}", stats.circuit_depth);
    println!(
        "  Gate breakdown: {} single, {} two-qubit, {} SWAPs",
        stats.single_qubit_gates, stats.two_qubit_gates, stats.swap_gates
    );

    // Test Lookahead routing
    let lookahead_router =
        CircuitRouter::new(RoutingStrategy::Lookahead { depth: 5 }, coupling_map);
    let routed_lookahead = lookahead_router.route(circuit)?;

    println!("\nLookahead Routing Results:");
    println!(
        "  Total gates after routing: {}",
        routed_lookahead.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_lookahead.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_lookahead.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

fn demo_grid_coupling(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- 2x2 Grid Device ---");

    let coupling_map = CouplingMap::grid(2, 2);
    println!(
        "Coupling map: 2x2 grid with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    println!();
    Ok(())
}

fn demo_custom_device(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Custom Device (Star topology) ---");

    // Create a star topology: center qubit (0) connected to all others
    let edges = [(0, 1), (0, 2), (0, 3)];
    let coupling_map = CouplingMap::from_edges(4, &edges);

    println!(
        "Coupling map: star topology with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());
    println!("Diameter: {}", coupling_map.diameter());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    // Test stochastic routing for comparison
    let stochastic_router = CircuitRouter::new(
        RoutingStrategy::Stochastic { trials: 3 },
        CouplingMap::from_edges(4, &edges),
    );
    let routed_stochastic = stochastic_router.route(circuit)?;

    println!("\nStochastic Routing Results (3 trials):");
    println!(
        "  Total gates after routing: {}",
        routed_stochastic.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_stochastic.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_stochastic.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

pub fn edges(&self) -> Vec<(usize, usize)>

Get all edges as pairs

Examples found in repository

examples/routing_demo.rs (line 52)

fn demo_linear_coupling(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Linear Device (0-1-2-3) ---");

    let coupling_map = CouplingMap::linear(4);
    println!(
        "Coupling map: linear chain with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());

    // Test SABRE routing
    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map.clone());
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    let stats = routed.statistics();
    println!("  Circuit depth: {}", stats.circuit_depth);
    println!(
        "  Gate breakdown: {} single, {} two-qubit, {} SWAPs",
        stats.single_qubit_gates, stats.two_qubit_gates, stats.swap_gates
    );

    // Test Lookahead routing
    let lookahead_router =
        CircuitRouter::new(RoutingStrategy::Lookahead { depth: 5 }, coupling_map);
    let routed_lookahead = lookahead_router.route(circuit)?;

    println!("\nLookahead Routing Results:");
    println!(
        "  Total gates after routing: {}",
        routed_lookahead.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_lookahead.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_lookahead.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

fn demo_grid_coupling(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- 2x2 Grid Device ---");

    let coupling_map = CouplingMap::grid(2, 2);
    println!(
        "Coupling map: 2x2 grid with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    println!();
    Ok(())
}

fn demo_custom_device(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Custom Device (Star topology) ---");

    // Create a star topology: center qubit (0) connected to all others
    let edges = [(0, 1), (0, 2), (0, 3)];
    let coupling_map = CouplingMap::from_edges(4, &edges);

    println!(
        "Coupling map: star topology with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());
    println!("Diameter: {}", coupling_map.diameter());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    // Test stochastic routing for comparison
    let stochastic_router = CircuitRouter::new(
        RoutingStrategy::Stochastic { trials: 3 },
        CouplingMap::from_edges(4, &edges),
    );
    let routed_stochastic = stochastic_router.route(circuit)?;

    println!("\nStochastic Routing Results (3 trials):");
    println!(
        "  Total gates after routing: {}",
        routed_stochastic.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_stochastic.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_stochastic.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

pub fn distance(&self, qubit1: usize, qubit2: usize) -> Distance

Compute the distance between two qubits using BFS

pub fn compute_distances(&mut self)

Pre-compute all-pairs shortest distances

pub fn shortest_path(&self, start: usize, end: usize) -> Option<Vec<usize>>

Get the shortest path between two qubits

pub fn is_connected(&self) -> bool

Check if the graph is connected

pub fn diameter(&self) -> Distance

Get the diameter of the graph (maximum distance between any two nodes)

Examples found in repository

examples/routing_demo.rs (line 132)

fn demo_custom_device(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Custom Device (Star topology) ---");

    // Create a star topology: center qubit (0) connected to all others
    let edges = [(0, 1), (0, 2), (0, 3)];
    let coupling_map = CouplingMap::from_edges(4, &edges);

    println!(
        "Coupling map: star topology with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());
    println!("Diameter: {}", coupling_map.diameter());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    // Test stochastic routing for comparison
    let stochastic_router = CircuitRouter::new(
        RoutingStrategy::Stochastic { trials: 3 },
        CouplingMap::from_edges(4, &edges),
    );
    let routed_stochastic = stochastic_router.route(circuit)?;

    println!("\nStochastic Routing Results (3 trials):");
    println!(
        "  Total gates after routing: {}",
        routed_stochastic.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_stochastic.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_stochastic.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

pub fn linear(num_qubits: usize) -> Self

Create common device topologies Linear topology (1D chain)

Examples found in repository

examples/noise_optimization_demo.rs (line 87)

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

examples/routing_demo.rs (line 47)

fn demo_linear_coupling(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Linear Device (0-1-2-3) ---");

    let coupling_map = CouplingMap::linear(4);
    println!(
        "Coupling map: linear chain with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());

    // Test SABRE routing
    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map.clone());
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    let stats = routed.statistics();
    println!("  Circuit depth: {}", stats.circuit_depth);
    println!(
        "  Gate breakdown: {} single, {} two-qubit, {} SWAPs",
        stats.single_qubit_gates, stats.two_qubit_gates, stats.swap_gates
    );

    // Test Lookahead routing
    let lookahead_router =
        CircuitRouter::new(RoutingStrategy::Lookahead { depth: 5 }, coupling_map);
    let routed_lookahead = lookahead_router.route(circuit)?;

    println!("\nLookahead Routing Results:");
    println!(
        "  Total gates after routing: {}",
        routed_lookahead.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_lookahead.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_lookahead.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

pub fn ring(num_qubits: usize) -> Self

Ring topology (circular)

pub fn grid(rows: usize, cols: usize) -> Self

Grid topology (2D)

Examples found in repository

examples/routing_demo.rs (line 97)

fn demo_grid_coupling(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- 2x2 Grid Device ---");

    let coupling_map = CouplingMap::grid(2, 2);
    println!(
        "Coupling map: 2x2 grid with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    println!();
    Ok(())
}

pub fn all_to_all(num_qubits: usize) -> Self

All-to-all topology (complete graph)

pub fn ibm_lagos() -> Self

IBM Lagos device topology

pub fn ibm_nairobi() -> Self

IBM Nairobi device topology

pub fn google_sycamore() -> Self

Google Sycamore-like device topology

pub fn from_edges(num_qubits: usize, edges: &[(usize, usize)]) -> Self

Load coupling map from adjacency list

Examples found in repository

examples/routing_demo.rs (line 125)

fn demo_custom_device(circuit: &Circuit<4>) -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Custom Device (Star topology) ---");

    // Create a star topology: center qubit (0) connected to all others
    let edges = [(0, 1), (0, 2), (0, 3)];
    let coupling_map = CouplingMap::from_edges(4, &edges);

    println!(
        "Coupling map: star topology with {} qubits",
        coupling_map.num_qubits()
    );
    println!("Edges: {:?}", coupling_map.edges());
    println!("Diameter: {}", coupling_map.diameter());

    let router = CircuitRouter::new(RoutingStrategy::Sabre, coupling_map);
    let routed = router.route(circuit)?;

    println!("\nSABRE Routing Results:");
    println!("  Total gates after routing: {}", routed.num_gates());
    println!("  SWAP gates inserted: {}", routed.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed.routing_overhead() * 100.0
    );
    println!("  Final mapping: {:?}", routed.get_mapping());

    // Test stochastic routing for comparison
    let stochastic_router = CircuitRouter::new(
        RoutingStrategy::Stochastic { trials: 3 },
        CouplingMap::from_edges(4, &edges),
    );
    let routed_stochastic = stochastic_router.route(circuit)?;

    println!("\nStochastic Routing Results (3 trials):");
    println!(
        "  Total gates after routing: {}",
        routed_stochastic.num_gates()
    );
    println!("  SWAP gates inserted: {}", routed_stochastic.num_swaps());
    println!(
        "  Routing overhead: {:.2}%",
        routed_stochastic.routing_overhead() * 100.0
    );

    println!();
    Ok(())
}

Trait Implementations

impl Clone for CouplingMap

fn clone(&self) -> CouplingMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CouplingMap

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

Formats the value using the given formatter.

impl Default for CouplingMap

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CouplingMap

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CouplingMap

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

where __S: Serializer,

Serialize this value into the given Serde serializer.