dyber 0.1.0__py3-none-any.whl

dyber/__init__.py

@@ -0,0 +1,19 @@
+"""
+Dyber SDK: interact with the H-cat photonic quantum computer.
+
+Write a circuit once, run it on the local simulator today and on the H-cat QPU later,
+unchanged. The simulator is physics-informed by the validated H-cat resource and loss
+models.
+
+    from dyber import Dyber, Circuit
+    dy = Dyber()
+    c = Circuit(2); c.h(0); c.cx(0, 1); c.measure_all()
+    job = dy.backend("local_simulator").run(c, shots=1000)
+    print(job.result().counts())
+"""
+from .circuit import Circuit
+from .result import Result, Job
+from .provider import Dyber
+
+__version__ = "0.1.0"
+__all__ = ["Dyber", "Circuit", "Result", "Job", "__version__"]

dyber/backend.py

@@ -0,0 +1,108 @@
+"""Dyber SDK backends. Same interface for the local simulator and the remote QPU."""
+from __future__ import annotations
+import json
+import time
+import urllib.request
+import urllib.error
+
+from . import simulator, native, protocol
+from .circuit import Circuit
+from .result import Result, Job
+
+
+class Backend:
+    name = "backend"
+    online = True
+    def run(self, circuit, shots=1024, **options) -> Job:
+        raise NotImplementedError
+    def __repr__(self):
+        return f"<Backend {self.name!r} online={self.online}>"
+
+
+class LocalSimulatorBackend(Backend):
+    name = "local_simulator"
+    online = True
+
+    def run(self, circuit, shots=1024, seed=None, **options):
+        rep = native.resource_report(
+            circuit,
+            loss_per_cycle=options.get("loss_per_cycle", 0.005),
+            target_logical_err=options.get("target_logical_err", 1e-9),
+            alpha=options.get("alpha", 2.0),
+            p_herald=options.get("p_herald"),
+            spatial=options.get("spatial", 16),
+            wavelength=options.get("wavelength", 32),
+            code=options.get("code", "surface"),
+            fault_tolerant=options.get("fault_tolerant", True),
+            corrected_threshold=options.get("corrected_threshold", True),
+        )
+        sim = simulator.run(
+            circuit, shots=shots, seed=seed,
+            loss_per_cycle=options.get("loss_per_cycle") if options.get("noise", True) else None,
+            resources=rep,
+        )
+        meta = {"resources": rep, "noise": sim["noise"],
+                "native": native.transpile(circuit)["summary"]}
+        res = Result(sim["counts"], shots, self.name, metadata=meta)
+        return Job(job_id="local-" + format(abs(hash((circuit.name, shots))) % 10**8, "08d"),
+                   backend_name=self.name, result=res, status="completed")
+
+
+class RemoteBackend(Backend):
+    """Talks the job protocol over HTTP. Works against the reference control server
+    today and the real control plane later, unchanged."""
+    name = "remote"
+
+    def __init__(self, url, name=None, timeout=30):
+        self.url = url.rstrip("/")
+        self.timeout = timeout
+        if name:
+            self.name = name
+        self.online = self._ping()
+
+    def _ping(self):
+        try:
+            urllib.request.urlopen(self.url + "/health", timeout=3).read()
+            return True
+        except Exception:
+            return False
+
+    def _post(self, path, payload):
+        data = json.dumps(payload).encode()
+        req = urllib.request.Request(self.url + path, data=data,
+                                     headers={"Content-Type": "application/json"})
+        with urllib.request.urlopen(req, timeout=self.timeout) as r:
+            return json.loads(r.read())
+
+    def _get(self, path):
+        with urllib.request.urlopen(self.url + path, timeout=self.timeout) as r:
+            return json.loads(r.read())
+
+    def run(self, circuit, shots=1024, poll=0.3, **options):
+        if not self.online:
+            raise ConnectionError(
+                f"{self.name} is not reachable at {self.url}. The H-cat QPU is not yet "
+                "online. Use the 'local_simulator' backend, or start the reference control "
+                "server (python -m dyber.server) and point a backend at it.")
+        req = protocol.make_job_request(circuit, shots, options)
+        resp = self._post("/jobs", req)
+        job_id = resp["job_id"]
+        while resp.get("status") in ("queued", "running"):
+            time.sleep(poll)
+            resp = self._get(f"/jobs/{job_id}")
+        if resp.get("status") != "completed":
+            return Job(job_id, self.name, result=None, status=resp.get("status", "failed"))
+        payload = self._get(f"/jobs/{job_id}/result")["result"]
+        res = Result(payload["counts"], payload["shots"], self.name,
+                     metadata={"resources": payload.get("resources"),
+                               "noise": payload.get("noise"),
+                               "native": payload.get("native")})
+        return Job(job_id, self.name, result=res, status="completed")
+
+
+class HCatQPUBackend(RemoteBackend):
+    """The real H-cat machine, reached through the control plane. Offline until the
+    hardware exists; defaults to the production control-plane URL."""
+    name = "hcat_qpu"
+    def __init__(self, url="https://qpu.dyber.org", timeout=30):
+        super().__init__(url, name="hcat_qpu", timeout=timeout)

dyber/circuit.py

@@ -0,0 +1,90 @@
+"""Dyber SDK: the user-facing circuit model.
+
+A small gate-model circuit you write once and run on any Dyber backend (local
+simulator today, H-cat QPU later). Qubit 0 is the leftmost bit in result strings.
+"""
+from __future__ import annotations
+
+_1Q = {"i", "x", "y", "z", "h", "s", "sdg", "t", "tdg"}
+_1Q_PARAM = {"rx", "ry", "rz", "p"}
+_2Q = {"cx", "cz", "swap"}
+
+
+class Circuit:
+    def __init__(self, num_qubits: int, name: str = "circuit"):
+        if num_qubits < 1:
+            raise ValueError("num_qubits must be >= 1")
+        self.num_qubits = int(num_qubits)
+        self.name = name
+        self.ops = []          # list of dicts: {gate, qubits, params}
+        self.measured = []     # ordered list of measured qubit indices
+
+    # ---- single-qubit gates ----
+    def _add1(self, g, q):
+        self._check(q)
+        self.ops.append({"gate": g, "qubits": [int(q)], "params": []})
+        return self
+    def i(self, q): return self._add1("i", q)
+    def x(self, q): return self._add1("x", q)
+    def y(self, q): return self._add1("y", q)
+    def z(self, q): return self._add1("z", q)
+    def h(self, q): return self._add1("h", q)
+    def s(self, q): return self._add1("s", q)
+    def sdg(self, q): return self._add1("sdg", q)
+    def t(self, q): return self._add1("t", q)
+    def tdg(self, q): return self._add1("tdg", q)
+
+    def _add1p(self, g, theta, q):
+        self._check(q)
+        self.ops.append({"gate": g, "qubits": [int(q)], "params": [float(theta)]})
+        return self
+    def rx(self, theta, q): return self._add1p("rx", theta, q)
+    def ry(self, theta, q): return self._add1p("ry", theta, q)
+    def rz(self, theta, q): return self._add1p("rz", theta, q)
+    def p(self, theta, q): return self._add1p("p", theta, q)
+
+    # ---- two-qubit gates ----
+    def _add2(self, g, a, b):
+        self._check(a); self._check(b)
+        if a == b:
+            raise ValueError("two-qubit gate needs distinct qubits")
+        self.ops.append({"gate": g, "qubits": [int(a), int(b)], "params": []})
+        return self
+    def cx(self, ctrl, tgt): return self._add2("cx", ctrl, tgt)
+    def cz(self, a, b): return self._add2("cz", a, b)
+    def swap(self, a, b): return self._add2("swap", a, b)
+
+    # ---- measurement ----
+    def measure(self, q):
+        self._check(q)
+        if q not in self.measured:
+            self.measured.append(int(q))
+        self.ops.append({"gate": "measure", "qubits": [int(q)], "params": []})
+        return self
+    def measure_all(self):
+        for q in range(self.num_qubits):
+            self.measure(q)
+        return self
+
+    def _check(self, q):
+        if not (0 <= q < self.num_qubits):
+            raise ValueError(f"qubit {q} out of range 0..{self.num_qubits-1}")
+
+    # ---- serialization (wire protocol) ----
+    def to_dict(self):
+        return {"num_qubits": self.num_qubits, "name": self.name,
+                "ops": self.ops, "measured": self.measured}
+
+    @classmethod
+    def from_dict(cls, d):
+        c = cls(d["num_qubits"], d.get("name", "circuit"))
+        c.ops = list(d.get("ops", []))
+        c.measured = list(d.get("measured", []))
+        return c
+
+    def depth_2q(self):
+        return sum(1 for o in self.ops if o["gate"] in _2Q)
+
+    def __repr__(self):
+        return (f"Circuit(name={self.name!r}, qubits={self.num_qubits}, "
+                f"ops={len(self.ops)}, measured={self.measured})")

dyber/native.py

@@ -0,0 +1,183 @@
+"""Dyber SDK: lowering to native H-cat operations and the resource report.
+
+transpile() maps a gate-model circuit onto native H-cat operations (cat preparation,
+hybrid fusion, parity readout). On real hardware this lowering is performed by the
+proprietary OpenForge back-end; here it is an illustrative mapping plus the resource
+estimate, which also supplies the simulator's physics-informed noise rate.
+"""
+from __future__ import annotations
+import math
+
+# ---- v2 calibration constants ----
+# Hardcoded so the SDK stays dependency-light.
+#
+# Circuit-level distance calibration:
+#   Lambda(gamma) = (p_th_circ / gamma)^1.61
+#   LER(d) = A_CIRC * Lambda^(-(d+1)/2)
+P_TH_CIRC = 0.0079            # corrected circuit-level loss threshold per cycle
+                              # (default; folds in the validated ~2.9x silent-Pauli
+                              # digital-twin correction)
+P_TH_CIRC_UNCORRECTED = 0.00898  # default-knob circuit-level threshold
+                                 # (bootstrap 95 percent CI 0.852-0.916 percent)
+LAMBDA_EXP = 1.61             # margin-ladder fit exponent
+A_CIRC = 0.30                 # global prefactor, fit so the model reproduces the
+                              # authoritative circuit-level points:
+                              # d(1e-9) = 29 / 41 / 61 at gamma = 0.4 / 0.5 / 0.6
+                              # percent with the uncorrected threshold
+QLDPC_GAIN = 10.0
+ALPHA0 = 1.0
+
+# Cat production: heralded generation and breeding success, plus the multiplexing
+# herald-collision tax at a 2 spatial x 8 wavelength architecture (231.5 -> 239.5):
+P_GEN = 0.30
+P_BREED = 0.24
+MUX_ATTEMPT_FACTOR = 239.0 / 231.0
+
+# Loss-split correction factors: exact channel measured on the bred-cat density
+# matrix vs the Poisson closed form, ratio (measured / Poisson) for erase and pauli:
+_SPLIT_GAMMA_GRID = (0.005, 0.010, 0.020, 0.030)
+_SPLIT_F_ERASE = (0.9583507007766099, 0.9205203546179248,
+                  0.854608265667542, 0.7994035470416974)
+_SPLIT_F_PAULI = (3.0846032998386854, 2.919170374042666,
+                  2.629331412714363, 2.384856621831815)
+
+
+def _split_correction(gamma):
+    """Digital-twin correction factors (f_erase, f_pauli), linearly interpolated
+    on the measured grid gamma in [0.5, 3] percent and CLIPPED outside it
+    (constant extrapolation at the nearest measured point), exactly as the v2
+    resource model does. Below 0.5 percent the measured pauli ratio rises
+    monotonically (2.38 -> 3.08), so holding 3.08 flat is conservative."""
+    g = min(max(gamma, _SPLIT_GAMMA_GRID[0]), _SPLIT_GAMMA_GRID[-1])
+    for i in range(len(_SPLIT_GAMMA_GRID) - 1):
+        g0, g1 = _SPLIT_GAMMA_GRID[i], _SPLIT_GAMMA_GRID[i + 1]
+        if g <= g1:
+            t = (g - g0) / (g1 - g0)
+            f_e = _SPLIT_F_ERASE[i] + t * (_SPLIT_F_ERASE[i + 1] - _SPLIT_F_ERASE[i])
+            f_p = _SPLIT_F_PAULI[i] + t * (_SPLIT_F_PAULI[i + 1] - _SPLIT_F_PAULI[i])
+            return f_e, f_p
+    return _SPLIT_F_ERASE[-1], _SPLIT_F_PAULI[-1]
+
+
+def _loss_split(alpha, gamma):
+    """Per-cycle loss -> (heralded erasure, unheralded Pauli), v2 calibrated:
+    Poisson closed form times the digital-twin correction factors."""
+    lam = alpha * alpha * gamma
+    p_e = max((1 - math.exp(-2 * lam)) / 2, 0.0)            # heralded erasure
+    p_z = max((1 + math.exp(-2 * lam)) / 2 - math.exp(-lam), 0.0)  # unheralded Pauli
+    f_e, f_p = _split_correction(gamma)
+    return p_e * f_e, p_z * f_p
+
+
+def _rounds(alpha):
+    return max(0, math.ceil(2 * math.log2(alpha / ALPHA0)))
+
+
+def _distance(gamma, target_err, corrected_threshold=True):
+    """v2 circuit-level distance: smallest odd d with
+    A_CIRC * Lambda^(-(d+1)/2) <= target, Lambda = (p_th_circ/gamma)^1.61.
+    Returns None at or above threshold (Lambda <= 1: increasing d makes the
+    logical error worse, as measured at gamma = 1 percent)."""
+    p_th = P_TH_CIRC if corrected_threshold else P_TH_CIRC_UNCORRECTED
+    lam = (p_th / gamma) ** LAMBDA_EXP
+    if lam <= 1.0:
+        return None
+    m = math.ceil(math.log(A_CIRC / target_err) / math.log(lam))   # = (d+1)/2
+    return max(3, 2 * m - 1)
+
+
+def transpile(circuit):
+    """Return a native H-cat program summary for the circuit."""
+    n = circuit.num_qubits
+    native = []
+    for q in range(n):
+        native.append({"op": "prepare_cat", "qubit": q})
+    fusions = 0
+    for op in circuit.ops:
+        g = op["gate"]
+        if g == "measure":
+            native.append({"op": "measure_parity", "qubit": op["qubits"][0]})
+        elif g in ("cx", "cz", "swap"):
+            native.append({"op": "hybrid_fusion", "qubits": op["qubits"]})
+            fusions += 1
+        else:
+            native.append({"op": "single_mode_op", "gate": g, "qubits": op["qubits"]})
+    summary = {"cat_preparations": n, "hybrid_fusions": fusions,
+               "parity_measurements": len(circuit.measured) or n,
+               "native_op_count": len(native)}
+    return {"native": native, "summary": summary}
+
+
+def resource_report(circuit, loss_per_cycle=0.005, target_logical_err=1e-9,
+                    alpha=2.0, p_herald=None, spatial=16, wavelength=32,
+                    code="surface", fault_tolerant=True, corrected_threshold=True,
+                    p_gen=P_GEN, p_breed=P_BREED):
+    """Device-level resource estimate for running this circuit, plus the effective
+    error rate the simulator uses for physics-informed noise.
+
+    v2 calibrated. The default operating
+    point is the 0.5 percent per-cycle loss spec (d=53, 5,617 cats per logical at
+    1e-9 with the corrected 0.79 percent circuit-level threshold; pass
+    corrected_threshold=False for the uncorrected 0.898 percent calibration,
+    d=41 / 3,361). At 1 percent loss the model honestly reports the
+    above-threshold regime: no code distance reaches a fault-tolerant target,
+    and the NISQ / error-detected estimate is returned instead.
+
+    p_herald, if given, overrides both p_gen and p_breed (legacy single-knob
+    behavior). The mux herald-collision tax (239/231) is always applied.
+    """
+    gamma = loss_per_cycle
+    p_e, p_z = _loss_split(alpha, gamma)
+    if p_herald is not None:
+        p_gen = p_breed = p_herald
+    att = (2.0 / p_breed) ** _rounds(alpha) / p_gen * MUX_ATTEMPT_FACTOR
+
+    rep = {"loss_per_cycle": gamma, "alpha": alpha, "p_erase": p_e, "p_pauli": p_z,
+           "attempts_per_cat": att, "breeding_rounds": _rounds(alpha),
+           "outer_code": code if fault_tolerant else "none"}
+
+    # ops touching each qubit (for NISQ noise accumulation)
+    nq = circuit.num_qubits
+    touch = [0] * nq
+    for op in circuit.ops:
+        if op["gate"] == "measure":
+            continue
+        for q in op["qubits"]:
+            touch[q] += 1
+    avg_ops = sum(touch) / max(nq, 1)
+
+    # NISQ / physical-regime error accumulation (also the honest fallback when
+    # the operating point is above the circuit-level threshold)
+    p_nisq = min(1.0 - (1.0 - p_z) ** max(avg_ops, 1), 0.5)
+
+    if not fault_tolerant or target_logical_err >= 0.01:
+        # NISQ / physical regime: unheralded Pauli accumulates over the circuit
+        rep.update({"regime": "nisq", "distance": 1, "cats_per_logical": 1,
+                    "hw_modes_per_logical": spatial,
+                    "logical_error_estimate": p_nisq})
+    else:
+        d = _distance(gamma, target_logical_err, corrected_threshold)
+        if d is None:
+            # Above the circuit-level threshold: no code distance reaches the
+            # target (increasing d makes the logical error worse). Report the
+            # NISQ / error-detected estimate so the simulator still has an
+            # honest physics-informed noise rate.
+            p_th = P_TH_CIRC if corrected_threshold else P_TH_CIRC_UNCORRECTED
+            rep.update({"regime": "above-threshold", "distance": None,
+                        "cats_per_logical": None, "hw_modes_per_logical": None,
+                        "logical_error_estimate": p_nisq,
+                        "note": ("per-cycle loss exceeds the circuit-level "
+                                 "threshold ({:.3g} percent); no fault-tolerant "
+                                 "distance exists, NISQ / error-detected regime "
+                                 "reported instead").format(p_th * 100)})
+        else:
+            cpl = 2 * d * d - 1
+            hw = spatial * cpl
+            if code == "qldpc":
+                hw = max(1, round(hw / QLDPC_GAIN))
+            # below threshold: logical error is approximately the target
+            rep.update({"regime": "fault-tolerant", "distance": d,
+                        "cats_per_logical": cpl, "hw_modes_per_logical": hw,
+                        "logical_error_estimate": float(target_logical_err)})
+    rep["throughput_per_logical"] = att * (rep.get("cats_per_logical") or 1)
+    return rep

dyber/protocol.py

@@ -0,0 +1,38 @@
+"""Dyber QPU job protocol: the wire format shared by the SDK and the control plane.
+
+A job is JSON. Today the control server executes it on the simulator; on hardware the
+same JSON is consumed by the FPGA control system. Keeping one schema means the SDK does
+not change when the backend becomes real silicon.
+
+Job request (POST /jobs):
+  {
+    "program":  <circuit.to_dict()>,        # gate-model circuit
+    "shots":    1024,
+    "options":  { "loss_per_cycle": 0.005, "target_logical_err": 1e-9,
+                  "alpha": 2.0, "code": "surface", "fault_tolerant": true }
+  }
+
+Job response (GET /jobs/{id} and /jobs/{id}/result):
+  {
+    "job_id": "...", "status": "queued|running|completed|failed",
+    "result": { "counts": {...}, "shots": N,
+                "resources": {...}, "noise": {...|null} }
+  }
+"""
+from __future__ import annotations
+
+PROTOCOL_VERSION = "1.0"
+
+
+def make_job_request(circuit, shots, options=None):
+    return {"protocol": PROTOCOL_VERSION,
+            "program": circuit.to_dict(),
+            "shots": int(shots),
+            "options": dict(options or {})}
+
+
+def make_result_payload(result):
+    return {"counts": result.counts(), "shots": result.shots,
+            "resources": result.metadata.get("resources"),
+            "noise": result.metadata.get("noise"),
+            "native": result.metadata.get("native")}

dyber/provider.py

@@ -0,0 +1,29 @@
+"""Dyber provider: the entry point. dy = Dyber(); dy.backend('local_simulator')."""
+from __future__ import annotations
+from .backend import LocalSimulatorBackend, RemoteBackend, HCatQPUBackend
+
+_BUILTIN = {"local_simulator", "hcat_qpu"}
+
+
+class Dyber:
+    def __init__(self, token=None):
+        self.token = token
+
+    def backends(self):
+        sim = LocalSimulatorBackend()
+        try:
+            qpu = HCatQPUBackend()
+            qstatus = "online" if qpu.online else "offline (hardware not yet available)"
+        except Exception:
+            qstatus = "offline"
+        return [{"name": "local_simulator", "status": "online"},
+                {"name": "hcat_qpu", "status": qstatus}]
+
+    def backend(self, name="local_simulator", **kw):
+        if name == "local_simulator":
+            return LocalSimulatorBackend()
+        if name == "hcat_qpu":
+            return HCatQPUBackend(url=kw.get("url", "https://qpu.dyber.org"))
+        if name == "remote":
+            return RemoteBackend(url=kw["url"], name=kw.get("label"))
+        raise ValueError(f"unknown backend {name!r}; try 'local_simulator' or 'hcat_qpu'")

dyber/result.py

@@ -0,0 +1,50 @@
+"""Dyber SDK: Job and Result objects."""
+from __future__ import annotations
+
+
+class Result:
+    def __init__(self, counts, shots, backend, metadata=None):
+        self._counts = counts
+        self.shots = shots
+        self.backend = backend
+        self.metadata = metadata or {}
+
+    def counts(self):
+        return dict(self._counts)
+
+    get_counts = counts
+
+    def probabilities(self):
+        return {k: v / self.shots for k, v in self._counts.items()}
+
+    def most_frequent(self):
+        return max(self._counts, key=self._counts.get) if self._counts else None
+
+    @property
+    def resources(self):
+        return self.metadata.get("resources")
+
+    @property
+    def noise(self):
+        return self.metadata.get("noise")
+
+    def __repr__(self):
+        return f"Result(backend={self.backend!r}, shots={self.shots}, outcomes={len(self._counts)})"
+
+
+class Job:
+    """Base job. Local jobs are completed on creation; remote jobs poll."""
+    def __init__(self, job_id, backend_name, result=None, status="completed"):
+        self.job_id = job_id
+        self.backend_name = backend_name
+        self._result = result
+        self._status = status
+
+    def status(self):
+        return self._status
+
+    def result(self):
+        return self._result
+
+    def __repr__(self):
+        return f"Job(id={self.job_id!r}, backend={self.backend_name!r}, status={self._status!r})"

dyber/server.py

@@ -0,0 +1,85 @@
+"""Dyber reference control server.
+
+A minimal control plane that speaks the job protocol over HTTP and executes jobs on the
+local simulator. This is the stand-in for the real H-cat control system: when the FPGA
+control plane exists, it implements these same endpoints and the SDK does not change.
+
+Run:  python -m dyber.server         (listens on 127.0.0.1:8787)
+Then: dy.backend("remote", url="http://127.0.0.1:8787").run(circuit)
+
+Stdlib only, no external dependencies.
+"""
+from __future__ import annotations
+import json
+import uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from .circuit import Circuit
+from .backend import LocalSimulatorBackend
+from .protocol import make_result_payload
+
+_JOBS = {}            # job_id -> {"status":..., "result": payload}
+_BACKEND = LocalSimulatorBackend()
+
+
+def _execute(req):
+    circ = Circuit.from_dict(req["program"])
+    job = _BACKEND.run(circ, shots=req.get("shots", 1024), **(req.get("options") or {}))
+    return make_result_payload(job.result())
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _send(self, code, obj):
+        body = json.dumps(obj).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        if self.path == "/health":
+            return self._send(200, {"status": "ok", "engine": "local_simulator",
+                                    "note": "reference control plane; simulator backend"})
+        if self.path.startswith("/jobs/"):
+            parts = self.path.strip("/").split("/")
+            jid = parts[1]
+            job = _JOBS.get(jid)
+            if not job:
+                return self._send(404, {"error": "no such job"})
+            if len(parts) == 3 and parts[2] == "result":
+                return self._send(200, {"job_id": jid, "status": job["status"],
+                                        "result": job["result"]})
+            return self._send(200, {"job_id": jid, "status": job["status"]})
+        return self._send(404, {"error": "not found"})
+
+    def do_POST(self):
+        if self.path != "/jobs":
+            return self._send(404, {"error": "not found"})
+        n = int(self.headers.get("Content-Length", 0))
+        req = json.loads(self.rfile.read(n) or b"{}")
+        jid = uuid.uuid4().hex[:12]
+        try:
+            payload = _execute(req)                  # synchronous execution
+            _JOBS[jid] = {"status": "completed", "result": payload}
+            return self._send(200, {"job_id": jid, "status": "completed"})
+        except Exception as e:
+            _JOBS[jid] = {"status": "failed", "result": None}
+            return self._send(200, {"job_id": jid, "status": "failed", "error": str(e)})
+
+    def log_message(self, *a):
+        pass
+
+
+def serve(host="127.0.0.1", port=8787):
+    srv = ThreadingHTTPServer((host, port), Handler)
+    print(f"Dyber control plane (reference) on http://{host}:{port}  [simulator engine]")
+    print("Endpoints: GET /health, POST /jobs, GET /jobs/{id}, GET /jobs/{id}/result")
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        srv.shutdown()
+
+
+if __name__ == "__main__":
+    serve()

dyber/simulator.py

@@ -0,0 +1,123 @@
+"""Dyber SDK: local statevector simulator with optional physics-informed noise.
+
+Exact for small circuits. The noise model is a planning-grade estimate: it takes the
+effective logical error per qubit from the validated H-cat resource model and applies it
+as output bit flips, and reports the heralded-erasure fraction. It is not a full physical
+H-cat simulation (that lives in the research repo); it is enough to interact with circuits
+and see realistic, loss-dependent results.
+"""
+from __future__ import annotations
+import numpy as np
+
+I = np.array([[1, 0], [0, 1]], complex)
+X = np.array([[0, 1], [1, 0]], complex)
+Y = np.array([[0, -1j], [1j, 0]], complex)
+Z = np.array([[1, 0], [0, -1]], complex)
+H = np.array([[1, 1], [1, -1]], complex) / np.sqrt(2)
+S = np.array([[1, 0], [0, 1j]], complex)
+SDG = np.array([[1, 0], [0, -1j]], complex)
+T = np.array([[1, 0], [0, np.exp(1j * np.pi / 4)]], complex)
+TDG = np.array([[1, 0], [0, np.exp(-1j * np.pi / 4)]], complex)
+P0 = np.array([[1, 0], [0, 0]], complex)
+P1 = np.array([[0, 0], [0, 1]], complex)
+_1Q = {"i": I, "x": X, "y": Y, "z": Z, "h": H, "s": S, "sdg": SDG, "t": T, "tdg": TDG}
+
+
+def _rot(g, th):
+    c, s = np.cos(th / 2), np.sin(th / 2)
+    if g == "rx": return np.array([[c, -1j * s], [-1j * s, c]], complex)
+    if g == "ry": return np.array([[c, -s], [s, c]], complex)
+    if g == "rz": return np.array([[np.exp(-1j * th / 2), 0], [0, np.exp(1j * th / 2)]], complex)
+    if g == "p":  return np.array([[1, 0], [0, np.exp(1j * th)]], complex)
+    raise ValueError(g)
+
+
+def _op_on(n, factors):
+    """Full 2^n operator: factors maps qubit index -> 2x2, default identity.
+    Qubit 0 is the most significant tensor factor."""
+    mats = [factors.get(q, I) for q in range(n)]
+    out = mats[0]
+    for m in mats[1:]:
+        out = np.kron(out, m)
+    return out
+
+
+def _gate_matrix(n, op):
+    g, qs = op["gate"], op["qubits"]
+    if g in _1Q:
+        return _op_on(n, {qs[0]: _1Q[g]})
+    if g in ("rx", "ry", "rz", "p"):
+        return _op_on(n, {qs[0]: _rot(g, op["params"][0])})
+    if g == "cx":
+        c, t = qs
+        return _op_on(n, {c: P0}) + _op_on(n, {c: P1, t: X})
+    if g == "cz":
+        c, t = qs
+        return _op_on(n, {c: P0}) + _op_on(n, {c: P1, t: Z})
+    if g == "swap":
+        a, b = qs
+        lo_hi = np.array([[0, 1], [0, 0]], complex)   # |0><1|
+        hi_lo = np.array([[0, 0], [1, 0]], complex)   # |1><0|
+        return (_op_on(n, {a: P0, b: P0}) + _op_on(n, {a: P1, b: P1})
+                + _op_on(n, {a: lo_hi, b: hi_lo}) + _op_on(n, {a: hi_lo, b: lo_hi}))
+    raise ValueError(f"unknown gate {g}")
+
+
+def statevector(circuit):
+    n = circuit.num_qubits
+    if n > 14:
+        raise ValueError("local simulator supports up to 14 qubits")
+    psi = np.zeros(1 << n, complex); psi[0] = 1.0
+    for op in circuit.ops:
+        if op["gate"] == "measure":
+            continue
+        psi = _gate_matrix(n, op) @ psi
+    return psi
+
+
+def _bits(idx, n):
+    return format(idx, "0" + str(n) + "b")
+
+
+def run(circuit, shots=1024, seed=None, loss_per_cycle=None, resources=None):
+    """Return a dict: counts, probabilities, and optional noise summary."""
+    rng = np.random.default_rng(seed)
+    n = circuit.num_qubits
+    psi = statevector(circuit)
+    probs = np.abs(psi) ** 2
+    probs = probs / probs.sum()
+    meas = circuit.measured if circuit.measured else list(range(n))
+
+    # sample full-register outcomes, then project onto measured qubits
+    draws = rng.choice(len(probs), size=shots, p=probs)
+    out_bits = []
+    for idx in draws:
+        full = _bits(int(idx), n)
+        out_bits.append("".join(full[q] for q in meas))
+
+    noise = None
+    if loss_per_cycle is not None and resources is not None:
+        # effective logical error per logical qubit for this operating point
+        p_log = resources.get("logical_error_estimate")
+        p_erase = resources.get("p_erase", 0.0)
+        if p_log:
+            flipped = []
+            for bs in out_bits:
+                b = list(bs)
+                for i in range(len(b)):
+                    if rng.random() < p_log:
+                        b[i] = "1" if b[i] == "0" else "0"
+                flipped.append("".join(b))
+            out_bits = flipped
+        # heralded-erasure shots (flagged, not discarded here)
+        erased = int(sum(1 for _ in range(shots) if rng.random() < p_erase))
+        noise = {"loss_per_cycle": loss_per_cycle,
+                 "logical_error_per_qubit": p_log,
+                 "heralded_erasure_fraction": round(erased / shots, 4)}
+
+    counts = {}
+    for bs in out_bits:
+        counts[bs] = counts.get(bs, 0) + 1
+    return {"counts": counts, "probabilities": {_bits(i, n): float(probs[i])
+            for i in range(len(probs)) if probs[i] > 1e-12},
+            "measured": meas, "noise": noise}

dyber-0.1.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: dyber
+Version: 0.1.0
+Summary: Dyber SDK: interact with the H-cat photonic quantum computer (simulator now, QPU later)
+Author: Dyber, Inc.
+License: Apache-2.0
+Project-URL: Homepage, https://quantaforge.dyber.org
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: physics
+Requires-Dist: dyberforge; extra == "physics"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Dyber SDK
+
+Interact with the H-cat photonic quantum computer. Write a circuit once and run it on the
+local simulator today and on the H-cat QPU later, with no change to your code. This is the
+control interface, designed so that when the hardware exists, only the backend transport
+changes.
+
+## Install
+
+```bash
+pip install numpy
+pip install -e .            # from sdk/
+# optional: physics-grade resource and noise models
+pip install -e ../forge/sdk    # dyberforge
+```
+
+## Hello, H-cat
+
+```python
+from dyber import Dyber, Circuit
+
+dy = Dyber()
+print(dy.backends())                 # local_simulator (online), hcat_qpu (offline)
+
+c = Circuit(2, "bell")
+c.h(0); c.cx(0, 1); c.measure_all()
+
+job = dy.backend("local_simulator").run(c, shots=1000)
+res = job.result()
+print(res.counts())                  # {'00': ~500, '11': ~500}
+print(res.resources)                 # distance, cats per logical, hw modes per logical
+print(res.noise)                     # physics-informed noise summary (if enabled)
+```
+
+## Run it over the network (the real QPU path)
+
+```bash
+python -m dyber.server               # reference control plane on 127.0.0.1:8787
+```
+```python
+backend = dy.backend("remote", url="http://127.0.0.1:8787")
+job = backend.run(c, shots=1000)     # same protocol the hardware will use
+```
+
+The `hcat_qpu` backend points at the production control plane and is offline until the
+hardware exists. The moment it is online, `dy.backend("hcat_qpu").run(c)` runs on silicon.
+
+## How it is layered
+
+| Layer | Module | Role |
+|---|---|---|
+| Circuit | `circuit.py` | gate-model program you write |
+| Lowering | `native.py` | maps gates to native H-cat ops (cat prep, hybrid fusion, parity readout); the real lowering is OpenForge |
+| Simulator | `simulator.py` | exact statevector run, plus physics-informed noise from the resource model |
+| Backends | `backend.py` | local simulator, remote (HTTP), and the hcat_qpu hardware backend, one interface |
+| Protocol | `protocol.py` | the JSON job format shared by SDK and control plane |
+| Control plane | `server.py` | reference server: today runs the simulator, later fronts the FPGA control system |
+
+## Notes
+
+- The simulator is exact for up to 14 qubits. Noise is a planning-grade estimate calibrated
+  to the validated H-cat loss and resource models, not a full physical simulation.
+- Resource estimates use the v2 calibration (June 2026 circuit-level validation campaign):
+  corrected loss threshold 0.79 percent per cycle (0.898 percent uncorrected option), spec
+  operating point 0.5 percent per cycle (d=53, 5,617 cats per logical at 1e-9, 239.5
+  attempts per cat). At or above the threshold the resource report honestly returns the
+  above-threshold regime (no fault-tolerant distance) with a NISQ fallback estimate.
+- Proprietary components (the OpenForge compiler passes, calibration, foundry recipes) are
+  not part of this SDK. The native lowering here is illustrative.
+- Style: no em-dashes; commas, colons, periods, and hyphens for ranges.

dyber-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+dyber/__init__.py,sha256=epCu1Yo1jSsOroAAf4Fr4d2a7rfUE3bI400zp-qrRmM,629
+dyber/backend.py,sha256=eD0BcAjI0ODxS0ZUHwxqRW4YubXpRGZTgtCaNIc3608,4434
+dyber/circuit.py,sha256=9cjlZdzKL2fp2W52aV_BVvN_w6HxiRea6sEyfzlpigs,3388
+dyber/native.py,sha256=cZqmvVh0V51L3LfOdn9ZnPOFDP5GaByW_CTIvgeplU8,8823
+dyber/protocol.py,sha256=zT4k9Q5Zk-bVGBUWOkj8RyC760GTzlb1JxCH3k01Cfc,1349
+dyber/provider.py,sha256=crBdcyvoz6ZCxKzidsVMjBLZROLkAxLVQ3RjJ94uJXc,1129
+dyber/result.py,sha256=3Y2TNdxRf6BrjPz1zrp5ppprBJXx2ec7JC1t-mTRLKE,1386
+dyber/server.py,sha256=PIPvM1yWVzgZqr6UnuCpW9AOdpbo9TFkaUjoDH0t9pw,3279
+dyber/simulator.py,sha256=tTCTqCfdWt9n-ESn6-bVMin67Fxwn-oI4DWaWGpZVeQ,4790
+dyber-0.1.0.dist-info/licenses/LICENSE,sha256=f7DuGEDcRwcVk0yt1RxHL5gFqq5gfHOCjguwsCziuIo,11342
+dyber-0.1.0.dist-info/METADATA,sha256=rdHSaSW9YxCKD5uPbRTr7I6yUBi1TdxQvo3BA7KKcBo,3706
+dyber-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dyber-0.1.0.dist-info/entry_points.txt,sha256=QarjZzUofwsXsf9Wuf7bqp2gdJyp5gnjP8bCLcxgtHo,52
+dyber-0.1.0.dist-info/top_level.txt,sha256=CEL5mIGG25z72ZAYkg7G49zIp9AbSlDFPrJ6ToG6zRc,6
+dyber-0.1.0.dist-info/RECORD,,

dyber-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dyber-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dyber-server = dyber.server:serve

dyber-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Dyber, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dyber-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dyber