quantbom 0.6.0__py3-none-any.whl

quantbom/frameworks/qrisp.py

@@ -0,0 +1,267 @@
+"""Qrisp — compiled by Qrisp, then converted by Qrisp's own `.to_qiskit()`.
+
+Two steps, judged separately. Qrisp's compiler (`QuantumSession.compile()`,
+`Jaspr.to_qc()`) turns typed variables into a Qrisp QuantumCircuit; whether
+that matches the developer's intent is checked by declared results
+(QBOM-BENCH-02) and service re-execution. The conversion of that circuit to
+Qiskit is a translation like any other adapter's, and QNT-06 checks it against
+Qrisp's OWN simulator (`get_unitary`, `statevector_array`, big-endian: qubit 0
+most significant), up to the dense and state-vector caps.
+
+The native program (`native_export`) is Qrisp's compiled circuit in Qrisp's
+terms (`secqdevops.qrisp-program/v1`): qubit identifiers (`primary.0`), the
+typed variables that own them, the instruction list including Qrisp's own
+bookkeeping (`qb_alloc`), and Qrisp's metrics. It is a faithful record of what
+`to_qiskit()` consumed, not a re-loadable program. There is no decision-diagram
+method for Qrisp: Qrisp's OpenQASM exporters go through Qiskit, so checking
+one against the other would compare Qiskit with itself. Qrisp before 0.9
+simulates in single precision, which cannot meet the 1e-7 tolerance; the
+reference is then undecidable (N-A with the reason), never `unfaithful`.
+
+Three input kinds, each with its OWN reading of a bitstring (K0b spike,
+5 Oct 2026 — pinned here and held by the conformance suite, C3/C4):
+
+  QuantumCircuit   `qc.run()`                      qubit 0 is the RIGHTMOST character (Qiskit's order)
+  QuantumSession   `QuantumVariable.get_measurement()`  qubit 0 is the LEFTMOST character
+  Jaspr            `measure(qv)` -> integer, bit 0 = qubit 0; `to_qc()` allocates the
+                   classical bits in reverse, so the LOWERED circuit's measured string
+                   also reads qubit 0 first
+
+A declaration written the way the user sees results is therefore translated
+per kind (`bit_order_for`), and for a Jaspr the lowered circuit's own order is
+not Qiskit's (`measured_order_for`). Getting either wrong fails correct
+releases and can pass wrong ones — the PennyLane lesson.
+
+Dynamic programs. Classic Qrisp cannot express feed-forward at all
+(`control(clbit)` is refused by Qrisp); mid-circuit measurement and reset
+lower faithfully and are accepted. Jasp expresses feed-forward on a measured
+bit (`with control(measure(...))`), which lowers to a Qiskit `if_else`. Any
+real-time classical computation — repeat-until-success, arithmetic or
+comparisons on results, loops bounded by a measurement — has no circuit
+representation; Qrisp itself refuses to convert it, and so does this adapter,
+with the reason (the QIR route, K5, is the way to certify those).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .base import FrameworkAdapter, Undecidable, dist_version, qiskit_version
+
+REALTIME_REFUSAL = (
+    "Jasp programs with real-time classical computation (repeat-until-success, arithmetic or comparisons "
+    "on measurement results, loops bounded by a measurement) have no circuit representation: Qrisp cannot "
+    "convert them. Feed-forward on a measured bit alone (`with control(measure(...))`) is supported. "
+    "Certifying real-time programs needs the QIR route (HARNESS_KITS_PLAN.md K5)"
+)
+ARGUMENT_REFUSAL = (
+    "Jasp programs with arguments are not supported: the certified circuit would depend on values the "
+    "evidence does not record. Wrap it in an argument-free function that binds them, then make_jaspr(...)()"
+)
+
+
+def _is_jaspr(obj: Any) -> bool:
+    return (type(obj).__module__ or "").startswith("qrisp.jasp") and callable(getattr(obj, "to_qc", None))
+
+
+def _jaspr_arguments(jaspr: Any) -> list[str]:
+    """Argument variables of a traced Jasp program (everything but the quantum state)."""
+    return [str(v.aval) for v in getattr(jaspr, "invars", ()) if "QuantumState" not in str(v.aval)]
+
+
+#: id(program) -> (program, its compiled Qrisp circuit). `Jaspr.to_qc()` names
+#: qubits from a global counter (qb_59 on one call, qb_77 on the next), so the
+#: circuit is compiled once per program and every reader — lowering, the native
+#: export the QNT-06 report hashes, the file written beside it, both references —
+#: sees the same one. The program is held, so its id cannot be reused meanwhile.
+_COMPILED: dict[int, tuple[Any, Any]] = {}
+
+
+def _compiled_once(program: Any, compile_: Any) -> Any:
+    hit = _COMPILED.get(id(program))
+    if hit is not None and hit[0] is program:
+        return hit[1]
+    qc = compile_()
+    _COMPILED[id(program)] = (program, qc)
+    return qc
+
+
+def _jaspr_circuit(jaspr: Any) -> Any:
+    """Qrisp's own lowering of a Jasp program to its QuantumCircuit, with refusals explained."""
+    if _jaspr_arguments(jaspr):
+        raise ValueError(ARGUMENT_REFUSAL)
+
+    def to_qc() -> Any:
+        try:
+            _, qc = jaspr.to_qc()
+        except Exception as err:
+            if "real-time feedback" in str(err):
+                raise ValueError(REALTIME_REFUSAL) from err
+            raise
+        return qc
+
+    return _compiled_once(jaspr, to_qc)
+
+
+class QrispAdapter(FrameworkAdapter):
+    name = "qrisp"
+    component = "qrisp"
+    license = "EUPL-1.2"
+    bit_order = "by-input"
+    bit_orders = {"QuantumCircuit": "qubit0_last", "QuantumSession": "qubit0_first", "Jaspr": "qubit0_first"}
+    translation = "qrisp-to_qiskit"  # Qrisp's own converter, checked by QNT-06 against Qrisp's simulator
+    supports_dynamic = True  # mid-circuit measurement and reset (classic), feed-forward (Jasp): verified by C7
+    reference = "dense"
+
+    def detect(self, obj: Any) -> bool:
+        # duck-typed: Qrisp QuantumCircuit and QuantumSession both expose it; a Jaspr exposes to_qc
+        return callable(getattr(obj, "to_qiskit", None)) or _is_jaspr(obj)
+
+    def input_kind(self, obj: Any) -> str:
+        if _is_jaspr(obj):
+            return "Jaspr"
+        if type(obj).__name__ == "QuantumCircuit":
+            return "QuantumCircuit"
+        return "QuantumSession"
+
+    def measured_order_for(self, obj: Any) -> str:
+        # Jaspr.to_qc() numbers classical bits in reverse (qubit i -> clbit n-1-i)
+        return "qubit0_first" if self.input_kind(obj) == "Jaspr" else "qubit0_last"
+
+    def lower(self, obj: Any) -> tuple[Any, str, Any]:
+        if _is_jaspr(obj):
+            qc = _jaspr_circuit(obj)
+            return qc.to_qiskit(), f"qrisp {dist_version('qrisp')} (jasp) / qiskit {qiskit_version()}", qc
+        return obj.to_qiskit(), f"qrisp {dist_version('qrisp')} / qiskit {qiskit_version()}", obj
+
+    # ---- native support: Qrisp's own record of the program, and its own simulator ----
+    def _native_circuit(self, obj: Any) -> Any:
+        """The Qrisp QuantumCircuit `to_qiskit()` converts: compiled for a session."""
+        kind = self.input_kind(obj)
+        if kind == "Jaspr":
+            return _jaspr_circuit(obj)
+        if kind == "QuantumSession":
+            return _compiled_once(obj, obj.compile)
+        return obj
+
+    def native_export(self, obj: Any) -> tuple[str, str]:
+        import json
+
+        qc = self._native_circuit(obj)
+
+        def name(bit: Any) -> str:
+            return str(getattr(bit, "identifier", bit))
+
+        def param(p: Any) -> Any:
+            try:
+                return float(p)
+            except (TypeError, ValueError):
+                return str(p)
+
+        variables = [{"name": qv.name, "type": type(qv).__name__, "size": int(qv.size),
+                      "qubits": [name(q) for q in qv.reg]}
+                     for qv in (getattr(obj, "qv_list", None) or [])]  # sessions on Qrisp >= 0.9
+        program = {
+            "schema": "secqdevops.qrisp-program/v1",
+            "framework": "qrisp",
+            "qrisp_version": dist_version("qrisp"),
+            "input_kind": self.input_kind(obj),
+            "qubits": [name(q) for q in qc.qubits],
+            "clbits": [name(c) for c in qc.clbits],
+            **({"variables": variables} if variables else {}),
+            "instructions": [{"op": ins.op.name, "qubits": [name(q) for q in ins.qubits],
+                              **({"clbits": [name(c) for c in ins.clbits]} if ins.clbits else {}),
+                              **({"params": [param(p) for p in ins.op.params]} if ins.op.params else {})}
+                             for ins in qc.data],
+            "metrics": {"num_qubits": int(qc.num_qubits()), "depth": int(qc.depth()),
+                        "cnot_count": int(qc.cnot_count()), "cnot_depth": int(qc.cnot_depth()),
+                        "t_depth": int(qc.t_depth()),
+                        "count_ops": {str(k): int(v) for k, v in dict(qc.count_ops()).items()}},
+        }
+        return json.dumps(program, indent=2, ensure_ascii=True) + "\n", "qrisp-program-json"
+
+    def _unitary_body(self, obj: Any) -> Any:
+        """The compiled circuit without terminal measurements and allocation bookkeeping;
+        a measurement or reset acted on afterwards makes it non-unitary."""
+        qc = self._native_circuit(obj)
+        body, measured = qc.clearcopy(), set()
+        for ins in qc.data:
+            op = ins.op.name
+            if op in ("qb_alloc", "qb_dealloc", "barrier"):
+                continue
+            if op == "measure":
+                measured.update(ins.qubits)
+                continue
+            if op == "reset" or measured.intersection(ins.qubits) or ins.clbits:
+                raise Undecidable("non-terminal measurement, reset or classical control: the circuit is not a unitary")
+            body.append(ins)
+        return body
+
+    @staticmethod
+    def _double(array: Any, what: str) -> Any:
+        import numpy as np
+
+        array = np.asarray(array)
+        if array.dtype != np.complex128:
+            raise Undecidable(f"qrisp {dist_version('qrisp')} returns its {what} as {array.dtype}: single precision "
+                              "cannot meet the 1e-7 comparison tolerance (Qrisp >= 0.9 simulates in double)")
+        return array
+
+    @staticmethod
+    def _simulate(call: Any) -> Any:
+        """Run Qrisp's simulator without its progress bar in the producer's terminal."""
+        import contextlib
+        import io
+
+        with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+            return call()
+
+    def reference_unitary(self, obj: Any) -> tuple[Any, str]:
+        body = self._unitary_body(obj)
+        return (self._double(self._simulate(body.get_unitary), "unitary"),
+                f"qrisp {dist_version('qrisp')} QuantumCircuit.get_unitary")
+
+    def reference_state(self, obj: Any) -> tuple[Any, str]:
+        body = self._unitary_body(obj)
+        return (self._double(self._simulate(body.statevector_array), "state vector").reshape(-1),
+                f"qrisp {dist_version('qrisp')} QuantumCircuit.statevector_array")
+
+    def native_run(self, obj: Any, shots: int) -> dict[str, Any]:
+        """Qrisp's own simulator on the compiled circuit — the one the native
+        export records. Qrisp's QuantumCircuit.run() reads classical bits as the
+        lowered circuit's measured string does (clbit 0 rightmost), for every
+        input kind, so no reordering is needed."""
+        qc = self._native_circuit(obj).copy()
+        if not any(ins.op.name == "measure" for ins in qc.data):
+            qc.measure(qc.qubits)  # clbit i <- qubit i, as measure_all() on the lowered circuit
+        counts = self._simulate(lambda: qc.run(shots=shots))
+        measured = {str(k).replace(" ", ""): int(v) for k, v in counts.items()}
+        run = {"simulator": f"qrisp {dist_version('qrisp')} QuantumCircuit.run", "reading": measured,
+               "reading_order": "measured", "measured": measured}
+        variables = list(getattr(obj, "qv_list", None) or []) if self.input_kind(obj) == "QuantumSession" else []
+        index = {str(getattr(q, "identifier", q)): i for i, q in enumerate(qc.qubits)}
+        if variables and not any(ins.op.name == "measure" for ins in self._native_circuit(obj).data):
+            # the same outcomes in the developer's vocabulary: each variable's own bits
+            def value(qv: Any, key: str) -> Any:
+                bits = [key[-1 - index[str(getattr(q, "identifier", q))]] for q in qv.reg]
+                return bits[0] == "1" if type(qv).__name__ == "QuantumBool" else "".join(bits)
+
+            run["by_variable"] = [{"values": {qv.name: value(qv, key) for qv in variables}, "count": n}
+                                  for key, n in sorted(measured.items(), key=lambda kv: -kv[1])]
+        return run
+
+    def export_for_equivalence(self, obj: Any) -> tuple[str, str, str | None]:
+        raise Undecidable("Qrisp's OpenQASM exporters go through Qiskit, so a decision-diagram check of the "
+                          "export would compare Qiskit with itself; Qrisp's own simulator is the reference")
+
+    def native_sample(self, obj: Any, shots: int = 8) -> dict[str, int]:
+        kind = self.input_kind(obj)
+        if kind == "QuantumCircuit":
+            return {str(k): int(v) for k, v in obj.run(shots=shots).items()}
+        if kind == "Jaspr":
+            return {str(k): int(v) for k, v in _jaspr_circuit(obj).run(shots=shots).items()}
+        # a session: Qrisp's own reading is QuantumVariable.get_measurement() (probabilities)
+        variables = list(getattr(obj, "qv_list", []))
+        if len(variables) != 1:
+            raise Undecidable("native_sample expects a session holding exactly one QuantumVariable")
+        probs = variables[0].get_measurement()
+        return {str(k): int(round(float(p) * shots)) for k, p in probs.items() if float(p) > 1e-12}