Struct Qubit 

#[repr(transparent)]
pub struct Qubit(pub u32);

A transparent wrapper around a qubit identifier

This provides type safety for qubit references while maintaining zero-cost abstraction.

Tuple Fields

0: u32

Implementations

impl QubitId

pub const fn new(id: u32) -> QubitId

Create a new qubit identifier

Examples found in repository

examples/qasm_example.rs (line 31)

fn export_example() {
    println!("1. Exporting a circuit to OpenQASM 3.0");
    println!("--------------------------------------");

    // Create a quantum teleportation circuit
    let mut builder = CircuitBuilder::<3>::new();

    // Create Bell pair between Alice and Bob
    let _ = builder.h(Qubit::new(1));
    let _ = builder.cx(Qubit::new(1), Qubit::new(2));

    // Alice's operations
    let _ = builder.cx(Qubit::new(0), Qubit::new(1));
    let _ = builder.h(Qubit::new(0));

    // Measurements (in real teleportation, these would be mid-circuit)
    let _ = builder.measure(Qubit::new(0));
    let _ = builder.measure(Qubit::new(1));

    // Bob's corrections (would be conditional in real circuit)
    let _ = builder.cx(Qubit::new(1), Qubit::new(2));
    let _ = builder.cz(Qubit::new(0), Qubit::new(2));

    let circuit = builder.build();

    // Export with default options
    match export_qasm3(&circuit) {
        Ok(qasm) => {
            println!("Teleportation circuit in OpenQASM 3.0:");
            println!("{}", qasm);
        }
        Err(e) => println!("Export error: {}", e),
    }

    // Export with custom options
    let options = ExportOptions {
        include_stdgates: true,
        decompose_custom: true,
        include_gate_comments: true,
        optimize: true,
        pretty_print: true,
    };

    let mut exporter = QasmExporter::new(options);
    match exporter.export(&circuit) {
        Ok(qasm) => {
            println!("\nWith custom options:");
            println!("{}", qasm);
        }
        Err(e) => println!("Export error: {}", e),
    }
}

fn parse_example() {
    println!("\n2. Parsing OpenQASM 3.0 code");
    println!("----------------------------");

    let qasm_code = r#"
OPENQASM 3.0;
include "stdgates.inc";

// Quantum registers
qubit[5] q;
bit[5] c;

// Create W state
reset q;
ry(1.91063) q[0];  // arccos(1/sqrt(5))
cx q[0], q[1];

// Controlled rotations to distribute amplitude
cry(1.10715) q[1], q[2];  // arccos(1/2)
cx q[1], q[2];

cry(0.95532) q[2], q[3];  // arccos(1/sqrt(3))
cx q[2], q[3];

cry(pi/4) q[3], q[4];
cx q[3], q[4];

// Measure all qubits
measure q -> c;
"#;

    match parse_qasm3(qasm_code) {
        Ok(program) => {
            println!("Successfully parsed QASM program!");
            println!("Version: {}", program.version);
            println!("Includes: {:?}", program.includes);
            println!("Declarations: {} items", program.declarations.len());
            println!("Statements: {} operations", program.statements.len());

            // Pretty print the parsed program
            println!("\nReconstructed QASM:");
            println!("{}", program);
        }
        Err(e) => println!("Parse error: {}", e),
    }
}

fn validation_example() {
    println!("\n3. Validating QASM programs");
    println!("---------------------------");

    // Valid program
    let valid_qasm = r#"
OPENQASM 3.0;

gate mybell a, b {
    h a;
    cx a, b;
}

qubit[4] q;
bit[2] c;

mybell q[0], q[1];
mybell q[2], q[3];

measure q[0] -> c[0];
measure q[2] -> c[1];
"#;

    println!("Validating correct program...");
    match parse_qasm3(valid_qasm) {
        Ok(program) => match validate_qasm3(&program) {
            Ok(()) => println!("✓ Program is valid!"),
            Err(e) => println!("✗ Validation error: {}", e),
        },
        Err(e) => println!("Parse error: {}", e),
    }

    // Program with errors
    let invalid_qasm = r#"
OPENQASM 3.0;

qubit[2] q;
bit[2] c;

// Error: using undefined register
h r[0];

// Error: index out of bounds
cx q[0], q[5];

// Error: wrong number of parameters
rx q[0];  // Missing angle parameter
"#;

    println!("\nValidating program with errors...");
    match parse_qasm3(invalid_qasm) {
        Ok(program) => match validate_qasm3(&program) {
            Ok(()) => println!("Program is valid (unexpected!)"),
            Err(e) => println!("✓ Caught validation error: {}", e),
        },
        Err(e) => println!("Parse error: {}", e),
    }
}

fn round_trip_example() {
    println!("\n4. Round-trip conversion");
    println!("------------------------");

    // Create a variational circuit
    let mut builder = CircuitBuilder::<4>::new();

    // Layer 1: Single-qubit rotations
    for i in 0..4 {
        let _ = builder.ry(Qubit::new(i), 0.5);
        let _ = builder.rz(Qubit::new(i), 0.3);
    }

    // Layer 2: Entangling gates
    for i in 0..3 {
        let _ = builder.cx(Qubit::new(i), Qubit::new(i + 1));
    }
    let _ = builder.cx(Qubit::new(3), Qubit::new(0)); // Circular connectivity

    // Layer 3: More rotations
    for i in 0..4 {
        let _ = builder.rx(Qubit::new(i), -0.2);
    }

    // Measurements
    for i in 0..4 {
        let _ = builder.measure(Qubit::new(i));
    }

    let original = builder.build();

    println!(
        "Original circuit created with {} gates",
        original.gates().len()
    );

    // Export to QASM
    match export_qasm3(&original) {
        Ok(qasm) => {
            println!("\nExported QASM:");
            println!("{}", qasm);

            // Parse it back
            match parse_qasm3(&qasm) {
                Ok(program) => {
                    println!("\n✓ Successfully parsed the exported QASM!");

                    // Validate it
                    match validate_qasm3(&program) {
                        Ok(()) => println!("✓ Validation passed!"),
                        Err(e) => println!("✗ Validation error: {}", e),
                    }

                    // Count operations
                    let gate_count = program
                        .statements
                        .iter()
                        .filter(|s| {
                            matches!(s, quantrs2_circuit::qasm::ast::QasmStatement::Gate(_))
                        })
                        .count();
                    let measure_count = program
                        .statements
                        .iter()
                        .filter(|s| {
                            matches!(s, quantrs2_circuit::qasm::ast::QasmStatement::Measure(_))
                        })
                        .count();

                    println!("\nParsed circuit has:");
                    println!("  - {} gate operations", gate_count);
                    println!("  - {} measurements", measure_count);
                }
                Err(e) => println!("Parse error: {}", e),
            }
        }
        Err(e) => println!("Export error: {}", e),
    }
}

pub const fn id(&self) -> u32

Get the raw identifier value

Examples found in repository

examples/crosstalk_demo.rs (line 374)

fn demo_adaptive_scheduling() -> quantrs2_core::error::QuantRS2Result<()> {
    println!("--- Adaptive Scheduling ---");

    // Create a circuit with varying gate densities
    let mut circuit = Circuit::<8>::new();

    // Dense region: many gates on qubits 0-3
    for _ in 0..3 {
        for i in 0..3 {
            circuit.add_gate(Hadamard { target: QubitId(i) })?;
            circuit.add_gate(RotationZ {
                target: QubitId(i),
                theta: 0.1,
            })?;
        }
        circuit.add_gate(CNOT {
            control: QubitId(0),
            target: QubitId(1),
        })?;
        circuit.add_gate(CNOT {
            control: QubitId(2),
            target: QubitId(3),
        })?;
    }

    // Sparse region: few gates on qubits 4-7
    circuit.add_gate(Hadamard { target: QubitId(4) })?;
    circuit.add_gate(CNOT {
        control: QubitId(4),
        target: QubitId(5),
    })?;
    circuit.add_gate(PauliX { target: QubitId(7) })?;

    println!("Circuit with dense (qubits 0-3) and sparse (qubits 4-7) regions");
    println!("Total gates: {}", circuit.num_gates());

    let model = CrosstalkModel::uniform(8, 0.05);
    let analyzer = CrosstalkAnalyzer::new(model.clone());

    // Analyze before scheduling
    let analysis = analyzer.analyze(&circuit);
    println!("\nCrosstalk analysis:");
    println!(
        "  Problematic pairs in dense region: {}",
        analysis
            .problematic_pairs
            .iter()
            .filter(|(g1, g2, _)| {
                let gates = circuit.gates();
                let q1 = gates[*g1].qubits()[0].id();
                let q2 = gates[*g2].qubits()[0].id();
                q1 < 4 && q2 < 4
            })
            .count()
    );

    // Schedule with adaptive strategy
    let scheduler = CrosstalkScheduler::new(model);
    let schedule = scheduler.schedule(&circuit)?;

    println!("\nAdaptive scheduling results:");
    println!("  Time slices: {}", schedule.time_slices.len());
    println!(
        "  Average gates per slice: {:.1}",
        circuit.num_gates() as f64 / schedule.time_slices.len() as f64
    );

    Ok(())
}

Trait Implementations

impl Clone for QubitId

fn clone(&self) -> QubitId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QubitId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QubitId

fn deserialize<__D>( __deserializer: __D, ) -> Result<QubitId, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<QubitId> for u32

fn from(qubit: QubitId) -> u32

Converts to this type from the input type.

impl From<i32> for QubitId

fn from(id: i32) -> QubitId

Converts to this type from the input type.

impl From<u32> for QubitId

fn from(id: u32) -> QubitId

Converts to this type from the input type.

impl From<usize> for QubitId

fn from(id: usize) -> QubitId

Converts to this type from the input type.

impl Hash for QubitId

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for QubitId

fn cmp(&self, other: &QubitId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for QubitId

fn eq(&self, other: &QubitId) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for QubitId

fn partial_cmp(&self, other: &QubitId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for QubitId

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for QubitId

impl Eq for QubitId

impl StructuralPartialEq for QubitId