Struct BasicBlock 

pub struct BasicBlock {
    pub gates: Vec<GateInstruction>,
    pub qubits_op: BTreeMap<usize, QubitOp>,
    pub global: Option<f64>,
}

A straight-line sequence of quantum gate instructions.

A BasicBlock is created empty and gates are appended one at a time via BasicBlock::append_gate or in bulk via BasicBlock::append_block. Each append operation attempts lightweight algebraic simplifications: adjacent inverse gate pairs are cancelled and consecutive same-axis rotation gates are merged into one.

The block also maintains a dependency index (qubits_op) consumed by the qubit-allocation and circuit-mapping passes.

Fields

gates: Vec<GateInstruction>

The ordered list of gate instructions in this block.

qubits_op: BTreeMap<usize, QubitOp>

Per-qubit dependency records (propriety and read-control sets).

global: Option<f64>

Accumulated global phase (in radians), or None if no global phase has been added to this block.

Implementations

impl BasicBlock

pub fn new() -> Self

Creates a new, empty BasicBlock.

Examples found in repository

examples/qft.rs (line 19)

fn qft(qubits: &[usize], do_swap: bool) -> Result<BasicBlock, KetError> {
    let mut quantum_code = BasicBlock::new();
    if qubits.len() == 1 {
        quantum_code.append_gate(QuantumGate::Hadamard, qubits[0]);
        return Ok(quantum_code);
    }

    let init = &qubits[..qubits.len() - 1];
    let last = qubits[qubits.len() - 1];
    quantum_code.append_gate(QuantumGate::Hadamard, last);
    for (i, c) in init.iter().enumerate() {
        quantum_code.append_block(
            controlled_gate(
                QuantumGate::Phase(Param::Value(PI / 2.0_f64.powi(i as i32 + 1))),
                &[*c],
                last,
            )?,
            None,
        );
    }
    quantum_code.append_block(qft(init, false)?, None);

    if do_swap {
        for i in 0..qubits.len() / 2 {
            quantum_code.append_block(swap_gate(qubits[i], qubits[qubits.len() - i - 1])?, None);
        }
    }

    Ok(quantum_code)
}

examples/grover.rs (line 25)

fn main() -> Result<(), KetError> {
    let num_qubits = 3;

    let mut process = Process::new(QPUConfig {
        num_qubits,
        quantum_execution: None,
    });

    let qubits: Result<Vec<_>, _> = (0..num_qubits).map(|_| process.alloc()).collect();
    let qubits = qubits?;

    let mut quantum_code = BasicBlock::new();

    for target in &qubits {
        quantum_code.append_gate(QuantumGate::Hadamard, *target);
    }

    process.append_block(quantum_code)?;

    let steps = ((FRAC_PI_4) * f64::sqrt((1 << num_qubits) as f64)) as i64;

    for _ in 0..steps {
        process.append_block(compute_action_uncompute_gate(
            |mut compute| {
                for target in &qubits {
                    compute.append_gate(QuantumGate::PauliX, *target);
                }
                Ok(compute)
            },
            |mut action| {
                action.append_gate(QuantumGate::PauliZ, qubits[0]);
                Ok(action.control(&qubits[1..])?)
            },
        )?)?;

        process.append_block(compute_action_uncompute_gate(
            |mut compute| {
                for target in &qubits {
                    compute.append_gate(QuantumGate::Hadamard, *target);
                    compute.append_gate(QuantumGate::PauliX, *target);
                }
                Ok(compute)
            },
            |mut action| {
                action.append_gate(QuantumGate::PauliZ, qubits[0]);
                Ok(action.control(&qubits[1..])?)
            },
        )?)?;
    }

    println!("{:#?}", process);

    Ok(())
}

pub fn append_gate(&mut self, gate: QuantumGate, target: usize)

Appends an uncontrolled gate to the block.

Examples found in repository

examples/qft.rs (line 21)

fn qft(qubits: &[usize], do_swap: bool) -> Result<BasicBlock, KetError> {
    let mut quantum_code = BasicBlock::new();
    if qubits.len() == 1 {
        quantum_code.append_gate(QuantumGate::Hadamard, qubits[0]);
        return Ok(quantum_code);
    }

    let init = &qubits[..qubits.len() - 1];
    let last = qubits[qubits.len() - 1];
    quantum_code.append_gate(QuantumGate::Hadamard, last);
    for (i, c) in init.iter().enumerate() {
        quantum_code.append_block(
            controlled_gate(
                QuantumGate::Phase(Param::Value(PI / 2.0_f64.powi(i as i32 + 1))),
                &[*c],
                last,
            )?,
            None,
        );
    }
    quantum_code.append_block(qft(init, false)?, None);

    if do_swap {
        for i in 0..qubits.len() / 2 {
            quantum_code.append_block(swap_gate(qubits[i], qubits[qubits.len() - i - 1])?, None);
        }
    }

    Ok(quantum_code)
}

examples/grover.rs (line 28)

fn main() -> Result<(), KetError> {
    let num_qubits = 3;

    let mut process = Process::new(QPUConfig {
        num_qubits,
        quantum_execution: None,
    });

    let qubits: Result<Vec<_>, _> = (0..num_qubits).map(|_| process.alloc()).collect();
    let qubits = qubits?;

    let mut quantum_code = BasicBlock::new();

    for target in &qubits {
        quantum_code.append_gate(QuantumGate::Hadamard, *target);
    }

    process.append_block(quantum_code)?;

    let steps = ((FRAC_PI_4) * f64::sqrt((1 << num_qubits) as f64)) as i64;

    for _ in 0..steps {
        process.append_block(compute_action_uncompute_gate(
            |mut compute| {
                for target in &qubits {
                    compute.append_gate(QuantumGate::PauliX, *target);
                }
                Ok(compute)
            },
            |mut action| {
                action.append_gate(QuantumGate::PauliZ, qubits[0]);
                Ok(action.control(&qubits[1..])?)
            },
        )?)?;

        process.append_block(compute_action_uncompute_gate(
            |mut compute| {
                for target in &qubits {
                    compute.append_gate(QuantumGate::Hadamard, *target);
                    compute.append_gate(QuantumGate::PauliX, *target);
                }
                Ok(compute)
            },
            |mut action| {
                action.append_gate(QuantumGate::PauliZ, qubits[0]);
                Ok(action.control(&qubits[1..])?)
            },
        )?)?;
    }

    println!("{:#?}", process);

    Ok(())
}

pub fn inverse(&self) -> Self

Return a new basic block with the inverse of the circuit.

pub fn control(&self, control_qubits: &[usize]) -> Result<Self, KetError>

Returns a copy of this block with control_qubits added to every gate.

Errors

Propagates any KetError returned by GateInstruction::control.

Examples found in repository

examples/grover.rs (line 45)

fn main() -> Result<(), KetError> {
    let num_qubits = 3;

    let mut process = Process::new(QPUConfig {
        num_qubits,
        quantum_execution: None,
    });

    let qubits: Result<Vec<_>, _> = (0..num_qubits).map(|_| process.alloc()).collect();
    let qubits = qubits?;

    let mut quantum_code = BasicBlock::new();

    for target in &qubits {
        quantum_code.append_gate(QuantumGate::Hadamard, *target);
    }

    process.append_block(quantum_code)?;

    let steps = ((FRAC_PI_4) * f64::sqrt((1 << num_qubits) as f64)) as i64;

    for _ in 0..steps {
        process.append_block(compute_action_uncompute_gate(
            |mut compute| {
                for target in &qubits {
                    compute.append_gate(QuantumGate::PauliX, *target);
                }
                Ok(compute)
            },
            |mut action| {
                action.append_gate(QuantumGate::PauliZ, qubits[0]);
                Ok(action.control(&qubits[1..])?)
            },
        )?)?;

        process.append_block(compute_action_uncompute_gate(
            |mut compute| {
                for target in &qubits {
                    compute.append_gate(QuantumGate::Hadamard, *target);
                    compute.append_gate(QuantumGate::PauliX, *target);
                }
                Ok(compute)
            },
            |mut action| {
                action.append_gate(QuantumGate::PauliZ, qubits[0]);
                Ok(action.control(&qubits[1..])?)
            },
        )?)?;
    }

    println!("{:#?}", process);

    Ok(())
}

pub fn enable_approximated_decomposition(&mut self)

Enable approximate decomposition enabled on all gate instructions.

pub fn lock_control(&mut self)

Lock control sets locked on all gates.

pub fn append_block(&mut self, block: Self, epsilon: Option<f64>)

Appends all instructions from block into self, applying algebraic simplifications using the given epsilon tolerance.

After draining block.gates, the global phases are summed and the qubits_op dependency maps are merged (restricting propriety to the more-general of the two).

Examples found in repository

examples/qft.rs (lines 29-36)

fn qft(qubits: &[usize], do_swap: bool) -> Result<BasicBlock, KetError> {
    let mut quantum_code = BasicBlock::new();
    if qubits.len() == 1 {
        quantum_code.append_gate(QuantumGate::Hadamard, qubits[0]);
        return Ok(quantum_code);
    }

    let init = &qubits[..qubits.len() - 1];
    let last = qubits[qubits.len() - 1];
    quantum_code.append_gate(QuantumGate::Hadamard, last);
    for (i, c) in init.iter().enumerate() {
        quantum_code.append_block(
            controlled_gate(
                QuantumGate::Phase(Param::Value(PI / 2.0_f64.powi(i as i32 + 1))),
                &[*c],
                last,
            )?,
            None,
        );
    }
    quantum_code.append_block(qft(init, false)?, None);

    if do_swap {
        for i in 0..qubits.len() / 2 {
            quantum_code.append_block(swap_gate(qubits[i], qubits[qubits.len() - i - 1])?, None);
        }
    }

    Ok(quantum_code)
}

pub fn add_global_phase(&mut self, phase: f64)

Sum a global phase in the block.

pub fn max_qubit_index(&self) -> Option<usize>

Returns the highest qubit index referenced by any gate in this block, or None if the block is empty.

pub fn flat_gates( &self, parameters: Option<&[f64]>, shift: Option<(usize, usize, f64)>, ) -> Vec<DecomposedGate>

Flattens decomposed multi-qubit gates into a single sequence of DecomposedGate.

When parameters is provided, any symbolic Param::Ref values are resolved to their concrete floating-point equivalents before output.

pub fn set_as_diagonal(&mut self)

Forces the propriety classification of every qubit entry to at most GatePropriety::Diagonal, even if the actual gate sequence is more general. Used when an externally-verified analysis guarantees the circuit is diagonal.

pub fn set_as_permutation(&mut self)

Forces the propriety classification of every qubit entry to at most GatePropriety::Permutation, even if the actual gate sequence is more general. Used when an externally-verified analysis guarantees the circuit only permutes basis states.

Trait Implementations

impl Clone for BasicBlock

fn clone(&self) -> BasicBlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BasicBlock

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

Formats the value using the given formatter.

impl Default for BasicBlock

fn default() -> BasicBlock

Returns the “default value” for a type.