Transpiler Pipeline

QP-Core's FastAPI service (quantumflow-api) exposes a single POST /api/v1/transpile endpoint. The request and response shapes are:

1
class TranspileRequest(BaseModel):
2
    qasm: str
3
    target_device: BraketDevice = BraketDevice.LOCAL_SIMULATOR
4
    optimization_level: int = Field(1, ge=0, le=3)  # accepted, not yet wired up

The pipeline behind that endpoint has three real stages today — parse, convert, emit. There is currently no fourth "optimize" stage in the code path, which the next section explains.

1. Parsing

Parsing is Qiskit's own, not a QP-Core-authored AST parser. qasm3.loads() is tried first (OpenQASM 3); if that raises, the code falls back to QuantumCircuit.from_qasm_str() (OpenQASM 2). Both return a Qiskit QuantumCircuit, Qiskit's own in-memory circuit representation — QP-Core doesn't define or walk its own AST.

1
def _parse_circuit(source: str) -> QuantumCircuit:
2
    try:
3
        return qasm3.loads(source)
4
    except Exception:
5
        try:
6
            return QuantumCircuit.from_qasm_str(source)
7
        except Exception as exc:
8
            raise TranspilationError(f"Could not parse circuit source: {exc}") from exc

2. Optimization — accepted, not yet wired up

For reference, once wired up this stage would run Qiskit's own preset pass managers, which include commutation-based gate cancellation (cancelling or merging adjacent gates that commute past each other, not just adjacent identical ones) and, for hardware targets with limited connectivity, layout selection and SWAP-based routing to satisfy the device's coupling map. Those are real, well-documented Qiskit internals — see Qiskit's transpiler passes reference. QP-Core would be selecting and configuring them, not implementing them from scratch.

The live playground on this site shows a small, honest preview of the same class of optimization: its client-side analyzer (src/lib/qasmAnalyzer.ts) cancels adjacent self-inverse single-qubit gate pairs on the circuit you paste in and reports the resulting gate-count reduction. It's a simplified, illustrative version of one thing a real commutation pass does — not the production QP-Core pipeline, and not a general commutation analysis (it only catches immediately-adjacent identical gates, not gates separated by something they commute past).

3. Braket IR emission

Conversion is handled by qiskit_braket_provider's to_braket() adapter, which maps the Qiskit circuit onto Amazon Braket's circuit model. The response serializes that via to_ir() — braket_ir carries the IR's JSON payload, and qasm carries a readable OpenQASM form when the IR type exposes one.

1
def transpile_to_braket(request: TranspileRequest) -> TranspileResponse:
2
    circuit = _parse_circuit(request.qasm)
3
 
4
    braket_circuit = to_braket(circuit)
5
 
6
    return TranspileResponse(
7
        braket_ir=braket_circuit.to_ir().json(),
8
        qasm=braket_circuit.to_ir().source if hasattr(braket_circuit.to_ir(), "source") else str(braket_circuit),
9
        target_device=request.target_device,
10
        qubit_count=circuit.num_qubits,
11
        gate_count=sum(circuit.count_ops().values()),
12
    )

Benchmarks

Not yet measured. The test suite today (tests/test_transpiler.py) covers correctness — a health check and a Bell-state transpile that asserts the reported qubit count — not performance. There is no Rust or native extension anywhere in this service; it is pure Python (FastAPI + Qiskit + qiskit-braket-provider). A performance-benchmark section will be added here once real measurements exist, rather than before.

Source: github.com/sadeqisaidmohaddes-star/quantumflow-api