qamomile.qiskit

Qiskit backend for Qamomile.

Design intent: this package concretizes circuit’s abstract IR for Qiskit through QiskitMaterializer. QiskitTranspiler plugs the materializer into the shared compiler pipeline, while observable.py converts Hamiltonians to SparsePauliOp.

Constraints: depend only on qamomile.circuit public APIs plus the qiskit SDK — never on qamomile.optimization or other backends. Backend-specific lowering (decompositions, runtime control flow) belongs here at emit time, not in the IR; reuse circuit’s shared decomposition recipes as the fallback for gates without a native Qiskit equivalent.

Overview¶

Functions¶

hamiltonian_to_sparse_pauli_op [source]¶

def hamiltonian_to_sparse_pauli_op(hamiltonian: qm_o.Hamiltonian) -> 'SparsePauliOp'

Convert qamomile.observable.Hamiltonian to Qiskit SparsePauliOp.

Parameters:

Returns:

'SparsePauliOp' — Qiskit SparsePauliOp representation

Example:

import qamomile.observable as qm_o
from qamomile.qiskit.observable import hamiltonian_to_sparse_pauli_op

# Build Hamiltonian
H = qm_o.Z(0) * qm_o.Z(1) + 0.5 * (qm_o.X(0) + qm_o.X(1))

# Convert to Qiskit
sparse_pauli_op = hamiltonian_to_sparse_pauli_op(H)

Classes¶

QiskitExecutor [source]¶

class QiskitExecutor(QuantumExecutor['QuantumCircuit'])

Qiskit quantum executor using a safe local simulator or other backends.

Example:

executor = QiskitExecutor()  # Uses AerSimulator when available
counts = executor.execute(circuit, shots=1000)
# counts: {"00": 512, "11": 512}

# With expectation value estimation
from qamomile.qiskit.observable import QiskitExpectationEstimator
executor = QiskitExecutor(estimator=QiskitExpectationEstimator())
exp_val = executor.estimate(circuit, observable)

Constructor¶

def __init__(self, backend: Any = None, estimator: Any = None)

Initialize executor with backend and optional estimator.

Parameters:

Attributes¶

• backend

Methods¶

bind_parameters¶

def bind_parameters(
    self,
    circuit: 'QuantumCircuit',
    bindings: dict[str, Any],
    parameter_metadata: ParameterMetadata,
) -> 'QuantumCircuit'

Bind parameter values to the Qiskit circuit.

Parameters:

Returns:

'QuantumCircuit' — New circuit with parameters bound

estimate¶

def estimate(
    self,
    circuit: 'QuantumCircuit',
    hamiltonian: 'qm_o.Hamiltonian',
    params: Sequence[float] | None = None,
) -> float

Estimate the expectation value of a Hamiltonian.

Parameters:

Returns:

float — The estimated expectation value

Raises:

• RuntimeError — If no estimator is configured

execute¶

def execute(self, circuit: 'QuantumCircuit', shots: int) -> dict[str, int]

Execute circuit and return bitstring counts.

Parameters:

Returns:

dict[str, int] — dict[str, int]: Dictionary mapping bitstrings to counts. A circuit dict[str, int] — without quantum or classical bits returns {"": shots}.

Raises:

• RuntimeError — If no Qiskit backend is available for execution, or if Aer would still receive an empty-parameter multiplexer after the workaround decomposition.

QiskitTranspiler [source]¶

class QiskitTranspiler(Transpiler['QuantumCircuit'])

Qiskit backend transpiler.

Converts Qamomile QKernels into Qiskit QuantumCircuits.

Parameters:

Example:

from qamomile.qiskit import QiskitTranspiler
import qamomile as qm

@qm.qkernel
def bell_state(q0: qm.Qubit, q1: qm.Qubit) -> tuple[qm.Bit, qm.Bit]:
    q0 = qm.h(q0)
    q0, q1 = qm.cx(q0, q1)
    return qm.measure(q0), qm.measure(q1)

transpiler = QiskitTranspiler()
circuit = transpiler.to_circuit(bell_state)
print(circuit.draw())

Constructor¶

def __init__(
    self,
    use_native_composite: bool = True,
    use_native_pauli_evolution: bool = True,
) -> None

Initialize the Qiskit transpiler.

Parameters:

Methods¶

executor¶

def executor(self, backend: Any = None) -> QiskitExecutor

Create a Qiskit executor.

Parameters:

Returns:

QiskitExecutor — Executor configured with the backend.

Submodules¶

• qamomile.qiskit.emitter

• qamomile.qiskit.materializer

• qamomile.qiskit.observable

• qamomile.qiskit.transpiler