Struct Process 

pub struct Process { /* private fields */ }

A quantum process: the top-level compilation and execution unit.

Create a Process with Process::new, allocate qubits with Process::alloc, append gate sequences with Process::append_block, and trigger execution with Process::execute (batch mode) or read results immediately after each gate/measurement in live mode.

Each process follows a linear ProcessState machine and can be executed at most once. Results are cached and retrieved via Process::read_sample, Process::read_exp_value, and Process::read_gradient.

Implementations

impl Process

pub fn new(qpu_config: QPUConfig) -> Self

Creates a new Process from the given QPUConfig.

The process starts in the ProcessState::AcceptingGate state with an empty gate sequence, no allocated qubits, and an angle-cancellation threshold (epsilon) of 1e-10 radians.

Examples found in repository

examples/qft.rs (lines 52-55)

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

    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?;

    process.append_block(qft(&qubits, true)?)?;

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

    Ok(())
}

examples/grover.rs (lines 17-20)

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 const fn alloc(&mut self) -> Result<usize, KetError>

Allocates the next available logical qubit and returns its index.

Errors

• KetError::ProcessTerminated: the process has already been executed.
• KetError::QubitLimitExceeded: all qubits permitted by the QPU configuration have been allocated.

Examples found in repository

examples/qft.rs (line 57)

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

    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?;

    process.append_block(qft(&qubits, true)?)?;

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

    Ok(())
}

examples/grover.rs (line 22)

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_block(&mut self, block: BasicBlock) -> Result<(), KetError>

Appends a BasicBlock of gate instructions to this process.

If required, gate decomposition is performed in parallel before the block is merged into the main circuit. In live mode every gate is sent to the QPU backend immediately.

Errors

• KetError::GateAppendForbidden: the process is not in the gate-accepting state.
• KetError::QubitIndexOutOfRange: the block references a qubit that has not yet been allocated.

Examples found in repository

examples/qft.rs (line 60)

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

    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?;

    process.append_block(qft(&qubits, true)?)?;

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

    Ok(())
}

examples/grover.rs (line 31)

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 main_block(&self) -> &BasicBlock

Returns a reference to the accumulated gate sequence of this process.

Useful for introspection or serialization before execution.

pub fn measure(&mut self, qubits: &[usize]) -> Result<u64, KetError>

Performs a single-shot mid-circuit measurement of qubits.

Errors

• KetError::MeasurementUnavailableInBatch: the process is not running in live execution mode.

pub fn dump(&mut self, qubits: &[usize]) -> Result<DumpData, KetError>

Dumps the quantum state of qubits (live mode only).

Errors

• KetError::DumpUnavailableInBatch: the process is not running in live execution mode.

pub fn sample( &mut self, qubits: &[usize], shots: usize, ) -> Result<Option<SampleData>, KetError>

Requests a measurement sample of qubits over shots repetitions.

Live mode: The sample is taken immediately and returned as Ok(Some(SampleData)).

Batch mode: The request is recorded and Ok(None) is returned. The process transitions to ProcessState::ReadyToExecute. Call Process::execute to dispatch the circuit and then retrieve the result with Process::read_sample.

Errors

• KetError::SamplingUnavailable: a conflicting measurement has already been registered, or no execution backend is configured.

pub fn read_sample(&self) -> Option<&SampleData>

Returns a reference to the cached SampleData from the most recent execution, or None if no sample result is available yet.

pub fn exp_value( &mut self, hamiltonian: Hamiltonian, ) -> Result<Option<f64>, KetError>

Requests the expectation value ⟨ψ|H|ψ⟩ of hamiltonian.

Live mode: The expectation value is computed immediately and returned as Ok(Some(f64)).

Batch mode (no gradient): The Hamiltonian is appended to the internal list. The process stays in (or transitions to) ProcessState::AcceptingHamiltonian, allowing additional Hamiltonians to be registered before execution.

Batch mode (with gradient): The Hamiltonian is registered and the process immediately transitions to ProcessState::ReadyToExecute because the parameter-shift rule requires exactly one observable.

In both batch cases Ok(None) is returned; call Process::execute followed by Process::read_exp_value to retrieve the results.

Errors

• KetError::ExpectationValueUnavailable: the process is in an incompatible state (e.g., already terminated or a sample request has been registered), or no execution backend is configured.

pub fn read_exp_value(&self) -> Option<&[f64]>

Returns a slice of the cached expectation-value results from the most recent execution, or None if no results are available yet.

The slice contains one value per Hamiltonian registered via Process::exp_value, in registration order.

pub fn read_gradient(&self) -> Option<&[f64]>

Returns a slice of the cached gradient values from the most recent execution, or None if gradient computation was not enabled or has not yet been performed.

The slice contains one value per registered parameter (in registration order). Each element is the partial derivative of the expectation value with respect to that parameter.

pub fn param(&mut self, param: f64) -> Param

Registers a new differentiable parameter with initial value param and returns a Param::Ref token for embedding in gate rotation angles.

pub fn execute(&mut self) -> Result<(), KetError>

Compiles and executes the accumulated circuit (batch mode only).

Errors

• KetError::NoPendingMeasurement: no sample or exp_value request has been registered before calling execute.
• KetError::ExplicitExecuteInLiveMode: the process is in live execution mode, where gates are dispatched immediately.

pub fn status(&self) -> ProcessState

Returns the current ProcessState of this process.

Trait Implementations

impl Debug for Process

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

Formats the value using the given formatter.