quantbom 0.6.0__py3-none-any.whl

quantbom/frameworks/braket.py

@@ -0,0 +1,132 @@
+"""Amazon Braket — translated through OpenQASM 3 with gate-name rewriting.
+
+Braket's OpenQASM uses its own gate names; they are rewritten (word-bounded)
+to stdgates.inc names. Gates outside the table fail to import with an explicit
+error — never a silent mistranslation (a survey of every Braket gate found
+none). Qubit 0 first.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from .base import FrameworkAdapter, dist_version, qiskit_version
+
+GATE_ALIASES = (  # braket OpenQASM3 names -> stdgates names (word-bounded)
+    ("cnot", "cx"), ("ccnot", "ccx"), ("ti", "tdg"), ("si", "sdg"),
+    ("vi", "sxdg"), ("v", "sx"), ("phaseshift", "p"), ("cphaseshift", "cp"),
+    ("i", "id"),  # Braket's identity is `i`; stdgates.inc names it `id`
+    ("xx", "rxx"), ("yy", "ryy"), ("zz", "rzz"),  # Braket's Ising gates are exp(-i theta/2 P⊗P): Qiskit's rxx/ryy/rzz
+)
+
+# Braket's hardware-native gates (IonQ, Rigetti, OQC), which stdgates.inc does
+# not define. Each body was checked against Braket's own `Circuit.to_unitary()`
+# (tests/frontends/test_frontend_fidelity.py; the conformance suite's C5 keeps
+# a mixed fixture faithful). Parameters are named p0, p1 on purpose: Qiskit's
+# OpenQASM 3 importer binds a gate's parameters by sorted NAME, not position
+# (observed on qiskit 2.5.2: `gate g(theta, phi)` called as g(0.7, 0.3) bound
+# phi=0.7), so names in alphabetical order are correct under either reading.
+NATIVE_GATE_DEFS = """
+gate rxx(p0) a, b { h a; h b; cx a, b; rz(p0) b; cx a, b; h a; h b; }
+gate ryy(p0) a, b { rx(pi/2) a; rx(pi/2) b; cx a, b; rz(p0) b; cx a, b; rx(-pi/2) a; rx(-pi/2) b; }
+gate rzz(p0) a, b { cx a, b; rz(p0) b; cx a, b; }
+gate rzx(p0) a, b { h b; cx a, b; rz(p0) b; cx a, b; h b; }
+gate iswap a, b { s a; s b; h a; cx a, b; cx b, a; h b; }
+gate pswap(p0) a, b { swap a, b; x a; cp(p0) a, b; x a; x b; cp(p0) a, b; x b; }
+gate xy(p0) a, b { rxx(-p0/2) a, b; ryy(-p0/2) a, b; }
+gate ecr a, b { rzx(pi/4) a, b; x a; rzx(-pi/4) a, b; }
+gate cv a, b { h b; cp(pi/2) a, b; h b; }
+gate cphaseshift00(p0) a, b { x a; x b; cp(p0) a, b; x a; x b; }
+gate cphaseshift01(p0) a, b { x a; cp(p0) a, b; x a; }
+gate cphaseshift10(p0) a, b { x b; cp(p0) a, b; x b; }
+gate prx(p0, p1) a { rz(-p1) a; rx(p0) a; rz(p1) a; }
+gate gpi(p0) a { rz(-p0) a; x a; rz(p0) a; }
+gate gpi2(p0) a { prx(pi/2, p0) a; }
+"""
+NATIVE_GATES = ("iswap", "pswap", "xy", "xx", "yy", "zz", "ecr", "cv", "cphaseshift00", "cphaseshift01", "cphaseshift10", "gpi", "gpi2", "prx")
+
+
+def _root(obj: Any) -> str:
+    return (type(obj).__module__ or "").split(".")[0]
+
+
+class BraketAdapter(FrameworkAdapter):
+    name = "braket"
+    component = "amazon-braket-sdk"
+    license = "Apache-2.0"
+    bit_order = "qubit0_first"
+    translation = "openqasm3"
+    supports_dynamic = False  # the SDK refuses gates on measured qubits and has no branching: nothing dynamic to lower
+    reference = "dense"
+
+    def detect(self, obj: Any) -> bool:
+        module = type(obj).__module__ or ""
+        return module == "braket.circuits" or module.startswith("braket.circuits.")  # not braket.ahs (analog): K7 refuses it
+
+    def _openqasm(self, obj: Any) -> str:
+        from braket.circuits.serialization import IRType
+
+        return obj.to_ir(ir_type=IRType.OPENQASM).source
+
+    def open_parameters(self, obj: Any) -> list[str]:
+        return sorted(str(getattr(p, "name", p)) for p in (getattr(obj, "parameters", None) or ()))
+
+    def _std_source(self, obj: Any) -> str:
+        """Braket's OpenQASM 3 with stdgates.inc names: what any standard parser reads."""
+        source = self._openqasm(obj)
+        header = 'OPENQASM 3.0;\ninclude "stdgates.inc";'
+        if re.search(r"\bvi\b", source):
+            # stdgates.inc defines sx but not sxdg. Braket's vi is V-dagger =
+            # sxdg, which is exactly H·Sdg·H (since sx = H·S·H exactly).
+            header += "\ngate sxdg a { h a; sdg a; h a; }"
+        if any(re.search(rf"\b{g}\b", source) for g in NATIVE_GATES):
+            header += NATIVE_GATE_DEFS  # only when a native gate is used: the export stays minimal otherwise
+        source = source.replace("OPENQASM 3.0;", header, 1)
+        for braket_name, std_name in GATE_ALIASES:
+            source = re.sub(rf"\b{braket_name}\b", std_name, source)
+        return source
+
+    def lower(self, obj: Any) -> tuple[Any, str, Any]:
+        from qiskit import qasm3
+
+        return qasm3.loads(self._std_source(obj)), f"braket {dist_version('amazon-braket-sdk')} / qiskit {qiskit_version()}", None
+
+    def native_export(self, obj: Any) -> tuple[str, str]:
+        return self._openqasm(obj), "openqasm3"
+
+    def reference_unitary(self, obj: Any) -> tuple[Any, str]:
+        return obj.to_unitary(), f"amazon-braket-sdk {dist_version('amazon-braket-sdk')} Circuit.to_unitary"
+
+    def reference_state(self, obj: Any) -> tuple[Any, str]:
+        import numpy as np
+        from braket.circuits import Circuit
+        from braket.devices import LocalSimulator
+
+        body = Circuit()
+        for inst in obj.instructions:
+            if getattr(inst.operator, "name", "") == "Measure":
+                continue
+            body.add_instruction(inst)
+        body.state_vector()
+        state = np.asarray(LocalSimulator().run(body, shots=0).result().values[0], dtype=complex)
+        return state, f"amazon-braket-sdk {dist_version('amazon-braket-sdk')} LocalSimulator state_vector"
+
+    def export_for_equivalence(self, obj: Any) -> tuple[str, str, str | None]:
+        """Braket's OpenQASM uses its own gate names (cnot, ccnot, vi, ...); an independent
+        parser knows the stdgates names, so they are aliased — textually, word-bounded —
+        and the note says so."""
+        return self._std_source(obj), "openqasm3", ("Braket gate names aliased to stdgates.inc (cnot->cx, ccnot->ccx, ti->tdg, si->sdg, vi->sxdg, v->sx, "
+                                                      "phaseshift->p, cphaseshift->cp, i->id, xx/yy/zz->rxx/ryy/rzz); hardware-native gates defined in the header")
+
+    def native_sample(self, obj: Any, shots: int = 8) -> dict[str, int]:
+        from braket.devices import LocalSimulator
+
+        return {str(k): int(v) for k, v in LocalSimulator().run(obj, shots=shots).result().measurement_counts.items()}
+
+    def native_run(self, obj: Any, shots: int) -> dict[str, Any]:
+        """Braket's LocalSimulator; its measurement_counts read qubit 0 first over every qubit."""
+        from braket.devices import LocalSimulator
+
+        counts = LocalSimulator().run(obj, shots=shots).result().measurement_counts
+        return self._reversed_reading({str(k): int(v) for k, v in counts.items()},
+                                      f"amazon-braket-sdk {dist_version('amazon-braket-sdk')} LocalSimulator")

quantbom/frameworks/cirq.py

@@ -0,0 +1,106 @@
+"""Cirq — translated through OpenQASM 2 (`cirq.qasm`). Qubit 0 first."""
+from __future__ import annotations
+
+from typing import Any
+
+from .base import FrameworkAdapter, Undecidable, dist_version, qiskit_version
+
+
+def _root(obj: Any) -> str:
+    return (type(obj).__module__ or "").split(".")[0]
+
+
+class CirqAdapter(FrameworkAdapter):
+    name = "cirq"
+    component = "cirq-core"
+    license = "Apache-2.0"
+    bit_order = "qubit0_first"
+    translation = "openqasm2"
+    supports_dynamic = False
+    reference = "dense"
+
+    def detect(self, obj: Any) -> bool:
+        return _root(obj) == "cirq"
+
+    def open_parameters(self, obj: Any) -> list[str]:
+        import cirq
+
+        return sorted(cirq.parameter_names(obj)) if cirq.is_parameterized(obj) else []
+
+    def dynamic_features(self, obj: Any) -> list[str]:
+        import cirq
+
+        out: list[str] = []
+        if not obj.are_all_measurements_terminal():
+            out.append("mid-circuit-measurement")
+        if any(isinstance(op, cirq.ClassicallyControlledOperation) for op in obj.all_operations()):
+            out.append("classical-control-flow")
+        return out
+
+    def lower(self, obj: Any) -> tuple[Any, str, Any]:
+        import cirq
+        from qiskit import QuantumCircuit
+
+        return QuantumCircuit.from_qasm_str(cirq.qasm(obj)), f"cirq {cirq.__version__} / qiskit {qiskit_version()}", None
+
+    def native_export(self, obj: Any) -> tuple[str, str]:
+        import cirq
+
+        return cirq.qasm(obj), "openqasm2"
+
+    def reference_unitary(self, obj: Any) -> tuple[Any, str]:
+        import cirq
+
+        if not obj.are_all_measurements_terminal():
+            raise Undecidable("non-terminal measurement: the circuit is not a unitary")
+        qubits = sorted(obj.all_qubits())  # the order cirq.qasm numbers them in
+        body = cirq.Circuit(op for op in obj.all_operations() if not cirq.is_measurement(op))
+        return (
+            body.unitary(qubit_order=qubits, qubits_that_should_be_present=qubits),
+            f"cirq-core {dist_version('cirq-core')} Circuit.unitary",
+        )
+
+    def reference_state(self, obj: Any) -> tuple[Any, str]:
+        import cirq
+        import numpy as np
+
+        if not obj.are_all_measurements_terminal():
+            raise Undecidable("non-terminal measurement: the circuit is not a unitary")
+        qubits = sorted(obj.all_qubits())
+        body = cirq.Circuit(op for op in obj.all_operations() if not cirq.is_measurement(op))
+        return (cirq.final_state_vector(body, qubit_order=qubits, dtype=np.complex128),
+                f"cirq-core {dist_version('cirq-core')} final_state_vector")
+
+    def native_sample(self, obj: Any, shots: int = 8) -> dict[str, int]:
+        import cirq
+
+        keys = sorted({k for op in obj.all_operations() if cirq.is_measurement(op) for k in [cirq.measurement_key_name(op)]})
+        if len(keys) != 1:
+            raise Undecidable("native_sample expects exactly one measurement key")
+        n = sum(len(op.qubits) for op in obj.all_operations() if cirq.is_measurement(op))
+        hist = cirq.Simulator().run(obj, repetitions=shots).histogram(key=keys[0])
+        return {format(k, f"0{n}b"): int(v) for k, v in hist.items()}
+
+    def native_run(self, obj: Any, shots: int) -> dict[str, Any]:
+        """cirq.Simulator over every measurement key, keys in the order their
+        measurements first appear (the order cirq.qasm declares their registers),
+        each key's bits in its gate's qubit order — qubit 0 first. A circuit
+        without measurements is measured on every qubit, sorted."""
+        import cirq
+
+        circuit, order = obj, []
+        for op in obj.all_operations():
+            if cirq.is_measurement(op):
+                key = cirq.measurement_key_name(op)
+                if key in order:
+                    raise Undecidable(f"measurement key {key!r} is written more than once")
+                order.append(key)
+        if not order:
+            circuit = obj + cirq.Circuit(cirq.measure(*sorted(obj.all_qubits()), key="m"))
+            order = ["m"]
+        result = cirq.Simulator().run(circuit, repetitions=shots)
+        rows = ["".join("".join(str(int(b)) for b in result.measurements[k][r]) for k in order) for r in range(shots)]
+        reading: dict[str, int] = {}
+        for row in rows:
+            reading[row] = reading.get(row, 0) + 1
+        return self._reversed_reading(reading, f"cirq-core {dist_version('cirq-core')} Simulator.run")

quantbom/frameworks/cudaq.py

@@ -0,0 +1,223 @@
+"""CUDA-Q (NVIDIA) — translated through OpenQASM 2 (`cudaq.translate`). Qubit 0 first.
+
+Accepts kernels without arguments, written with `@cudaq.kernel` or the
+builder (`cudaq.make_kernel()`). A kernel that takes arguments is refused with
+an explanation: the circuit would depend on values the evidence cannot see —
+wrap it in an argument-free kernel that binds them.
+
+Verified by the conformance suite on CUDA-Q 0.16 (qpp-cpu target, K1; the
+record is in harness_manifest.json). What that run found, and the adapter
+now accounts for:
+
+  * `cudaq.sample` bitstrings put qubit 0 first (C3).
+  * `cudaq.get_unitary` indexes the basis with qubit 0 MOST significant while
+    `cudaq.get_state` indexes it with qubit 0 LEAST significant — the two APIs
+    disagree, so each is pinned by its OWN probe (X on qubit 0, H on qubit 1:
+    the support of the first column / the state tells the order) and
+    normalised to qubit-0-most-significant, which is what QNT-06 compares.
+  * CUDA-Q's compiler removes idle qubits before `get_unitary` (a 3-qubit
+    kernel touching one qubit yields a 2x2 matrix) but not before `get_state`
+    or `translate`. A probe with an idle qubit therefore answered for the
+    wrong register — the original probe did exactly that. The probes now act
+    on every qubit and require the full dimension; an elided reference is
+    reported as undecidable, and QNT-06 falls through to the state-vector
+    method, whose register is complete.
+  * `cudaq.translate` on a kernel with arguments raises a RuntimeError
+    ("Use synthesize before translate"); the kernel's signature is read
+    before lowering so the refusal is the adapter's explanation.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .base import FrameworkAdapter, Undecidable, dist_version, qiskit_version
+
+
+def _root(obj: Any) -> str:
+    return (type(obj).__module__ or "").split(".")[0]
+
+
+def _version() -> str:
+    for dist in ("cudaq", "cuda-quantum-cu12", "cuda-quantum-cu11", "cuda-quantum"):
+        v = dist_version(dist)
+        if v != "unknown":
+            return v
+    return "unknown"
+
+
+class CudaqAdapter(FrameworkAdapter):
+    name = "cudaq"
+    component = "cudaq"
+    license = "Apache-2.0"
+    bit_order = "qubit0_first"
+    translation = "openqasm2"
+    supports_dynamic = False
+    reference = "dense"
+
+    def detect(self, obj: Any) -> bool:
+        return _root(obj) == "cudaq"
+
+    def open_parameters(self, obj: Any) -> list[str]:
+        """Kernel arguments, read before lowering: a `@cudaq.kernel` carries them in
+        its signature, a builder kernel in `argument_count`."""
+        sig = getattr(obj, "signature", None)
+        arg_types = list(getattr(sig, "arg_types", None) or [])
+        if arg_types:
+            import inspect
+
+            fn = getattr(obj, "kernelFunction", None)
+            try:
+                names = list(inspect.signature(fn).parameters) if fn is not None else []
+            except (TypeError, ValueError):
+                names = []
+            return names or [f"arg{i}" for i in range(len(arg_types))]
+        count = getattr(obj, "argument_count", None)
+        if isinstance(count, int) and count > 0:
+            return [f"arg{i}" for i in range(count)]
+        return []
+
+    def _qasm(self, obj: Any) -> str:
+        import cudaq
+
+        try:
+            text = cudaq.translate(obj, format="openqasm2")
+        except (TypeError, RuntimeError) as err:  # a kernel that needs arguments ("Use synthesize before translate")
+            if isinstance(err, RuntimeError) and "synthesize" not in str(err) and "argument" not in str(err):
+                raise
+            raise ValueError(
+                "CUDA-Q kernels with arguments are not supported: the certified circuit would depend on "
+                f"values the evidence does not record. Wrap it in an argument-free kernel ({err})"
+            ) from err
+        if "OPENQASM" not in str(text):
+            # K1: CUDA-Q 0.16 returns the text "{translation failed}" (and prints
+            # "'cf.cond_br' op unable to translate") instead of raising when a kernel
+            # branches on a measurement result. Say so, rather than letting Qiskit's
+            # parser fail on a placeholder.
+            raise ValueError(
+                f"CUDA-Q could not export this kernel to OpenQASM 2 ({str(text).strip()[:60]}): kernels that branch on "
+                f"measurement results (classical feed-forward) are not exportable by CUDA-Q {_version()}, so dynamic "
+                "CUDA-Q programs are not supported — measure at the end, or move the branch to the host"
+            )
+        return text
+
+    def _qubits(self, obj: Any) -> int:
+        """Qubits of the kernel as its OpenQASM export declares them (the compiler
+        keeps the register there even when it drops idle qubits elsewhere)."""
+        import re
+
+        return sum(int(n) for n in re.findall(r"qreg\s+\w+\[(\d+)\]", self._qasm(obj)))
+
+    def lower(self, obj: Any) -> tuple[Any, str, Any]:
+        from qiskit import QuantumCircuit
+
+        qc = QuantumCircuit.from_qasm_str(self._qasm(obj))
+        if "measure" not in qc.count_ops():  # cudaq.sample measures every qubit when the kernel does not
+            qc.measure_all()
+        return qc, f"cuda-q {_version()} / qiskit {qiskit_version()}", None
+
+    def native_export(self, obj: Any) -> tuple[str, str]:
+        return self._qasm(obj), "openqasm2"
+
+    @staticmethod
+    def _unitary(cudaq: Any, kernel: Any):
+        import numpy as np
+
+        get_unitary = getattr(cudaq, "get_unitary", None)
+        if get_unitary is None:
+            raise Undecidable(f"CUDA-Q {_version()} has no cudaq.get_unitary, so the translation cannot be checked")
+        try:
+            return np.asarray(get_unitary(kernel), dtype=complex)
+        except Exception as err:  # e.g. measurements inside the kernel, or an unsupported target
+            raise Undecidable(f"cudaq.get_unitary could not compute the reference: {type(err).__name__}: {err}") from err
+
+    @staticmethod
+    def _probe(cudaq: Any):
+        """X on qubit 0 and H on qubit 1: every qubit is acted on (nothing for the
+        compiler to drop) and the support of X⊗H|00> names the index order —
+        {2, 3} when qubit 0 is most significant, {1, 3} when least."""
+        probe = cudaq.make_kernel()
+        q = probe.qalloc(2)
+        probe.x(q[0])
+        probe.h(q[1])
+        return probe
+
+    @staticmethod
+    def _order_from_support(vector, what: str) -> str:
+        import numpy as np
+
+        vector = np.asarray(vector).reshape(-1)
+        if vector.shape[0] != 4:
+            raise Undecidable(f"cudaq.{what} probe returned {vector.shape[0]} amplitudes for a 2-qubit kernel: "
+                              "the compiler dropped a qubit, so the index order cannot be read")
+        support = {int(i) for i in np.nonzero(np.abs(vector) > 1e-9)[0]}
+        if support == {2, 3}:
+            return "qubit0_msb"
+        if support == {1, 3}:
+            return "qubit0_lsb"
+        raise Undecidable(f"cudaq.{what} probe landed on basis states {sorted(support)}; its index order is unknown")
+
+    def _index_order(self, cudaq: Any) -> str:
+        """Basis-index order of cudaq.get_unitary, measured — never assumed."""
+        return self._order_from_support(self._unitary(cudaq, self._probe(cudaq))[:, 0], "get_unitary")
+
+    def _state_order(self, cudaq: Any) -> str:
+        """Basis-index order of cudaq.get_state — pinned separately: on CUDA-Q 0.16
+        it differs from get_unitary's."""
+        return self._order_from_support(self._state(cudaq, self._probe(cudaq)), "get_state")
+
+    @staticmethod
+    def _state(cudaq: Any, kernel: Any):
+        import numpy as np
+
+        get_state = getattr(cudaq, "get_state", None)
+        if get_state is None:
+            raise Undecidable(f"CUDA-Q {_version()} has no cudaq.get_state, so no state reference is available")
+        try:
+            return np.asarray(get_state(kernel), dtype=complex).reshape(-1)
+        except Exception as err:
+            raise Undecidable(f"cudaq.get_state could not compute the reference: {type(err).__name__}: {err}") from err
+
+    def reference_unitary(self, obj: Any) -> tuple[Any, str]:
+        import cudaq
+        import numpy as np
+
+        order = self._index_order(cudaq)
+        u = self._unitary(cudaq, obj)
+        n_declared = self._qubits(obj)
+        if n_declared and u.shape[0] != 1 << n_declared:
+            raise Undecidable(f"cudaq.get_unitary returned a {u.shape[0]}x{u.shape[0]} matrix for a {n_declared}-qubit kernel: "
+                              "CUDA-Q's compiler removed idle qubits, so the unitary does not cover the register "
+                              "(the state-vector method decides instead)")
+        if order == "qubit0_lsb":
+            n = u.shape[0].bit_length() - 1
+            perm = [int(format(i, f"0{n}b")[::-1], 2) for i in range(1 << n)]
+            u = u[np.ix_(perm, perm)]
+        return u, f"cudaq {_version()} get_unitary (target {cudaq.get_target().name}; index order {order}, normalised)"
+
+    def reference_state(self, obj: Any) -> tuple[Any, str]:
+        import cudaq
+
+        order = self._state_order(cudaq)  # get_state has its own order (it is not get_unitary's)
+        state = self._state(cudaq, obj)
+        n_declared = self._qubits(obj)
+        if n_declared and state.shape[0] != 1 << n_declared:
+            raise Undecidable(f"cudaq.get_state returned {state.shape[0]} amplitudes for a {n_declared}-qubit kernel")
+        if order == "qubit0_lsb":
+            n = state.shape[0].bit_length() - 1
+            perm = [int(format(i, f"0{n}b")[::-1], 2) for i in range(1 << n)]
+            state = state[perm]
+        return state, f"cudaq {_version()} get_state (index order {order}, normalised)"
+
+    def native_sample(self, obj: Any, shots: int = 8) -> dict[str, int]:
+        import cudaq
+
+        result = cudaq.sample(obj, shots_count=shots)
+        return {str(bits): int(count) for bits, count in result.items()}
+
+    def native_run(self, obj: Any, shots: int) -> dict[str, Any]:
+        """cudaq.sample on the kernel; bitstrings read qubit 0 first (conformance C3)."""
+        import cudaq
+
+        result = cudaq.sample(obj, shots_count=shots)
+        return self._reversed_reading({str(bits): int(count) for bits, count in result.items()},
+                                      f"cudaq {_version()} sample (target {cudaq.get_target().name})")

quantbom/frameworks/pennylane.py

@@ -0,0 +1,116 @@
+"""PennyLane — translated through OpenQASM 2 (`qml.to_openqasm`), wires pinned.
+
+`qml.to_openqasm` numbers qubits by the order wires FIRST APPEAR in the tape,
+not device order: a program starting with `PauliX(2)` was exported as
+`x q[0]` and certified as a circuit flipping qubit 0 (QNT-06 caught it). The
+translation, QNT-06's reference unitary and its export fingerprint therefore
+all use one order, defined once in `wire_order`. Qubit 0 first.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .base import FrameworkAdapter, Undecidable, dist_version, qiskit_version
+
+
+def _root(obj: Any) -> str:
+    return (type(obj).__module__ or "").split(".")[0]
+
+
+class PennyLaneAdapter(FrameworkAdapter):
+    name = "pennylane"
+    component = "pennylane"
+    license = "Apache-2.0"
+    bit_order = "qubit0_first"
+    translation = "openqasm2"
+    supports_dynamic = False
+    reference = "dense"
+
+    def detect(self, obj: Any) -> bool:
+        return _root(obj) == "pennylane"
+
+    def dynamic_features(self, obj: Any) -> list[str]:
+        """Mid-circuit measurements (`qml.measure`) and conditionals (`qml.cond`) on the tape."""
+        import pennylane as qml
+
+        try:
+            ops = list(qml.workflow.construct_tape(obj)().operations)
+        except Exception:  # an open QNode: refused for its parameters before this matters
+            return []
+        names = {type(op).__name__ for op in ops}
+        out: list[str] = []
+        if names & {"MidMeasureMP", "MidMeasure"}:
+            out.append("mid-circuit-measurement")
+        if "Conditional" in names:
+            out.append("classical-control-flow")
+        return out
+
+    def wire_order(self, obj: Any) -> list:
+        """The device's wires, or — for a device without fixed wires — the tape's, sorted."""
+        wires = list(getattr(getattr(obj, "device", None), "wires", None) or [])
+        if wires:
+            return wires
+        import pennylane as qml
+
+        tape_wires = list(qml.workflow.construct_tape(obj)().wires)
+        try:
+            return sorted(tape_wires)
+        except TypeError:  # mixed label types: no natural order, keep the tape's
+            return tape_wires
+
+    def open_parameters(self, obj: Any) -> list[str]:
+        """QNode arguments without a default: the circuit depends on values not given."""
+        import inspect
+
+        func = getattr(obj, "func", None)
+        if func is None:
+            return []
+        return [n for n, p in inspect.signature(func).parameters.items()
+                if p.default is inspect.Parameter.empty and p.kind not in (p.VAR_POSITIONAL, p.VAR_KEYWORD)]
+
+    def _openqasm(self, obj: Any) -> str:
+        import pennylane as qml
+
+        exported = qml.to_openqasm(obj, wires=self.wire_order(obj))
+        return exported() if callable(exported) else exported
+
+    def lower(self, obj: Any) -> tuple[Any, str, Any]:
+        import pennylane as qml
+        from qiskit import QuantumCircuit
+
+        return QuantumCircuit.from_qasm_str(self._openqasm(obj)), f"pennylane {qml.__version__} / qiskit {qiskit_version()}", None
+
+    def native_export(self, obj: Any) -> tuple[str, str]:
+        return self._openqasm(obj), "openqasm2"
+
+    def reference_unitary(self, obj: Any) -> tuple[Any, str]:
+        import pennylane as qml
+
+        return qml.matrix(obj, wire_order=self.wire_order(obj))(), f"pennylane {dist_version('pennylane')} qml.matrix"
+
+    def reference_state(self, obj: Any) -> tuple[Any, str]:
+        import numpy as np
+        import pennylane as qml
+
+        order = self.wire_order(obj)  # the same order the unitary reference and the export use
+        tape = qml.workflow.construct_tape(obj)()
+        script = qml.tape.QuantumScript(tape.operations, [qml.state()], shots=None)
+        device = obj.device if list(getattr(obj.device, "wires", None) or []) == order else qml.device("default.qubit", wires=order)
+        state = np.asarray(qml.execute([script], device)[0], dtype=complex)
+        return state, f"pennylane {dist_version('pennylane')} qml.state() on wire order {order}"
+
+    def native_sample(self, obj: Any, shots: int = 8) -> dict[str, int]:
+        """PennyLane's own reading: the QNode's probabilities over its wire order."""
+        probs = obj()
+        n = len(self.wire_order(obj))
+        return {format(i, f"0{n}b"): int(round(float(p) * shots)) for i, p in enumerate(probs) if float(p) > 1e-12}
+
+    def native_run(self, obj: Any, shots: int) -> dict[str, Any]:
+        """PennyLane's own device: the QNode's exact probabilities over its wire
+        order, scaled to `shots`. The comparison still treats them as a sample of
+        `shots`, which can only widen its error bound."""
+        try:
+            reading = self.native_sample(obj, shots)
+        except Exception as err:
+            raise Undecidable(f"the QNode does not return qml.probs over its wires ({type(err).__name__}: {err})") from err
+        return self._reversed_reading(reading, f"pennylane {dist_version('pennylane')} QNode probabilities")

quantbom/frameworks/qiskit.py

@@ -0,0 +1,67 @@
+"""Qiskit — the normalized IR itself: no translation, nothing for QNT-06 to check."""
+from __future__ import annotations
+
+from typing import Any
+
+from .base import FrameworkAdapter, Undecidable, qiskit_version
+
+
+class QiskitAdapter(FrameworkAdapter):
+    name = "qiskit"
+    component = "qiskit"  # always listed by the SBOM builder, as the IR
+    license = "Apache-2.0"
+    bit_order = "qubit0_last"
+    translation = None
+    supports_dynamic = True
+    reference = "none"  # the input already is the IR: nothing to compare
+
+    def detect(self, obj: Any) -> bool:
+        try:
+            from qiskit import QuantumCircuit
+        except Exception:
+            return False
+        return isinstance(obj, QuantumCircuit)
+
+    def lower(self, obj: Any) -> tuple[Any, str, Any]:
+        return obj, f"qiskit {qiskit_version()} (in-memory)", None
+
+    def load(self, kind: str, path: str) -> tuple[Any, str, str]:
+        """File inputs: (qiskit_circuit, label, source_format)."""
+        qkv = qiskit_version()
+        if kind == "qpy":
+            from qiskit import qpy
+
+            with open(path, "rb") as fh:
+                return qpy.load(fh)[0], f"qiskit {qkv} (qpy import)", "qpy"
+        if kind == "qasm3":
+            from qiskit import qasm3
+
+            return qasm3.load(path), f"qiskit {qkv} (openqasm3)", "openqasm3"
+        if kind == "qasm2":
+            from qiskit import QuantumCircuit
+
+            return QuantumCircuit.from_qasm_file(path), f"qiskit {qkv} (openqasm2)", "openqasm2"
+        raise ValueError(f"unknown circuit source: {kind}")
+
+    def native_sample(self, obj: Any, shots: int = 8) -> dict[str, int]:
+        from qiskit import transpile
+
+        from .._circuit import CONTROL_FLOW
+
+        circ = obj.copy()
+        if not any(i.operation.name == "measure" for i in circ.data):
+            circ.measure_all()
+        if any(i.operation.name in CONTROL_FLOW for i in circ.data):
+            # BasicSimulator cannot run classical control flow; qiskit-aer can
+            try:
+                from qiskit_aer import AerSimulator
+            except Exception as exc:
+                raise Undecidable("sampling a dynamic circuit needs qiskit-aer (pip install 'quantbom[sim]')") from exc
+            backend = AerSimulator()
+            counts = backend.run(transpile(circ, backend), shots=shots, seed_simulator=11).result().get_counts()
+        else:
+            from qiskit.providers.basic_provider import BasicSimulator
+
+            backend = BasicSimulator()
+            counts = backend.run(transpile(circ, backend), shots=shots).result().get_counts()
+        return {str(k).replace(" ", ""): int(v) for k, v in counts.items()}