qamomile.circuit.transpiler

qamomile.circuit.transpiler.capabilities¶

Backend capability definitions for transpiler optimization.

Overview¶

Classes¶

BackendCapability [source]¶

class BackendCapability(enum.Flag)

Capabilities that a backend may support natively.

Use these flags to indicate which composite gates and features a backend supports, allowing the transpiler to use native implementations when available.

Attributes¶

• BASIC_COMPOSITE

• CLASSICAL_FEEDFORWARD

• DYNAMIC_CIRCUITS

• FOR_LOOP

• FULL_COMPOSITE

• FULL_CONTROL_FLOW

• NATIVE_IQFT

• NATIVE_QFT

• NATIVE_QPE

• NONE

• WHILE_LOOP

CapableBackend [source]¶

class CapableBackend(Protocol)

Protocol for backends that declare their capabilities.

Implement this protocol in backend-specific EmitPass classes to enable capability-based optimizations.

Attributes¶

• capabilities: BackendCapability Return the capabilities this backend supports.

Methods¶

has_capability¶

def has_capability(self, cap: BackendCapability) -> bool

Check if this backend has a specific capability.

Parameters:

Returns:

bool — True if the backend has the capability, False otherwise.

qamomile.circuit.transpiler.classical_executor¶

Classical segment executor for Python-based classical operations.

Overview¶

Classes¶

BinOp [source]¶

class BinOp(BinaryOperationBase)

Binary arithmetic operation (ADD, SUB, MUL, DIV, FLOORDIV, POW).

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    kind: BinOpKind | None = None,
) -> None

Attributes¶

• kind: BinOpKind | None

• operation_kind: OperationKind

• signature: Signature

BinOpKind [source]¶

class BinOpKind(enum.Enum)

Attributes¶

• ADD

• DIV

• FLOORDIV

• MUL

• POW

• SUB

ClassicalExecutor [source]¶

class ClassicalExecutor

Executes classical segments in Python.

Methods¶

execute¶

def execute(self, segment: ClassicalSegment, context: ExecutionContext) -> dict[str, Any]

Execute classical operations and return outputs.

Interprets the operations list directly using Python.

ClassicalSegment [source]¶

class ClassicalSegment(Segment)

A segment of pure classical operations.

Contains arithmetic, comparisons, and control flow. Will be executed directly in Python.

Constructor¶

def __init__(
    self,
    operations: list[Operation] = list(),
    input_refs: list[str] = list(),
    output_refs: list[str] = list(),
) -> None

Attributes¶

• kind: SegmentKind

CompOp [source]¶

class CompOp(BinaryOperationBase)

Comparison operation (EQ, NEQ, LT, LE, GT, GE).

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    kind: CompOpKind | None = None,
) -> None

Attributes¶

• kind: CompOpKind | None

• operation_kind: OperationKind

• signature: Signature

CompOpKind [source]¶

class CompOpKind(enum.Enum)

Attributes¶

• EQ

• GE

• GT

• LE

• LT

• NEQ

CondOp [source]¶

class CondOp(BinaryOperationBase)

Conditional logical operation (AND, OR).

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    kind: CondOpKind | None = None,
) -> None

Attributes¶

• kind: CondOpKind | None

• operation_kind: OperationKind

• signature: Signature

CondOpKind [source]¶

class CondOpKind(enum.Enum)

Attributes¶

• AND

• OR

DecodeQFixedOperation [source]¶

class DecodeQFixedOperation(Operation)

Decode measured bits to float (classical operation).

This operation converts a sequence of classical bits from qubit measurements into a floating-point number using fixed-point encoding.

The decoding formula:

float_value = Σ bit[i] * 2^(int_bits - 1 - i)

For QPE phase (int_bits=0): float_value = 0.b0b1b2... = b00.5 + b10.25 + b2*0.125 + ...

Example:

bits = [1, 0, 1] with int_bits=0
→ 0.101 (binary) = 0.5 + 0.125 = 0.625

operands: [ArrayValue of bits (vec[bit])] results: [Float value]

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    num_bits: int = 0,
    int_bits: int = 0,
) -> None

Attributes¶

• int_bits: int

• num_bits: int

• operation_kind: OperationKind

• signature: Signature

ExecutionContext [source]¶

class ExecutionContext

Holds global state during program execution.

Constructor¶

def __init__(self, initial_bindings: dict[str, Any] | None = None)

Methods¶

get¶

def get(self, key: str) -> Any

get_many¶

def get_many(self, keys: list[str]) -> dict[str, Any]

has¶

def has(self, key: str) -> bool

set¶

def set(self, key: str, value: Any) -> None

update¶

def update(self, values: dict[str, Any]) -> None

ExecutionError [source]¶

class ExecutionError(QamomileCompileError)

Error during program execution.

NotOp [source]¶

class NotOp(Operation)

Constructor¶

def __init__(self, operands: list[Value] = list(), results: list[Value] = list()) -> None

Attributes¶

• input: Value

• operation_kind: OperationKind

• output: Value

• signature: Signature

Value [source]¶

class Value(Generic[T])

A typed value in the IR with SSA-style versioning.

Value represents a single typed value (qubit, float, int, bit, etc.) with support for:

• SSA versioning via uuid/logical_id

• Parameter binding

• Constant folding

• Array element tracking

Constructor¶

def __init__(
    self,
    type: T,
    name: str,
    version: int = 0,
    params: dict[str, Any] = dict(),
    uuid: str = (lambda: str(uuid.uuid4()))(),
    logical_id: str = (lambda: str(uuid.uuid4()))(),
    parent_array: ArrayValue | None = None,
    element_indices: tuple[Value, ...] = (),
) -> None

Attributes¶

• element_indices: tuple[Value, ...]

• logical_id: str

• name: str

• params: dict[str, Any]

• parent_array: ArrayValue | None

• type: T

• uuid: str

• version: int

Methods¶

get_cast_qubit_logical_ids¶

def get_cast_qubit_logical_ids(self) -> list[str] | None

Get the underlying qubit logical_ids for this cast value.

get_cast_qubit_uuids¶

def get_cast_qubit_uuids(self) -> list[str] | None

Get the underlying qubit UUIDs for this cast value.

get_cast_source_logical_id¶

def get_cast_source_logical_id(self) -> str | None

Get the source value logical_id if this is a cast result.

get_cast_source_uuid¶

def get_cast_source_uuid(self) -> str | None

Get the source value UUID if this is a cast result.

get_const¶

def get_const(self) -> int | float | None

Get constant value if available, otherwise None.

get_lowered_bits¶

def get_lowered_bits(self) -> list[Value] | None

Get lowered bit list if available, otherwise None.

get_lowered_qubits¶

def get_lowered_qubits(self) -> list[Value] | None

Get lowered qubit list if available, otherwise None.

is_array_element¶

def is_array_element(self) -> bool

Check if this value is an element of an array.

is_cast_result¶

def is_cast_result(self) -> bool

Check if this value is the result of a CastOperation.

is_constant¶

def is_constant(self) -> bool

Check if this value is a constant.

is_parameter¶

def is_parameter(self) -> bool

Check if this value is an unbound parameter.

next_version¶

def next_version(self) -> Value[T]

Create a new Value with incremented version (SSA style).

parameter_name¶

def parameter_name(self) -> str | None

Get the parameter name if this is a parameter, otherwise None.

set_cast_metadata¶

def set_cast_metadata(
    self,
    source_uuid: str,
    qubit_uuids: list[str],
    source_logical_id: str | None = None,
    qubit_logical_ids: list[str] | None = None,
) -> None

Set cast metadata for this value.

set_lowered_bits¶

def set_lowered_bits(self, bits: list[Value]) -> None

Set lowered bit list.

set_lowered_qubits¶

def set_lowered_qubits(self, qubits: list[Value]) -> None

Set lowered qubit list.

qamomile.circuit.transpiler.compile_check¶

Overview¶

Functions¶

is_block_compilable [source]¶

def is_block_compilable(block: BlockValue) -> bool

Check if a BlockValue is compilable.

A BlockValue is considered compilable if all its operations are compilable. This function checks each operation in the block’s operations list.

Parameters:

Returns: bool: True if the block is compilable, False otherwise.

Classes¶

BlockValue [source]¶

class BlockValue(Value[BlockType])

Represents a subroutine as a function block.

def func_block(a: UInt, b: UInt) -> tuple[UInt]: ...

BlockValue( name=“func_block”, inputs_type={“a”: UIntType(), “b”: UIntType()}, outputs_type=(UIntType(), ), operations=[...], )

Function to BlockValue conversion can be done via func_to_block function. Each Values in operations are dummy values. The execution of the BlockValue is corresponding to the BlockOperation.

Constructor¶

def __init__(
    self,
    type: BlockType = BlockType(),
    name: str = '',
    version: int = 0,
    params: dict[str, Any] = dict(),
    uuid: str = (lambda: str(uuid.uuid4()))(),
    logical_id: str = (lambda: str(uuid.uuid4()))(),
    parent_array: ArrayValue | None = None,
    element_indices: tuple[Value, ...] = (),
    label_args: list[str] = list(),
    input_values: list[Value] = list(),
    return_values: list[Value] = list(),
    operations: list[Operation] = list(),
) -> None

Attributes¶

• input_values: list[Value]

• label_args: list[str]

• name: str

• operations: list[Operation]

• return_values: list[Value]

• type: BlockType

Methods¶

call¶

def call(self, **kwargs: Value = {}) -> 'CallBlockOperation'

Create a CallBlockOperation to call this BlockValue.

Example:

block_value = BlockValue(
    name="func_block",
    inputs_type={"a": UIntType(), "b": UIntType()},
    outputs_type=(UIntType(), ),
    operations=[...],
)
a = Value(UIntType())
b = Value(UIntType())
call_op = block_value.call(a=a, b=b)

qamomile.circuit.transpiler.compiled_segments¶

Compiled segment structures for transpiled quantum circuits.

Overview¶

Classes¶

ClassicalSegment [source]¶

class ClassicalSegment(Segment)

A segment of pure classical operations.

Contains arithmetic, comparisons, and control flow. Will be executed directly in Python.

Constructor¶

def __init__(
    self,
    operations: list[Operation] = list(),
    input_refs: list[str] = list(),
    output_refs: list[str] = list(),
) -> None

Attributes¶

• kind: SegmentKind

CompiledClassicalSegment [source]¶

class CompiledClassicalSegment

A classical segment ready for Python execution.

Constructor¶

def __init__(self, segment: ClassicalSegment) -> None

Attributes¶

• segment: ClassicalSegment

CompiledExpvalSegment [source]¶

class CompiledExpvalSegment

A compiled expectation value segment with concrete Hamiltonian.

This segment computes <psi|H|psi> where psi is the quantum state from a quantum circuit and H is a qamomile.observable.Hamiltonian.

Constructor¶

def __init__(
    self,
    segment: ExpvalSegment,
    hamiltonian: 'qm_o.Hamiltonian',
    quantum_segment_index: int = 0,
    result_ref: str = '',
    qubit_map: dict[int, int] = dict(),
) -> None

Attributes¶

• hamiltonian: ‘qm_o.Hamiltonian’

• quantum_segment_index: int

• qubit_map: dict[int, int]

• result_ref: str

• segment: ExpvalSegment

CompiledQuantumSegment [source]¶

class CompiledQuantumSegment(Generic[T])

A quantum segment with emitted backend circuit.

Constructor¶

def __init__(
    self,
    segment: QuantumSegment,
    circuit: T,
    qubit_map: dict[str, int] = dict(),
    clbit_map: dict[str, int] = dict(),
    measurement_qubit_map: dict[int, int] = dict(),
    parameter_metadata: ParameterMetadata = ParameterMetadata(),
) -> None

Attributes¶

• circuit: T

• clbit_map: dict[str, int]

• measurement_qubit_map: dict[int, int]

• parameter_metadata: ParameterMetadata

• qubit_map: dict[str, int]

• segment: QuantumSegment

ExpvalSegment [source]¶

class ExpvalSegment(Segment)

A segment for expectation value computation.

Represents computing <psi|H|psi> where psi is the quantum state and H is a Hamiltonian observable.

This segment bridges a quantum circuit (state preparation) to a classical expectation value.

Constructor¶

def __init__(
    self,
    operations: list[Operation] = list(),
    input_refs: list[str] = list(),
    output_refs: list[str] = list(),
    hamiltonian_value: Value | None = None,
    qubits_value: Value | None = None,
    result_ref: str = '',
) -> None

Attributes¶

• hamiltonian_value: Value | None

• kind: SegmentKind

• qubits_value: Value | None

• result_ref: str

ParameterMetadata [source]¶

class ParameterMetadata

Metadata for all parameters in a compiled segment.

Tracks parameter information for runtime binding.

Constructor¶

def __init__(self, parameters: list[ParameterInfo] = list()) -> None

Attributes¶

• parameters: list[ParameterInfo]

Methods¶

get_array_names¶

def get_array_names(self) -> set[str]

Get unique array/scalar parameter names.

get_ordered_params¶

def get_ordered_params(self) -> list[Any]

Get backend parameter objects in definition order.

Useful for backends that require positional parameter binding (e.g., QURI Parts).

Returns:

list[Any] — List of backend_param objects in the order they were defined.

Example:

# For QURI Parts that uses positional binding:
param_values = [bindings[p.name] for p in metadata.parameters]
bound_circuit = circuit.bind_parameters(param_values)

get_param_by_name¶

def get_param_by_name(self, name: str) -> ParameterInfo | None

Get parameter info by full name.

to_binding_dict¶

def to_binding_dict(self, bindings: dict[str, Any]) -> dict[Any, Any]

Convert indexed bindings to backend parameter bindings.

Transforms user-provided bindings (with indexed names like “gammas[0]”) into a dictionary mapping backend parameter objects to values. Useful for backends that use dict-based parameter binding (e.g., Qiskit).

Parameters:

Returns:

dict[Any, Any] — Dictionary mapping backend_param objects to values.

Example:

# For Qiskit that uses dict-based binding:
qiskit_bindings = metadata.to_binding_dict(bindings)
bound_circuit = circuit.assign_parameters(qiskit_bindings)

QuantumSegment [source]¶

class QuantumSegment(Segment)

A segment of pure quantum operations.

Contains quantum gates and qubit allocations. Will be emitted to a quantum circuit.

Constructor¶

def __init__(
    self,
    operations: list[Operation] = list(),
    input_refs: list[str] = list(),
    output_refs: list[str] = list(),
    qubit_values: list[Value] = list(),
    num_qubits: int = 0,
) -> None

Attributes¶

• kind: SegmentKind

• num_qubits: int

• qubit_values: list[Value]

qamomile.circuit.transpiler.emitter¶

qamomile.circuit.transpiler.emitter.emitter¶

Overview¶

Classes¶

BlockValue [source]¶

class BlockValue(Value[BlockType])

Represents a subroutine as a function block.

def func_block(a: UInt, b: UInt) -> tuple[UInt]: ...

BlockValue( name=“func_block”, inputs_type={“a”: UIntType(), “b”: UIntType()}, outputs_type=(UIntType(), ), operations=[...], )

Function to BlockValue conversion can be done via func_to_block function. Each Values in operations are dummy values. The execution of the BlockValue is corresponding to the BlockOperation.

Constructor¶

def __init__(
    self,
    type: BlockType = BlockType(),
    name: str = '',
    version: int = 0,
    params: dict[str, Any] = dict(),
    uuid: str = (lambda: str(uuid.uuid4()))(),
    logical_id: str = (lambda: str(uuid.uuid4()))(),
    parent_array: ArrayValue | None = None,
    element_indices: tuple[Value, ...] = (),
    label_args: list[str] = list(),
    input_values: list[Value] = list(),
    return_values: list[Value] = list(),
    operations: list[Operation] = list(),
) -> None

Attributes¶

• input_values: list[Value]

• label_args: list[str]

• name: str

• operations: list[Operation]

• return_values: list[Value]

• type: BlockType

Methods¶

call¶

def call(self, **kwargs: Value = {}) -> 'CallBlockOperation'

Create a CallBlockOperation to call this BlockValue.

Example:

block_value = BlockValue(
    name="func_block",
    inputs_type={"a": UIntType(), "b": UIntType()},
    outputs_type=(UIntType(), ),
    operations=[...],
)
a = Value(UIntType())
b = Value(UIntType())
call_op = block_value.call(a=a, b=b)

EmitResult [source]¶

class EmitResult(abc.ABC, Generic[T])

Attributes¶

• circuit: T

Emitter [source]¶

class Emitter(abc.ABC, Generic[T])

Constructor¶

def __init__(
    self,
    block: BlockValue,
    bind: dict[str, int | float | list[int] | list[float]],
) -> None

Attributes¶

• bind

• block

Methods¶

emit¶

def emit(self, block: BlockValue) -> EmitResult[T]

qamomile.circuit.transpiler.errors¶

Compilation error classes for Qamomile transpiler.

Overview¶

Classes¶

AffineTypeError [source]¶

class AffineTypeError(QamomileCompileError)

Base class for affine type violations.

Affine types enforce that quantum resources (qubits) are used at most once. This prevents common errors such as reusing a consumed qubit or aliasing.

Constructor¶

def __init__(
    self,
    message: str,
    handle_name: str | None = None,
    operation_name: str | None = None,
    first_use_location: str | None = None,
)

Attributes¶

• first_use_location

• handle_name

• operation_name

DependencyError [source]¶

class DependencyError(QamomileCompileError)

Error when quantum operation depends on non-parameter classical value.

This error indicates that the program requires JIT compilation which is not yet supported.

Constructor¶

def __init__(
    self,
    message: str,
    quantum_op: str | None = None,
    classical_value: str | None = None,
)

Attributes¶

• classical_value

• quantum_op

EmitError [source]¶

class EmitError(QamomileCompileError)

Error during backend code emission.

Constructor¶

def __init__(self, message: str, operation: str | None = None)

Attributes¶

• operation

ExecutionError [source]¶

class ExecutionError(QamomileCompileError)

Error during program execution.

InliningError [source]¶

class InliningError(QamomileCompileError)

Error during inline pass (inlining CallBlockOperations).

OperandResolutionInfo [source]¶

class OperandResolutionInfo

Detailed information about a single operand that failed to resolve.

Constructor¶

def __init__(
    self,
    operand_name: str,
    operand_uuid: str,
    is_array_element: bool,
    parent_array_name: str | None,
    element_indices_names: list[str],
    failure_reason: ResolutionFailureReason,
    failure_details: str,
) -> None

Attributes¶

• element_indices_names: list[str]

• failure_details: str

• failure_reason: ResolutionFailureReason

• is_array_element: bool

• operand_name: str

• operand_uuid: str

• parent_array_name: str | None

QamomileCompileError [source]¶

class QamomileCompileError(Exception)

Base class for all Qamomile compilation errors.

QubitAliasError [source]¶

class QubitAliasError(AffineTypeError)

Same qubit used multiple times in one operation.

Operations like cx() require distinct qubits for control and target. Using the same qubit in both positions is physically impossible and indicates a programming error.

Example of incorrect code:

q1, q2 = qm.cx(q, q) # ERROR: same qubit as control and target

Correct code:

q1, q2 = qm.cx(control, target) # Use distinct qubits

QubitConsumedError [source]¶

class QubitConsumedError(AffineTypeError)

Qubit handle used after being consumed by a previous operation.

Each qubit handle can only be used once. After a gate operation, you must reassign the result to use the new handle.

Example of incorrect code:

q1 = qm.h(q) q2 = qm.x(q) # ERROR: q was already consumed by h()

Correct code:

q = qm.h(q) # Reassign to capture new handle q = qm.x(q) # Use the reassigned handle

QubitIndexResolutionError [source]¶

class QubitIndexResolutionError(EmitError)

Error when qubit indices cannot be resolved during emission.

This error provides detailed diagnostic information about why qubit index resolution failed and suggests remediation steps.

Constructor¶

def __init__(
    self,
    gate_type: str,
    operand_infos: list[OperandResolutionInfo],
    available_bindings_keys: list[str],
    available_qubit_map_keys: list[str],
)

Attributes¶

• available_bindings_keys

• available_qubit_map_keys

• gate_type

• operand_infos

QubitRebindError [source]¶

class QubitRebindError(AffineTypeError)

Quantum variable reassigned from a different quantum source.

When a quantum variable is reassigned, the RHS must consume the same variable (self-update pattern). Reassigning from a different quantum variable silently discards the original quantum state.

Example of incorrect code:

a = qm.h(b) # ERROR: ‘a’ was quantum, now overwritten from ‘b’ a = b # ERROR: ‘a’ was quantum, now overwritten from ‘b’

Correct patterns:

a = qm.h(a) # Self-update (OK) new = qm.h(b) # New binding (OK, ‘new’ wasn’t quantum before)

ResolutionFailureReason [source]¶

class ResolutionFailureReason(Enum)

Categorizes why qubit index resolution failed.

Attributes¶

• ARRAY_ELEMENT_NOT_IN_QUBIT_MAP

• DIRECT_UUID_NOT_FOUND

• INDEX_NOT_NUMERIC

• NESTED_ARRAY_RESOLUTION_FAILED

• SYMBOLIC_INDEX_NOT_BOUND

• UNKNOWN

SeparationError [source]¶

class SeparationError(QamomileCompileError)

Error during quantum/classical separation.

UnreturnedBorrowError [source]¶

class UnreturnedBorrowError(AffineTypeError)

Borrowed array element not returned before array use.

When you borrow an element from a qubit array, you must return it (write it back) before using other elements or the array itself.

Example of incorrect code:

q0 = qubits[0] q0 = qm.h(q0) q1 = qubits[1] # ERROR: q0 not returned yet

Correct code:

q0 = qubits[0] q0 = qm.h(q0) qubits[0] = q0 # Return the borrowed element q1 = qubits[1] # Now safe to borrow another

ValidationError [source]¶

class ValidationError(QamomileCompileError)

Error during validation (e.g., non-classical I/O).

Constructor¶

def __init__(self, message: str, value_name: str | None = None)

Attributes¶

• value_name

qamomile.circuit.transpiler.executable¶

Executable program structure for compiled quantum-classical programs.

Overview¶

Classes¶

ClassicalExecutor [source]¶

class ClassicalExecutor

Executes classical segments in Python.

Methods¶

execute¶

def execute(self, segment: ClassicalSegment, context: ExecutionContext) -> dict[str, Any]

Execute classical operations and return outputs.

Interprets the operations list directly using Python.

CompiledClassicalSegment [source]¶

class CompiledClassicalSegment

A classical segment ready for Python execution.

Constructor¶

def __init__(self, segment: ClassicalSegment) -> None

Attributes¶

• segment: ClassicalSegment

CompiledExpvalSegment [source]¶

class CompiledExpvalSegment

A compiled expectation value segment with concrete Hamiltonian.

This segment computes <psi|H|psi> where psi is the quantum state from a quantum circuit and H is a qamomile.observable.Hamiltonian.

Constructor¶

def __init__(
    self,
    segment: ExpvalSegment,
    hamiltonian: 'qm_o.Hamiltonian',
    quantum_segment_index: int = 0,
    result_ref: str = '',
    qubit_map: dict[int, int] = dict(),
) -> None

Attributes¶

• hamiltonian: ‘qm_o.Hamiltonian’

• quantum_segment_index: int

• qubit_map: dict[int, int]

• result_ref: str

• segment: ExpvalSegment

CompiledQuantumSegment [source]¶

class CompiledQuantumSegment(Generic[T])

A quantum segment with emitted backend circuit.

Constructor¶

def __init__(
    self,
    segment: QuantumSegment,
    circuit: T,
    qubit_map: dict[str, int] = dict(),
    clbit_map: dict[str, int] = dict(),
    measurement_qubit_map: dict[int, int] = dict(),
    parameter_metadata: ParameterMetadata = ParameterMetadata(),
) -> None

Attributes¶

• circuit: T

• clbit_map: dict[str, int]

• measurement_qubit_map: dict[int, int]

• parameter_metadata: ParameterMetadata

• qubit_map: dict[str, int]

• segment: QuantumSegment

ExecutableProgram [source]¶

class ExecutableProgram(Generic[T])

A fully compiled program ready for execution.

This is the Orchestrator - manages execution of mixed classical/quantum programs.

Example:

executable = transpiler.compile(kernel)

# Sample: multiple shots, returns counts
job = executable.sample(executor, shots=1000)
result = job.result()  # SampleResult with counts

# Run: single shot, returns typed result
job = executable.run(executor)
result = job.result()  # Returns kernel's return type

Constructor¶

def __init__(
    self,
    compiled_quantum: list[CompiledQuantumSegment[T]] = list(),
    compiled_classical: list[CompiledClassicalSegment] = list(),
    compiled_expval: list[CompiledExpvalSegment] = list(),
    execution_order: list[tuple[str, int]] = list(),
    output_refs: list[str] = list(),
    num_output_bits: int = 0,
) -> None

Attributes¶

• compiled_classical: list[CompiledClassicalSegment]

• compiled_expval: list[CompiledExpvalSegment]

• compiled_quantum: list[CompiledQuantumSegment[T]]

• execution_order: list[tuple[str, int]]

• has_parameters: bool Check if this program has unbound parameters.

• num_output_bits: int

• output_refs: list[str]

• parameter_names: list[str] Get list of parameter names that need binding.

• quantum_circuit: T Get the single quantum circuit.

Methods¶

get_circuits¶

def get_circuits(self) -> list[T]

Get all quantum circuits in execution order.

get_first_circuit¶

def get_first_circuit(self) -> T | None

Get the first quantum circuit, or None if no quantum segments.

run¶

def run(
    self,
    executor: QuantumExecutor[T],
    bindings: dict[str, Any] | None = None,
) -> RunJob[Any] | ExpvalJob

Execute once and return single result.

Parameters:

Returns:

RunJob[Any] | ExpvalJob — RunJob that resolves to the kernel’s return type, or RunJob[Any] | ExpvalJob — ExpvalJob if the program contains expectation value computation.

Raises:

• ExecutionError — If no quantum circuit to execute

• ValueError — If required parameters are missing

Example:

job = executable.run(executor, bindings={"gamma": [0.5]})
result = job.result()
print(result)  # 0.25 (for QFixed) or (0, 1) (for bits)

sample¶

def sample(
    self,
    executor: QuantumExecutor[T],
    shots: int = 1024,
    bindings: dict[str, Any] | None = None,
) -> SampleJob[Any]

Execute with multiple shots and return counts.

Parameters:

Returns:

SampleJob[Any] — SampleJob that resolves to SampleResult with results.

Raises:

• ExecutionError — If no quantum circuit to execute

• ValueError — If required parameters are missing

Example:

job = executable.sample(executor, shots=1000, bindings={"gamma": [0.5]})
result = job.result()
print(result.results)  # [(0.25, 500), (0.75, 500)]

ExecutionContext [source]¶

class ExecutionContext

Holds global state during program execution.

Constructor¶

def __init__(self, initial_bindings: dict[str, Any] | None = None)

Methods¶

get¶

def get(self, key: str) -> Any

get_many¶

def get_many(self, keys: list[str]) -> dict[str, Any]

has¶

def has(self, key: str) -> bool

set¶

def set(self, key: str, value: Any) -> None

update¶

def update(self, values: dict[str, Any]) -> None

ExecutionError [source]¶

class ExecutionError(QamomileCompileError)

Error during program execution.

ExpvalJob [source]¶

class ExpvalJob(Job[float])

Job for expectation value computation.

Returns a single float representing <psi|H|psi>.

Constructor¶

def __init__(self, exp_val: float)

Initialize expval job.

Parameters:

Methods¶

result¶

def result(self) -> float

Return the expectation value.

status¶

def status(self) -> JobStatus

Return job status.

ParameterInfo [source]¶

class ParameterInfo

Information about a single unbound parameter in the circuit.

Constructor¶

def __init__(
    self,
    name: str,
    array_name: str,
    index: int | None,
    backend_param: Any,
) -> None

Attributes¶

• array_name: str

• backend_param: Any

• index: int | None

• name: str

ParameterMetadata [source]¶

class ParameterMetadata

Metadata for all parameters in a compiled segment.

Tracks parameter information for runtime binding.

Constructor¶

def __init__(self, parameters: list[ParameterInfo] = list()) -> None

Attributes¶

• parameters: list[ParameterInfo]

Methods¶

get_array_names¶

def get_array_names(self) -> set[str]

Get unique array/scalar parameter names.

get_ordered_params¶

def get_ordered_params(self) -> list[Any]

Get backend parameter objects in definition order.

Useful for backends that require positional parameter binding (e.g., QURI Parts).

Returns:

list[Any] — List of backend_param objects in the order they were defined.

Example:

# For QURI Parts that uses positional binding:
param_values = [bindings[p.name] for p in metadata.parameters]
bound_circuit = circuit.bind_parameters(param_values)

get_param_by_name¶

def get_param_by_name(self, name: str) -> ParameterInfo | None

Get parameter info by full name.

to_binding_dict¶

def to_binding_dict(self, bindings: dict[str, Any]) -> dict[Any, Any]

Convert indexed bindings to backend parameter bindings.

Transforms user-provided bindings (with indexed names like “gammas[0]”) into a dictionary mapping backend parameter objects to values. Useful for backends that use dict-based parameter binding (e.g., Qiskit).

Parameters:

Returns:

dict[Any, Any] — Dictionary mapping backend_param objects to values.

Example:

# For Qiskit that uses dict-based binding:
qiskit_bindings = metadata.to_binding_dict(bindings)
bound_circuit = circuit.assign_parameters(qiskit_bindings)

QuantumExecutor [source]¶

class QuantumExecutor(ABC, Generic[T])

Abstract base class for quantum backend execution.

To implement a custom executor:

1. execute() [Required] Execute circuit and return bitstring counts as dict[str, int]. Keys are bitstrings in big-endian format (e.g., “011” means q2=0, q1=1, q0=1).

2. bind_parameters() [Optional] Bind parameter values to parametric circuits. Override if your executor supports parametric circuits (e.g., QAOA variational circuits). Use ParameterMetadata.to_binding_dict() for easy conversion.

3. estimate() [Optional] Compute expectation values <psi|H|psi>. Override if your executor supports estimation primitives (e.g., Qiskit Estimator, QURI Parts).

Example (Minimal): class MyExecutor(QuantumExecutor[QuantumCircuit]): def init(self): from qiskit_aer import AerSimulator self.backend = AerSimulator()

    def execute(self, circuit, shots):
        from qiskit import transpile
        if circuit.num_clbits == 0:
            circuit = circuit.copy()
            circuit.measure_all()
        transpiled = transpile(circuit, self.backend)
        return self.backend.run(transpiled, shots=shots).result().get_counts()

Example (With Parameter Binding): def bind_parameters(self, circuit, bindings, metadata): # metadata.to_binding_dict() converts indexed names to backend params return circuit.assign_parameters(metadata.to_binding_dict(bindings))

Methods¶

bind_parameters¶

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

Bind parameter values to the circuit.

Default implementation returns the circuit unchanged. Override for backends that support parametric circuits.

Parameters:

Returns:

T — New circuit with parameters bound

estimate¶

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

Estimate the expectation value of a Hamiltonian.

This method computes <psi|H|psi> where psi is the quantum state prepared by the circuit and H is the Hamiltonian.

Backends can override this method to provide optimized implementations using their native estimator primitives.

Parameters:

Returns:

float — The estimated expectation value

Raises:

• NotImplementedError — If the executor does not support estimation

execute¶

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

Execute the circuit and return bitstring counts.

Parameters:

Returns:

dict[str, int] — Dictionary mapping bitstrings to counts. dict[str, int] — {“00”: 512, “11”: 512}

RunJob [source]¶

class RunJob(Job[T], Generic[T])

Job for single execution.

Returns a single result value matching the kernel’s return type.

Constructor¶

def __init__(self, raw_counts: dict[str, int], result_converter: Callable[[str], T])

Initialize run job.

Parameters:

Methods¶

result¶

def result(self) -> T

Return the single result.

status¶

def status(self) -> JobStatus

Return job status.

SampleJob [source]¶

class SampleJob(Job[SampleResult[T]], Generic[T])

Job for sampling execution (multiple shots).

Returns a SampleResult containing counts for each unique result.

Constructor¶

def __init__(
    self,
    raw_counts: dict[str, int],
    result_converter: Callable[[dict[str, int]], list[tuple[T, int]]],
    shots: int,
)

Initialize sample job.

Parameters:

Methods¶

result¶

def result(self) -> SampleResult[T]

Return the sample result.

status¶

def status(self) -> JobStatus

Return job status.

qamomile.circuit.transpiler.execution_context¶

Execution context for quantum-classical program execution.

Overview¶

Classes¶

ExecutionContext [source]¶

class ExecutionContext

Holds global state during program execution.

Constructor¶

def __init__(self, initial_bindings: dict[str, Any] | None = None)

Methods¶

get¶

def get(self, key: str) -> Any

get_many¶

def get_many(self, keys: list[str]) -> dict[str, Any]

has¶

def has(self, key: str) -> bool

set¶

def set(self, key: str, value: Any) -> None

update¶

def update(self, values: dict[str, Any]) -> None

qamomile.circuit.transpiler.gate_emitter¶

GateEmitter protocol for backend-agnostic gate emission.

This module defines the GateEmitter protocol that backends implement to emit individual quantum gates. The StandardEmitPass uses this protocol to orchestrate circuit generation without backend-specific code.

Overview¶

Constants¶

• GATE_SPECS: dict[GateKind, GateSpec]

Classes¶

GateEmitter [source]¶

class GateEmitter(Protocol[T])

Protocol for backend-specific gate emission.

Each backend implements this protocol to emit individual gates to their circuit representation.

Type parameter T is the backend’s circuit type (e.g., QuantumCircuit).

Methods¶

append_gate¶

def append_gate(self, circuit: T, gate: Any, qubits: list[int]) -> None

Append a gate to the circuit.

Parameters:

circuit_to_gate¶

def circuit_to_gate(self, circuit: T, name: str = 'U') -> Any

Convert a circuit to a reusable gate.

Parameters:

Returns:

Any — Backend-specific gate object, or None if not supported

create_circuit¶

def create_circuit(self, num_qubits: int, num_clbits: int) -> T

Create a new empty circuit.

Parameters:

Returns:

T — A new backend-specific circuit object

create_parameter¶

def create_parameter(self, name: str) -> Any

Create a symbolic parameter for the backend.

Parameters:

Returns:

Any — Backend-specific parameter object

emit_barrier¶

def emit_barrier(self, circuit: T, qubits: list[int]) -> None

Emit barrier on specified qubits.

emit_ch¶

def emit_ch(self, circuit: T, control: int, target: int) -> None

Emit controlled-Hadamard gate.

emit_cp¶

def emit_cp(self, circuit: T, control: int, target: int, angle: float | Any) -> None

Emit controlled-Phase gate.

emit_crx¶

def emit_crx(self, circuit: T, control: int, target: int, angle: float | Any) -> None

Emit controlled-RX gate.

emit_cry¶

def emit_cry(self, circuit: T, control: int, target: int, angle: float | Any) -> None

Emit controlled-RY gate.

emit_crz¶

def emit_crz(self, circuit: T, control: int, target: int, angle: float | Any) -> None

Emit controlled-RZ gate.

emit_cx¶

def emit_cx(self, circuit: T, control: int, target: int) -> None

Emit CNOT gate.

emit_cy¶

def emit_cy(self, circuit: T, control: int, target: int) -> None

Emit controlled-Y gate.

emit_cz¶

def emit_cz(self, circuit: T, control: int, target: int) -> None

Emit CZ gate.

emit_else_start¶

def emit_else_start(self, circuit: T, context: Any) -> None

Start the else branch.

emit_for_loop_end¶

def emit_for_loop_end(self, circuit: T, context: Any) -> None

End a native for loop context.

emit_for_loop_start¶

def emit_for_loop_start(self, circuit: T, indexset: range) -> Any

Start a native for loop context.

Returns a context manager or loop parameter, depending on backend.

emit_h¶

def emit_h(self, circuit: T, qubit: int) -> None

Emit Hadamard gate.

emit_if_end¶

def emit_if_end(self, circuit: T, context: Any) -> None

End the if/else block.

emit_if_start¶

def emit_if_start(self, circuit: T, clbit: int, value: int = 1) -> Any

Start a native if context.

Returns context for the if/else block.

emit_measure¶

def emit_measure(self, circuit: T, qubit: int, clbit: int) -> None

Emit measurement operation.

emit_p¶

def emit_p(self, circuit: T, qubit: int, angle: float | Any) -> None

Emit Phase gate (P(θ) = diag(1, e^(iθ))).

emit_rx¶

def emit_rx(self, circuit: T, qubit: int, angle: float | Any) -> None

Emit RX rotation gate.

Parameters:

emit_ry¶

def emit_ry(self, circuit: T, qubit: int, angle: float | Any) -> None

Emit RY rotation gate.

emit_rz¶

def emit_rz(self, circuit: T, qubit: int, angle: float | Any) -> None

Emit RZ rotation gate.

emit_rzz¶

def emit_rzz(self, circuit: T, qubit1: int, qubit2: int, angle: float | Any) -> None

Emit RZZ gate (exp(-i * θ/2 * Z⊗Z)).

emit_s¶

def emit_s(self, circuit: T, qubit: int) -> None

Emit S gate (√Z).

emit_sdg¶

def emit_sdg(self, circuit: T, qubit: int) -> None

Emit S-dagger gate (inverse of S).

emit_swap¶

def emit_swap(self, circuit: T, qubit1: int, qubit2: int) -> None

Emit SWAP gate.

emit_t¶

def emit_t(self, circuit: T, qubit: int) -> None

Emit T gate (√S).

emit_tdg¶

def emit_tdg(self, circuit: T, qubit: int) -> None

Emit T-dagger gate (inverse of T).

emit_toffoli¶

def emit_toffoli(self, circuit: T, control1: int, control2: int, target: int) -> None

Emit Toffoli (CCX) gate.

emit_while_end¶

def emit_while_end(self, circuit: T, context: Any) -> None

End the while loop context.

emit_while_start¶

def emit_while_start(self, circuit: T, clbit: int, value: int = 1) -> Any

Start a native while loop context.

emit_x¶

def emit_x(self, circuit: T, qubit: int) -> None

Emit Pauli-X gate.

emit_y¶

def emit_y(self, circuit: T, qubit: int) -> None

Emit Pauli-Y gate.

emit_z¶

def emit_z(self, circuit: T, qubit: int) -> None

Emit Pauli-Z gate.

gate_controlled¶

def gate_controlled(self, gate: Any, num_controls: int) -> Any

Create controlled version of a gate.

Parameters:

Returns:

Any — New controlled gate

gate_power¶

def gate_power(self, gate: Any, power: int) -> Any

Create gate raised to a power (U^n).

Parameters:

Returns:

Any — New gate representing gate^power

supports_for_loop¶

def supports_for_loop(self) -> bool

Check if backend supports native for loops.

supports_if_else¶

def supports_if_else(self) -> bool

Check if backend supports native if/else.

supports_while_loop¶

def supports_while_loop(self) -> bool

Check if backend supports native while loops.

GateKind [source]¶

class GateKind(Enum)

Classification of gates for emission.

Attributes¶

• CH

• CP

• CRX

• CRY

• CRZ

• CX

• CY

• CZ

• H

• MEASURE

• P

• RX

• RY

• RZ

• RZZ

• S

• SDG

• SWAP

• T

• TDG

• TOFFOLI

• X

• Y

• Z

GateSpec [source]¶

class GateSpec

Specification for a gate type.

Constructor¶

def __init__(
    self,
    kind: GateKind,
    num_qubits: int,
    has_angle: bool = False,
    num_controls: int = 0,
) -> None

Attributes¶

• has_angle: bool

• kind: GateKind

• num_controls: int

• num_qubits: int

qamomile.circuit.transpiler.job¶

Job classes for quantum execution results.

Overview¶

Classes¶

ExpvalJob [source]¶

class ExpvalJob(Job[float])

Job for expectation value computation.

Returns a single float representing <psi|H|psi>.

Constructor¶

def __init__(self, exp_val: float)

Initialize expval job.

Parameters:

Methods¶

result¶

def result(self) -> float

Return the expectation value.

status¶

def status(self) -> JobStatus

Return job status.

Job [source]¶

class Job(ABC, Generic[T])

Abstract base class for quantum execution jobs.

A Job represents a quantum execution that can be awaited for results.

Methods¶

result¶

def result(self) -> T

Wait for and return the result.

Blocks until the job completes.

Returns:

T — The execution result with the appropriate type.

Raises:

• ExecutionError — If the job failed.

status¶

def status(self) -> JobStatus

Return the current job status.

JobStatus [source]¶

class JobStatus(Enum)

Status of a quantum job.

Attributes¶

• COMPLETED

• FAILED

• PENDING

• RUNNING

RunJob [source]¶

class RunJob(Job[T], Generic[T])

Job for single execution.

Returns a single result value matching the kernel’s return type.

Constructor¶

def __init__(self, raw_counts: dict[str, int], result_converter: Callable[[str], T])

Initialize run job.

Parameters:

Methods¶

result¶

def result(self) -> T

Return the single result.

status¶

def status(self) -> JobStatus

Return job status.

SampleJob [source]¶

class SampleJob(Job[SampleResult[T]], Generic[T])

Job for sampling execution (multiple shots).

Returns a SampleResult containing counts for each unique result.

Constructor¶

def __init__(
    self,
    raw_counts: dict[str, int],
    result_converter: Callable[[dict[str, int]], list[tuple[T, int]]],
    shots: int,
)

Initialize sample job.

Parameters:

Methods¶

result¶

def result(self) -> SampleResult[T]

Return the sample result.

status¶

def status(self) -> JobStatus

Return job status.

SampleResult [source]¶

class SampleResult(Generic[T])

Result of a sample() execution.

Contains results as a list of (value, count) tuples.

Example:

result.results  # [(0.25, 500), (0.75, 500)]

Constructor¶

def __init__(self, results: list[tuple[T, int]], shots: int) -> None

Attributes¶

• results: list[tuple[T, int]] List of (value, count) tuples.

• shots: int Total number of shots executed.

Methods¶

most_common¶

def most_common(self, n: int = 1) -> list[tuple[T, int]]

Return the n most common results.

Parameters:

Returns:

list[tuple[T, int]] — List of (result, count) tuples sorted by count descending.

probabilities¶

def probabilities(self) -> list[tuple[T, float]]

Return probability distribution over results.

Returns:

list[tuple[T, float]] — List of (value, probability) tuples.

qamomile.circuit.transpiler.orchestrator¶

Overview¶

Functions¶

separate_operations [source]¶

def separate_operations(
    operations: list[Operation],
    quantum_runnable_cls: type[QuantumRunnable],
    classical_runnable_cls: type[ClassicalRunnable],
) -> list[Runnable]

Classes¶

ClassicalRunnable [source]¶

class ClassicalRunnable(Runnable)

Operation [source]¶

class Operation(abc.ABC)

Constructor¶

def __init__(self, operands: list[Value] = list(), results: list[Value] = list()) -> None

Attributes¶

• operands: list[Value]

• operation_kind: OperationKind Return the kind of this operation for classical/quantum classification.

• results: list[Value]

• signature: Signature

OperationKind [source]¶

class OperationKind(enum.Enum)

Classification of operations for classical/quantum separation.

This enum is used to categorize operations during compilation to determine which parts run on classical hardware vs quantum hardware.

Values:

QUANTUM: Pure quantum operations (gates, qubit allocation) CLASSICAL: Pure classical operations (arithmetic, comparisons) HYBRID: Operations that bridge classical and quantum (measurement, encode/decode) CONTROL: Control flow structures (for, while, if)

Attributes¶

• CLASSICAL

• CONTROL

• HYBRID

• QUANTUM

Orchestrator [source]¶

class Orchestrator

Constructor¶

def __init__(
    self,
    global_variables: dict[str, float | int | bool | list] = dict(),
    operations: list[Runnable] = list(),
    return_ids: list[tuple[str, int]] = list(),
) -> None

Attributes¶

• global_variables: dict[str, float | int | bool | list]

• operations: list[Runnable]

• return_ids: list[tuple[str, int]]

Methods¶

run¶

def run(self, **kwargs = {})

QuantumRunnable [source]¶

class QuantumRunnable(Runnable)

Runnable [source]¶

class Runnable(abc.ABC)

Constructor¶

def __init__(self, operations: list) -> None

Attributes¶

• operations

Methods¶

input_args¶

def input_args(self) -> dict[str, int | float | bool | list]

reset_global_vars¶

def reset_global_vars(self)

return_assingnments¶

def return_assingnments(self, return_values: list) -> dict[str, int | float | bool | list]

run¶

def run(self, *args = (), **kwargs = {})

set_global_vars¶

def set_global_vars(self, global_vars: dict[str, int | float | bool | list])

qamomile.circuit.transpiler.parameter_binding¶

Parameter binding structures for compiled quantum circuits.

Overview¶

Classes¶

ParameterInfo [source]¶

class ParameterInfo

Information about a single unbound parameter in the circuit.

Constructor¶

def __init__(
    self,
    name: str,
    array_name: str,
    index: int | None,
    backend_param: Any,
) -> None

Attributes¶

• array_name: str

• backend_param: Any

• index: int | None

• name: str

ParameterMetadata [source]¶

class ParameterMetadata

Metadata for all parameters in a compiled segment.

Tracks parameter information for runtime binding.

Constructor¶

def __init__(self, parameters: list[ParameterInfo] = list()) -> None

Attributes¶

• parameters: list[ParameterInfo]

Methods¶

get_array_names¶

def get_array_names(self) -> set[str]

Get unique array/scalar parameter names.

get_ordered_params¶

def get_ordered_params(self) -> list[Any]

Get backend parameter objects in definition order.

Useful for backends that require positional parameter binding (e.g., QURI Parts).

Returns:

list[Any] — List of backend_param objects in the order they were defined.

Example:

# For QURI Parts that uses positional binding:
param_values = [bindings[p.name] for p in metadata.parameters]
bound_circuit = circuit.bind_parameters(param_values)

get_param_by_name¶

def get_param_by_name(self, name: str) -> ParameterInfo | None

Get parameter info by full name.

to_binding_dict¶

def to_binding_dict(self, bindings: dict[str, Any]) -> dict[Any, Any]

Convert indexed bindings to backend parameter bindings.

Transforms user-provided bindings (with indexed names like “gammas[0]”) into a dictionary mapping backend parameter objects to values. Useful for backends that use dict-based parameter binding (e.g., Qiskit).

Parameters:

Returns:

dict[Any, Any] — Dictionary mapping backend_param objects to values.

Example:

# For Qiskit that uses dict-based binding:
qiskit_bindings = metadata.to_binding_dict(bindings)
bound_circuit = circuit.assign_parameters(qiskit_bindings)

qamomile.circuit.transpiler.passes¶

Base classes for compiler passes.

Overview¶

Classes¶

AffineTypeError [source]¶

class AffineTypeError(QamomileCompileError)

Base class for affine type violations.

Affine types enforce that quantum resources (qubits) are used at most once. This prevents common errors such as reusing a consumed qubit or aliasing.

Constructor¶

def __init__(
    self,
    message: str,
    handle_name: str | None = None,
    operation_name: str | None = None,
    first_use_location: str | None = None,
)

Attributes¶

• first_use_location

• handle_name

• operation_name

AffineValidationPass [source]¶

class AffineValidationPass(Pass[Block, Block])

Validate affine type semantics at IR level.

This pass serves as a safety net to catch affine type violations that may have bypassed the frontend checks. It verifies:

1. Each quantum value is used (consumed) at most once

2. Quantum values are not silently discarded

Input: Block (any kind) Output: Same Block (unchanged, validation only)

Attributes¶

• name: str

Methods¶

run¶

def run(self, input: Block) -> Block

Validate affine type semantics in the block.

Raises:

• AffineTypeError — If a quantum value is consumed multiple times.

CompileTimeIfLoweringPass [source]¶

class CompileTimeIfLoweringPass(Pass[Block, Block])

Lowers compile-time resolvable IfOperations before separation.

After constant folding, some IfOperation conditions are statically known but remain as control-flow nodes. SeparatePass treats them as segment boundaries, causing MultipleQuantumSegmentsError for classical-only compile-time if after quantum init.

This pass:

1. Evaluates conditions including expression-derived ones (CompOp, CondOp, NotOp chains).

2. Replaces resolved IfOperations with selected-branch operations.

3. Substitutes phi output UUIDs with selected-branch values in all subsequent operations and block outputs.

Constructor¶

def __init__(self, bindings: dict[str, Any] | None = None)

Attributes¶

• name: str

Methods¶

run¶

def run(self, input: Block) -> Block

Run the compile-time if lowering pass.

ConstantFoldingPass [source]¶

class ConstantFoldingPass(Pass[Block, Block])

Evaluates constant expressions at compile time.

This pass folds BinOp operations when all operands are constants or bound parameters, eliminating unnecessary classical operations that would otherwise split quantum segments.

Example:

Before (with bindings={"phase": 0.5}):
    BinOp(phase * 2) -> classical segment split

After:
    Constant 1.0 -> no segment split

Constructor¶

def __init__(self, bindings: dict[str, Any] | None = None)

Attributes¶

• name: str

Methods¶

run¶

def run(self, input: Block) -> Block

Run constant folding on the block.

ControlFlowVisitor [source]¶

class ControlFlowVisitor(ABC)

Base class for visiting operations with control flow handling.

Subclasses override visit_operation to define per-operation behavior. Control flow recursion is handled automatically by the base class.

Example:

class MeasurementCounter(ControlFlowVisitor):
    def __init__(self):
        self.count = 0

    def visit_operation(self, op: Operation) -> None:
        if isinstance(op, MeasureOperation):
            self.count += 1

Methods¶

visit_operation¶

def visit_operation(self, op: Operation) -> None

Process a single operation. Override in subclasses.

visit_operations¶

def visit_operations(self, operations: list[Operation]) -> None

Visit all operations including nested control flow.

DependencyError [source]¶

class DependencyError(QamomileCompileError)

Error when quantum operation depends on non-parameter classical value.

This error indicates that the program requires JIT compilation which is not yet supported.

Constructor¶

def __init__(
    self,
    message: str,
    quantum_op: str | None = None,
    classical_value: str | None = None,
)

Attributes¶

• classical_value

• quantum_op

OperationCollector [source]¶

class OperationCollector(ControlFlowVisitor)

Collects operations matching a predicate.

Example:

collector = OperationCollector(lambda op: isinstance(op, MeasureOperation))
collector.visit_operations(block.operations)
measurements = collector.collected

Constructor¶

def __init__(self, predicate: Callable[[Operation], bool])

Attributes¶

• collected: list[Operation]

Methods¶

visit_operation¶

def visit_operation(self, op: Operation) -> None

OperationTransformer [source]¶

class OperationTransformer(ABC)

Base class for transforming operations with control flow handling.

Subclasses override transform_operation to define per-operation transformation. Control flow recursion and rebuilding is handled automatically.

Example:

class OperationRenamer(OperationTransformer):
    def transform_operation(self, op: Operation) -> Operation:
        # Return modified operation
        return dataclasses.replace(op, ...)

Methods¶

transform_operation¶

def transform_operation(self, op: Operation) -> Operation | None

Transform a single operation. Return None to remove it.

transform_operations¶

def transform_operations(self, operations: list[Operation]) -> list[Operation]

Transform all operations including nested control flow.

Pass [source]¶

class Pass(ABC, Generic[InputT, OutputT])

Base class for all compiler passes.

Attributes¶

• name: str Human-readable name for this pass.

Methods¶

run¶

def run(self, input: InputT) -> OutputT

Execute the pass transformation.

QamomileCompileError [source]¶

class QamomileCompileError(Exception)

Base class for all Qamomile compilation errors.

UUIDRemapper [source]¶

class UUIDRemapper

Clones values and operations with fresh UUIDs and logical_ids.

Used during inlining to create unique identities for values when a block is called multiple times.

Constructor¶

def __init__(self)

Attributes¶

• logical_id_remap: dict[str, str] Get the mapping from old logical_ids to new logical_ids.

• uuid_remap: dict[str, str] Get the mapping from old UUIDs to new UUIDs.

Methods¶

clone_operation¶

def clone_operation(self, op: Operation) -> Operation

Clone an operation with fresh UUIDs for all values.

clone_operations¶

def clone_operations(self, operations: list[Operation]) -> list[Operation]

Clone a list of operations with fresh UUIDs.

clone_value¶

def clone_value(self, value: ValueBase) -> ValueBase

Clone any value type with a fresh UUID and logical_id.

Handles Value, ArrayValue, TupleValue, and DictValue through the unified ValueBase protocol.

ValidateWhileContractPass [source]¶

class ValidateWhileContractPass(Pass[Block, Block])

Validates that all WhileOperation conditions are measurement-backed.

Builds a producer map (result UUID → producing Operation instance) and checks every WhileOperation operand against it. A valid condition must be:

1. A Value with BitType

2. Measurement-backed: produced by MeasureOperation directly, or by IfOperation / PhiOp where every reachable leaf source is itself measurement-backed.

Both operands[0] (initial condition) and operands[1] (loop-carried condition) are validated.

Raises ValidationError for any non-measurement while pattern.

Attributes¶

• name: str

Methods¶

run¶

def run(self, block: Block) -> Block

Validate all WhileOperations and return block unchanged.

ValidationError [source]¶

class ValidationError(QamomileCompileError)

Error during validation (e.g., non-classical I/O).

Constructor¶

def __init__(self, message: str, value_name: str | None = None)

Attributes¶

• value_name

ValueCollector [source]¶

class ValueCollector(ControlFlowVisitor)

Collects Value UUIDs from operation operands and results.

Constructor¶

def __init__(self)

Attributes¶

• operand_uuids: set[str]

• result_uuids: set[str]

Methods¶

visit_operation¶

def visit_operation(self, op: Operation) -> None

ValueSubstitutor [source]¶

class ValueSubstitutor

Substitutes values in operations using a mapping.

Used during inlining to replace block parameters with caller arguments.

Constructor¶

def __init__(self, value_map: dict[str, ValueBase])

Methods¶

substitute_operation¶

def substitute_operation(self, op: Operation) -> Operation

Substitute values in an operation using the value map.

Handles control-flow operations (IfOperation, ForOperation, etc.) by recursing into their nested operation lists and phi_ops.

substitute_value¶

def substitute_value(self, v: ValueBase) -> ValueBase

Substitute a single value using the value map.

Handles all value types and array elements by substituting their parent_array if needed.

qamomile.circuit.transpiler.passes.affine_validate¶

Affine type validation pass: Verify quantum resources are used correctly.

Overview¶

Classes¶

AffineTypeError [source]¶

class AffineTypeError(QamomileCompileError)

Base class for affine type violations.

Affine types enforce that quantum resources (qubits) are used at most once. This prevents common errors such as reusing a consumed qubit or aliasing.

Constructor¶

def __init__(
    self,
    message: str,
    handle_name: str | None = None,
    operation_name: str | None = None,
    first_use_location: str | None = None,
)

Attributes¶

• first_use_location

• handle_name

• operation_name

AffineValidationPass [source]¶

class AffineValidationPass(Pass[Block, Block])

Validate affine type semantics at IR level.

This pass serves as a safety net to catch affine type violations that may have bypassed the frontend checks. It verifies:

1. Each quantum value is used (consumed) at most once

2. Quantum values are not silently discarded

Input: Block (any kind) Output: Same Block (unchanged, validation only)

Attributes¶

• name: str

Methods¶

run¶

def run(self, input: Block) -> Block

Validate affine type semantics in the block.

Raises:

• AffineTypeError — If a quantum value is consumed multiple times.

Block [source]¶

class Block

Unified block representation for all pipeline stages.

Replaces both BlockValue and Graph with a single structure. The kind field indicates which pipeline stage this block is at.

Constructor¶

def __init__(
    self,
    name: str = '',
    label_args: list[str] = list(),
    input_values: list[Value] = list(),
    output_values: list[Value] = list(),
    operations: list[Operation] = list(),
    kind: BlockKind = BlockKind.HIERARCHICAL,
    parameters: dict[str, Value] = dict(),
    _dependency_graph: dict[str, set[str]] | None = None,
) -> None

Attributes¶

• input_values: list[Value]

• kind: BlockKind

• label_args: list[str]

• name: str

• operations: list[Operation]

• output_values: list[Value]

• parameters: dict[str, Value]

Methods¶

from_block_value¶

@classmethod
def from_block_value(
    cls,
    block_value: 'BlockValue',
    parameters: dict[str, Value] | None = None,
) -> 'Block'

Create a Block from a BlockValue.

Parameters:

Returns:

'Block' — A new Block in HIERARCHICAL state

is_affine¶

def is_affine(self) -> bool

Check if block contains no CallBlockOperations.

unbound_parameters¶

def unbound_parameters(self) -> list[str]

Return list of unbound parameter names.

ForItemsOperation [source]¶

class ForItemsOperation(Operation)

Represents iteration over dict/iterable items.

Example:

for (i, j), Jij in qmc.items(ising):
    body

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    key_vars: list[str] = list(),
    value_var: str = '',
    key_is_vector: bool = False,
    operations: list[Operation] = list(),
) -> None

Attributes¶

• key_is_vector: bool

• key_vars: list[str]

• operation_kind: OperationKind

• operations: list[Operation]

• signature: Signature

• value_var: str

ForOperation [source]¶

class ForOperation(Operation)

Represents a for loop operation.

Example:

for i in range(start, stop, step):
    body

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    loop_var: str = '',
    operations: list[Operation] = list(),
) -> None

Attributes¶

• loop_var: str

• operation_kind: OperationKind

• operations: list[Operation]

• signature: Signature

IfOperation [source]¶

class IfOperation(Operation)

Represents an if-else conditional operation.

Example:

if condition:
    true_body
else:
    false_body

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    true_operations: list[Operation] = list(),
    false_operations: list[Operation] = list(),
    phi_ops: list[PhiOp] = list(),
) -> None

Attributes¶

• condition: Value

• false_operations: list[Operation]

• operation_kind: OperationKind

• phi_ops: list[PhiOp]

• signature: Signature

• true_operations: list[Operation]

Pass [source]¶

class Pass(ABC, Generic[InputT, OutputT])

Base class for all compiler passes.

Attributes¶

• name: str Human-readable name for this pass.

Methods¶

run¶

def run(self, input: InputT) -> OutputT

Execute the pass transformation.

Value [source]¶

class Value(Generic[T])

A typed value in the IR with SSA-style versioning.

Value represents a single typed value (qubit, float, int, bit, etc.) with support for:

• SSA versioning via uuid/logical_id

• Parameter binding

• Constant folding

• Array element tracking

Constructor¶

def __init__(
    self,
    type: T,
    name: str,
    version: int = 0,
    params: dict[str, Any] = dict(),
    uuid: str = (lambda: str(uuid.uuid4()))(),
    logical_id: str = (lambda: str(uuid.uuid4()))(),
    parent_array: ArrayValue | None = None,
    element_indices: tuple[Value, ...] = (),
) -> None

Attributes¶

• element_indices: tuple[Value, ...]

• logical_id: str

• name: str

• params: dict[str, Any]

• parent_array: ArrayValue | None

• type: T

• uuid: str

• version: int

Methods¶

get_cast_qubit_logical_ids¶

def get_cast_qubit_logical_ids(self) -> list[str] | None

Get the underlying qubit logical_ids for this cast value.

get_cast_qubit_uuids¶

def get_cast_qubit_uuids(self) -> list[str] | None

Get the underlying qubit UUIDs for this cast value.

get_cast_source_logical_id¶

def get_cast_source_logical_id(self) -> str | None

Get the source value logical_id if this is a cast result.

get_cast_source_uuid¶

def get_cast_source_uuid(self) -> str | None

Get the source value UUID if this is a cast result.

get_const¶

def get_const(self) -> int | float | None

Get constant value if available, otherwise None.

get_lowered_bits¶

def get_lowered_bits(self) -> list[Value] | None

Get lowered bit list if available, otherwise None.

get_lowered_qubits¶

def get_lowered_qubits(self) -> list[Value] | None

Get lowered qubit list if available, otherwise None.

is_array_element¶

def is_array_element(self) -> bool

Check if this value is an element of an array.

is_cast_result¶

def is_cast_result(self) -> bool

Check if this value is the result of a CastOperation.

is_constant¶

def is_constant(self) -> bool

Check if this value is a constant.

is_parameter¶

def is_parameter(self) -> bool

Check if this value is an unbound parameter.

next_version¶

def next_version(self) -> Value[T]

Create a new Value with incremented version (SSA style).

parameter_name¶

def parameter_name(self) -> str | None

Get the parameter name if this is a parameter, otherwise None.

set_cast_metadata¶

def set_cast_metadata(
    self,
    source_uuid: str,
    qubit_uuids: list[str],
    source_logical_id: str | None = None,
    qubit_logical_ids: list[str] | None = None,
) -> None

Set cast metadata for this value.

set_lowered_bits¶

def set_lowered_bits(self, bits: list[Value]) -> None

Set lowered bit list.

set_lowered_qubits¶

def set_lowered_qubits(self, qubits: list[Value]) -> None

Set lowered qubit list.

WhileOperation [source]¶

class WhileOperation(Operation)

Represents a while loop operation.

Only measurement-backed conditions are supported: the condition must be a Bit value produced by qmc.measure(). Non-measurement conditions (classical variables, constants, comparisons) are rejected by ValidateWhileContractPass before reaching backend emit.

Example::

bit = qmc.measure(q)
while bit:
    q = qmc.h(q)
    bit = qmc.measure(q)

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    operations: list[Operation] = list(),
) -> None

Attributes¶

• operation_kind: OperationKind

• operations: list[Operation]

• signature: Signature

qamomile.circuit.transpiler.passes.analyze¶

Analyze pass: Validate and analyze dependencies in an affine block.

Overview¶

Classes¶

AnalyzePass [source]¶

class AnalyzePass(Pass[Block, Block])

Analyze and validate an affine block.

This pass:

1. Builds a dependency graph between values

2. Validates that quantum ops don’t depend on non-parameter classical results

3. Checks that block inputs/outputs are classical

Input: Block with BlockKind.AFFINE Output: Block with BlockKind.ANALYZED (with _dependency_graph populated)

Attributes¶

• name: str

Methods¶

run¶

def run(self, input: Block) -> Block

Analyze the block and validate dependencies.

Block [source]¶

class Block

Unified block representation for all pipeline stages.

Replaces both BlockValue and Graph with a single structure. The kind field indicates which pipeline stage this block is at.

Constructor¶

def __init__(
    self,
    name: str = '',
    label_args: list[str] = list(),
    input_values: list[Value] = list(),
    output_values: list[Value] = list(),
    operations: list[Operation] = list(),
    kind: BlockKind = BlockKind.HIERARCHICAL,
    parameters: dict[str, Value] = dict(),
    _dependency_graph: dict[str, set[str]] | None = None,
) -> None

Attributes¶

• input_values: list[Value]

• kind: BlockKind

• label_args: list[str]

• name: str

• operations: list[Operation]

• output_values: list[Value]

• parameters: dict[str, Value]

Methods¶

from_block_value¶

@classmethod
def from_block_value(
    cls,
    block_value: 'BlockValue',
    parameters: dict[str, Value] | None = None,
) -> 'Block'

Create a Block from a BlockValue.

Parameters:

Returns:

'Block' — A new Block in HIERARCHICAL state

is_affine¶

def is_affine(self) -> bool

Check if block contains no CallBlockOperations.

unbound_parameters¶

def unbound_parameters(self) -> list[str]

Return list of unbound parameter names.

BlockKind [source]¶

class BlockKind(Enum)

Classification of block structure for pipeline stages.

Attributes¶

• AFFINE

• ANALYZED

• HIERARCHICAL

ControlFlowVisitor [source]¶

class ControlFlowVisitor(ABC)

Base class for visiting operations with control flow handling.

Subclasses override visit_operation to define per-operation behavior. Control flow recursion is handled automatically by the base class.

Example:

class MeasurementCounter(ControlFlowVisitor):
    def __init__(self):
        self.count = 0

    def visit_operation(self, op: Operation) -> None:
        if isinstance(op, MeasureOperation):
            self.count += 1

Methods¶

visit_operation¶

def visit_operation(self, op: Operation) -> None

Process a single operation. Override in subclasses.

visit_operations¶

def visit_operations(self, operations: list[Operation]) -> None

Visit all operations including nested control flow.

DependencyError [source]¶

class DependencyError(QamomileCompileError)

Error when quantum operation depends on non-parameter classical value.

This error indicates that the program requires JIT compilation which is not yet supported.

Constructor¶

def __init__(
    self,
    message: str,
    quantum_op: str | None = None,
    classical_value: str | None = None,
)

Attributes¶

• classical_value

• quantum_op

MeasureOperation [source]¶

class MeasureOperation(Operation)

Constructor¶

def __init__(self, operands: list[Value] = list(), results: list[Value] = list()) -> None

Attributes¶

• operation_kind: OperationKind

• signature: Signature

OperationKind [source]¶

class OperationKind(enum.Enum)

Classification of operations for classical/quantum separation.

This enum is used to categorize operations during compilation to determine which parts run on classical hardware vs quantum hardware.

Values:

QUANTUM: Pure quantum operations (gates, qubit allocation) CLASSICAL: Pure classical operations (arithmetic, comparisons) HYBRID: Operations that bridge classical and quantum (measurement, encode/decode) CONTROL: Control flow structures (for, while, if)

Attributes¶

• CLASSICAL

• CONTROL

• HYBRID

• QUANTUM

Pass [source]¶

class Pass(ABC, Generic[InputT, OutputT])

Base class for all compiler passes.

Attributes¶

• name: str Human-readable name for this pass.

Methods¶

run¶

def run(self, input: InputT) -> OutputT

Execute the pass transformation.

ValidationError [source]¶

class ValidationError(QamomileCompileError)

Error during validation (e.g., non-classical I/O).

Constructor¶

def __init__(self, message: str, value_name: str | None = None)

Attributes¶

• value_name

Value [source]¶

class Value(Generic[T])

A typed value in the IR with SSA-style versioning.

Value represents a single typed value (qubit, float, int, bit, etc.) with support for:

• SSA versioning via uuid/logical_id

• Parameter binding

• Constant folding

• Array element tracking

Constructor¶

def __init__(
    self,
    type: T,
    name: str,
    version: int = 0,
    params: dict[str, Any] = dict(),
    uuid: str = (lambda: str(uuid.uuid4()))(),
    logical_id: str = (lambda: str(uuid.uuid4()))(),
    parent_array: ArrayValue | None = None,
    element_indices: tuple[Value, ...] = (),
) -> None

Attributes¶

• element_indices: tuple[Value, ...]

• logical_id: str

• name: str

• params: dict[str, Any]

• parent_array: ArrayValue | None

• type: T

• uuid: str

• version: int

Methods¶

get_cast_qubit_logical_ids¶

def get_cast_qubit_logical_ids(self) -> list[str] | None

Get the underlying qubit logical_ids for this cast value.

get_cast_qubit_uuids¶

def get_cast_qubit_uuids(self) -> list[str] | None

Get the underlying qubit UUIDs for this cast value.

get_cast_source_logical_id¶

def get_cast_source_logical_id(self) -> str | None

Get the source value logical_id if this is a cast result.

get_cast_source_uuid¶

def get_cast_source_uuid(self) -> str | None

Get the source value UUID if this is a cast result.

get_const¶

def get_const(self) -> int | float | None

Get constant value if available, otherwise None.

get_lowered_bits¶

def get_lowered_bits(self) -> list[Value] | None

Get lowered bit list if available, otherwise None.

get_lowered_qubits¶

def get_lowered_qubits(self) -> list[Value] | None

Get lowered qubit list if available, otherwise None.

is_array_element¶

def is_array_element(self) -> bool

Check if this value is an element of an array.

is_cast_result¶

def is_cast_result(self) -> bool

Check if this value is the result of a CastOperation.

is_constant¶

def is_constant(self) -> bool

Check if this value is a constant.

is_parameter¶

def is_parameter(self) -> bool

Check if this value is an unbound parameter.

next_version¶

def next_version(self) -> Value[T]

Create a new Value with incremented version (SSA style).

parameter_name¶

def parameter_name(self) -> str | None

Get the parameter name if this is a parameter, otherwise None.

set_cast_metadata¶

def set_cast_metadata(
    self,
    source_uuid: str,
    qubit_uuids: list[str],
    source_logical_id: str | None = None,
    qubit_logical_ids: list[str] | None = None,
) -> None

Set cast metadata for this value.

set_lowered_bits¶

def set_lowered_bits(self, bits: list[Value]) -> None

Set lowered bit list.

set_lowered_qubits¶

def set_lowered_qubits(self, qubits: list[Value]) -> None

Set lowered qubit list.

ValueBase [source]¶

class ValueBase(Protocol)

Protocol defining the common interface for all value types.

This protocol enables:

• isinstance(v, ValueBase) checks for any value type

• Unified type annotations with ValueBase instead of union types

• Duck typing for value operations in transpiler passes

All value types (Value, ArrayValue, TupleValue, DictValue) implement this protocol.

Attributes¶

• logical_id: str Identifies the same physical qubit/value across SSA versions.

• name: str Human-readable name for this value.

• params: dict[str, Any] Flexible parameter storage for metadata (const, parameter, etc.).

• uuid: str Unique identifier for this specific value instance.

Methods¶

is_constant¶

def is_constant(self) -> bool

Check if this value is a constant.

is_parameter¶

def is_parameter(self) -> bool

Check if this value is an unbound parameter.

next_version¶

def next_version(self) -> ValueBase

Create a new SSA version with fresh uuid but same logical_id.

parameter_name¶

def parameter_name(self) -> str | None

Get the parameter name if this is a parameter.

qamomile.circuit.transpiler.passes.compile_time_if_lowering¶

Compile-time IfOperation lowering pass.

Lowers compile-time resolvable IfOperations before the separate pass, replacing them with selected-branch operations and substituting phi outputs with selected-branch values throughout the block.

This prevents SeparatePass from seeing classical-only compile-time IfOperations that would otherwise split quantum segments.

Overview¶

Functions¶

resolve_if_condition [source]¶

def resolve_if_condition(condition: Any, bindings: dict[str, Any]) -> bool | None

Resolve an if-condition to a compile-time boolean.

Checks whether the condition can be statically evaluated at emit time. Plain Python values (int/bool captured by @qkernel from closure), constant-folded Values, and Values resolvable via bindings are all treated as compile-time constants.

Parameters:

Returns:

bool | None — True/False for compile-time resolvable conditions, bool | None — None for runtime conditions that must be dispatched to the bool | None — backend’s conditional branching protocol.

Classes¶

ArrayValue [source]¶

class ArrayValue(Value[T])

An array of values with shape information.

ArrayValue extends Value to represent multi-dimensional arrays of typed values (e.g., qubit registers, parameter vectors).

Constructor¶

def __init__(
    self,
    type: T,
    name: str,
    version: int = 0,
    params: dict[str, Any] = dict(),
    uuid: str = (lambda: str(uuid.uuid4()))(),
    logical_id: str = (lambda: str(uuid.uuid4()))(),
    parent_array: ArrayValue | None = None,
    element_indices: tuple[Value, ...] = (),
    shape: tuple[Value, ...] = tuple(),
) -> None

Attributes¶

• logical_id: str

• name: str

• params: dict[str, Any]

• shape: tuple[Value, ...]

• type: T

• uuid: str

Methods¶

next_version¶

def next_version(self) -> ArrayValue[T]

Create a new ArrayValue with incremented version, preserving shape.

BinOp [source]¶

class BinOp(BinaryOperationBase)

Binary arithmetic operation (ADD, SUB, MUL, DIV, FLOORDIV, POW).

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    kind: BinOpKind | None = None,
) -> None

Attributes¶

• kind: BinOpKind | None

• operation_kind: OperationKind

• signature: Signature

BinOpKind [source]¶

class BinOpKind(enum.Enum)

Attributes¶

• ADD

• DIV

• FLOORDIV

• MUL

• POW

• SUB

Block [source]¶

class Block

Unified block representation for all pipeline stages.

Replaces both BlockValue and Graph with a single structure. The kind field indicates which pipeline stage this block is at.

Constructor¶

def __init__(
    self,
    name: str = '',
    label_args: list[str] = list(),
    input_values: list[Value] = list(),
    output_values: list[Value] = list(),
    operations: list[Operation] = list(),
    kind: BlockKind = BlockKind.HIERARCHICAL,
    parameters: dict[str, Value] = dict(),
    _dependency_graph: dict[str, set[str]] | None = None,
) -> None

Attributes¶

• input_values: list[Value]

• kind: BlockKind

• label_args: list[str]

• name: str

• operations: list[Operation]

• output_values: list[Value]

• parameters: dict[str, Value]

Methods¶

from_block_value¶

@classmethod
def from_block_value(
    cls,
    block_value: 'BlockValue',
    parameters: dict[str, Value] | None = None,
) -> 'Block'

Create a Block from a BlockValue.

Parameters:

Returns:

'Block' — A new Block in HIERARCHICAL state

is_affine¶

def is_affine(self) -> bool

Check if block contains no CallBlockOperations.

unbound_parameters¶

def unbound_parameters(self) -> list[str]

Return list of unbound parameter names.

CompOp [source]¶

class CompOp(BinaryOperationBase)

Comparison operation (EQ, NEQ, LT, LE, GT, GE).

Constructor¶

def __init__(
    self,
    operands: list[Value] = list(),
    results: list[Value] = list(),
    kind: CompOpKind | None = None,
) -> None

Attributes¶

• kind: CompOpKind | None

• operation_kind: OperationKind

• signature: Signature