dyberforge 0.1.0__py3-none-any.whl

dyberforge/__init__.py

@@ -0,0 +1,34 @@
+"""
+dyberforge: the open H-cat simulation SDK (Workbench).
+
+One import surface over the validated, public H-cat simulation physics:
+cat-state generation, the cat loss budget with parity stabilization, and the
+end-to-end physical-to-logical resource model.
+
+    import dyberforge as df
+    df.generate_cat(s_db=6.0, k=1, N=40)            # cat fidelity, parity, state
+    df.loss_curves(2.0, [10**-0.32])                # loss budget, parity stabilization
+    df.estimate(gamma=0.005, target_logical_err=1e-9)   # target -> device spec
+
+Public, non-proprietary science only. The proprietary compiler passes, the
+calibration internals, the architecture loss-chain ledger, and the foundry
+recipes are NOT part of this package. The physics modules are vendored into the
+package so it is fully self-contained (no path injection into a research repo).
+"""
+from .cat_generation import (  # noqa: F401
+    generate_cat, ideal_cat, squeezed_vacuum, subtract_ideal,
+    apply_loss, parity, mean_n, purity, best_squeezed_cat_fidelity,
+)
+from .cat_loss_budget import loss_curves  # noqa: F401
+from .resource_model import (  # noqa: F401
+    estimate, attempts_per_cat, code_distance, cats_per_logical, loss_to_errors,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "generate_cat", "ideal_cat", "squeezed_vacuum", "subtract_ideal", "apply_loss",
+    "parity", "mean_n", "purity", "best_squeezed_cat_fidelity", "loss_curves",
+    "estimate", "attempts_per_cat", "code_distance", "cats_per_logical", "loss_to_errors",
+    "__version__",
+]

dyberforge/cat_generation.py

@@ -0,0 +1,335 @@
+"""
+H-cat cat-state generation from squeezed vacuum by photon subtraction.
+
+Vendored into dyberforge so the package is self-contained (no path injection
+into the research repo). Pure published physics, all in a truncated Fock space
+with QuTiP:
+
+  squeezed vacuum  ->  photon subtraction (herald)  ->  approximate Schroedinger cat
+       S(r)|0>              a^k |psi>  (ideal)              compare to ideal |cat(alpha)>
+                       or  beamsplitter tap + PNR (realistic)
+
+Key quantities returned for each generated state:
+  - fidelity to the best-matched ideal cat (amplitude alpha optimized)
+  - purity  Tr(rho^2)
+  - mean photon number <n>
+  - parity  <(-1)^n>     (the H-cat readout signature / loss syndrome)
+
+Squeezing convention
+--------------------
+Squeezing in dB of the squeezed quadrature variance relative to vacuum:
+    S_dB = -10 log10(V),   V = e^{-2r}   =>   r = S_dB * ln(10) / 20
+So 3.5 dB -> r=0.403, 6 dB -> r=0.691, 8 dB -> r=0.921, 10 dB -> r=1.151.
+
+References
+----------
+Lee, Park & Jeong, PRX Quantum 5, 030322 (2024)  (H-cat architecture)
+Ourjoumtsev et al., Science 312, 83 (2006)        (photon subtraction -> kitten)
+"""
+from __future__ import annotations
+
+from functools import lru_cache
+
+import numpy as np
+import qutip as qt
+
+
+# ---------------------------------------------------------------------------
+# cached primitives
+# ---------------------------------------------------------------------------
+# qt.squeeze / qt.coherent build a matrix exponential / displacement each call.
+# In the (alpha, s) fidelity scans these get hit ~10^5 times for a handful of
+# distinct values, so cache on quantized keys (1e-3 resolution is plenty).
+@lru_cache(maxsize=None)
+def _squeeze_op(N: int, r_milli: int) -> qt.Qobj:
+    return qt.squeeze(N, r_milli / 1000.0)
+
+
+@lru_cache(maxsize=None)
+def _coherent(N: int, a_milli: int) -> qt.Qobj:
+    return qt.coherent(N, a_milli / 1000.0)
+
+
+def squeeze_op(N: int, r: float) -> qt.Qobj:
+    return _squeeze_op(N, int(round(r * 1000)))
+
+
+def coherent_state(N: int, alpha: float) -> qt.Qobj:
+    return _coherent(N, int(round(alpha * 1000)))
+
+
+@lru_cache(maxsize=None)
+def _destroy(N: int) -> qt.Qobj:
+    return qt.destroy(N)
+
+
+@lru_cache(maxsize=None)
+def _num(N: int) -> qt.Qobj:
+    return qt.num(N)
+
+
+# ---------------------------------------------------------------------------
+# conversions
+# ---------------------------------------------------------------------------
+def db_to_r(s_db: float) -> float:
+    """Squeezing in dB -> squeezing parameter r (real)."""
+    return s_db * np.log(10.0) / 20.0
+
+
+def r_to_db(r: float) -> float:
+    return 20.0 * r / np.log(10.0)
+
+
+# ---------------------------------------------------------------------------
+# ideal reference states
+# ---------------------------------------------------------------------------
+@lru_cache(maxsize=None)
+def _ideal_cat(N: int, a_milli: int, parity: str) -> qt.Qobj:
+    alpha = a_milli / 1000.0
+    plus = coherent_state(N, alpha)
+    minus = coherent_state(N, -alpha)
+    if parity == "even":
+        psi = plus + minus
+    elif parity == "odd":
+        psi = plus - minus
+    else:
+        raise ValueError("parity must be 'even' or 'odd'")
+    return psi.unit()
+
+
+def ideal_cat(N: int, alpha: float, parity: str = "odd") -> qt.Qobj:
+    """Normalized even/odd Schroedinger cat |alpha> +/- |-alpha>."""
+    return _ideal_cat(N, int(round(alpha * 1000)), parity)
+
+
+def squeezed_vacuum(N: int, s_db: float) -> qt.Qobj:
+    """Single-mode squeezed vacuum S(r)|0> for a given squeezing in dB."""
+    r = db_to_r(s_db)
+    return squeeze_op(N, r) * qt.basis(N, 0)
+
+
+def ideal_squeezed_cat(N: int, alpha: float, s: float, parity: str = "odd") -> qt.Qobj:
+    """
+    Squeezed cat  S(s)(|alpha> +/- |-alpha>).  This is the natural output of
+    photon subtraction from squeezed vacuum (Ourjoumtsev 2006), so it is the
+    correct high-fidelity reference manifold for a heralded kitten. s is a real
+    squeezing parameter (can be negative).
+    """
+    cat = ideal_cat(N, alpha, parity)
+    return (squeeze_op(N, s) * cat).unit()
+
+
+# ---------------------------------------------------------------------------
+# photon subtraction
+# ---------------------------------------------------------------------------
+def subtract_ideal(state: qt.Qobj, k: int = 1) -> qt.Qobj:
+    """
+    Ideal k-photon subtraction: apply a^k and renormalize.
+    Subtracting an odd number of photons from squeezed vacuum yields an
+    approximate odd cat; an even number yields an approximate even cat.
+    """
+    N = state.shape[0]
+    a = _destroy(N)
+    out = a ** k * state
+    return out.unit()
+
+
+def subtract_beamsplitter(state: qt.Qobj, k: int = 1, tap_db: float = 13.0,
+                          eta_det: float = 1.0) -> qt.Qobj:
+    """
+    Realistic heralded subtraction: send the signal through a weakly-reflecting
+    beamsplitter (tap), detect exactly k photons in the tap arm with a PNR
+    detector of efficiency eta_det, and keep the conditional signal state.
+
+    tap_db : tap arm reflectivity expressed as -10 log10(R)  (e.g. 13 dB -> R~0.05).
+    Returns the (mixed) conditional density matrix of the signal mode.
+    """
+    N = state.shape[0]
+    R = 10 ** (-tap_db / 10.0)          # tap reflectivity (small)
+    theta = np.arcsin(np.sqrt(R))       # beamsplitter mixing angle
+    Ntap = max(k + 4, 8)
+
+    a = qt.tensor(qt.destroy(N), qt.qeye(Ntap))
+    b = qt.tensor(qt.qeye(N), qt.destroy(Ntap))
+    BS = (theta * (a.dag() * b - a * b.dag())).expm()
+
+    sig = state if state.isket else state
+    full = qt.tensor(sig, qt.basis(Ntap, 0))
+    if full.isket:
+        full = full * full.dag()
+    rho = BS * full * BS.dag()
+
+    # PNR projector onto exactly k photons in the tap arm (with detector loss)
+    if eta_det >= 1.0:
+        proj = qt.tensor(qt.qeye(N), qt.basis(Ntap, k) * qt.basis(Ntap, k).dag())
+        cond = (proj * rho * proj).ptrace(0)
+    else:
+        # detector efficiency: photons arriving m >= k, click registers k
+        cond = 0
+        for m in range(k, Ntap):
+            pm = qt.basis(Ntap, m) * qt.basis(Ntap, m).dag()
+            weight = _binom(m, k) * eta_det ** k * (1 - eta_det) ** (m - k)
+            blk = qt.tensor(qt.qeye(N), pm) * rho * qt.tensor(qt.qeye(N), pm)
+            cond = cond + weight * blk.ptrace(0)
+    return cond.unit()
+
+
+def _binom(n: int, k: int) -> float:
+    from math import comb
+    return float(comb(n, k))
+
+
+# ---------------------------------------------------------------------------
+# loss channel (pure-loss / vacuum) on a single mode
+# ---------------------------------------------------------------------------
+def apply_loss(rho: qt.Qobj, eta: float, kmax: int | None = None) -> qt.Qobj:
+    """
+    Pure-loss bosonic channel with transmissivity eta (eta=1 -> lossless).
+    Kraus operators E_l = sqrt((1-eta)^l / l!) * eta^{n/2} a^l. This is the
+    standard trace-preserving (sum_l E_l.dag E_l = I) pure-loss / amplitude-damping
+    form and is exactly the t-integral of the Lindblad dissipator kappa D[a] with
+    eta = exp(-kappa t); the operator order eta^{n/2} a^l (number-weight applied
+    after the lowering) is what makes the coefficient (1-eta)^l correct.
+    """
+    if rho.isket:
+        rho = rho * rho.dag()
+    N = rho.shape[0]
+    if eta >= 1.0:
+        return rho
+    a = _destroy(N)
+    n = _num(N)
+    eta_half_n = (0.5 * np.log(eta) * n).expm()      # eta^{n/2}
+    if kmax is None:
+        kmax = N - 1
+    from math import factorial
+    out = 0
+    one_m_eta = 1.0 - eta
+    for l in range(kmax + 1):
+        coeff = np.sqrt(one_m_eta ** l / factorial(l))
+        E = coeff * eta_half_n * (a ** l)
+        out = out + E * rho * E.dag()
+    # trace is preserved exactly by the Kraus set; renormalize only to absorb the
+    # tiny Fock-truncation defect from cutting the l-sum / a^l at the boundary.
+    return out.unit()
+
+
+# ---------------------------------------------------------------------------
+# observables
+# ---------------------------------------------------------------------------
+def parity(state: qt.Qobj) -> float:
+    """<(-1)^n>  (Wigner value at the origin, up to a factor)."""
+    N = state.shape[0]
+    P = (1j * np.pi * qt.num(N)).expm()
+    return float(np.real(qt.expect(P, state)))
+
+
+def mean_n(state: qt.Qobj) -> float:
+    N = state.shape[0]
+    return float(np.real(qt.expect(_num(N), state)))
+
+
+def purity(state: qt.Qobj) -> float:
+    rho = state * state.dag() if state.isket else state
+    return float(np.real((rho * rho).tr()))
+
+
+def best_cat_fidelity(state: qt.Qobj, parity_hint: str = "odd",
+                      alpha_grid: np.ndarray | None = None) -> tuple[float, float]:
+    """
+    Fidelity to the best-matched bare ideal cat, optimizing over amplitude.
+    Returns (max_fidelity, best_alpha).  For a pure target |c>, <c|rho|c> is the
+    (squared) state fidelity.
+    """
+    N = state.shape[0]
+    if alpha_grid is None:
+        alpha_grid = np.linspace(0.3, 2.8, 60)
+    rho = state if state.isoper else state * state.dag()
+    best_f, best_a = 0.0, 0.0
+    for a in alpha_grid:
+        tgt = ideal_cat(N, a, parity_hint)
+        f = float(np.real(qt.expect(rho, tgt)))
+        if f > best_f:
+            best_f, best_a = f, a
+    return best_f, best_a
+
+
+def best_squeezed_cat_fidelity(state: qt.Qobj, parity_hint: str = "odd",
+                               alpha_min: float = 0.3,
+                               alpha_max: float = 2.8,
+                               n_alpha: int = 40,
+                               s_grid: np.ndarray | None = None
+                               ) -> tuple[float, float, float]:
+    """
+    Fidelity to the best-matched squeezed cat, optimizing over (alpha, s) with
+    alpha constrained to [alpha_min, alpha_max]. This is the physically correct
+    reference for photon-subtracted squeezed vacuum.
+
+    Set alpha_min ~ 1.0 to demand a usable cat: a cat with |alpha| < ~1 has
+    strongly overlapping lobes (|<alpha|-alpha>|^2 = exp(-4 alpha^2)) and is not
+    a good logical qubit, so an unconstrained fit (alpha -> 0) over-reports
+    quality. Returns (max_fidelity, best_alpha, best_s).
+    """
+    N = state.shape[0]
+    alpha_grid = np.linspace(alpha_min, alpha_max, n_alpha)
+    if s_grid is None:
+        s_grid = np.linspace(-1.4, 1.4, 43)
+    rho = state if state.isoper else state * state.dag()
+    best = (0.0, alpha_min, 0.0)
+    for a in alpha_grid:
+        for s in s_grid:
+            tgt = ideal_squeezed_cat(N, a, s, parity_hint)
+            f = float(np.real(qt.expect(rho, tgt)))
+            if f > best[0]:
+                best = (f, a, s)
+    return best
+
+
+# ---------------------------------------------------------------------------
+# one-shot generator + characterization
+# ---------------------------------------------------------------------------
+def generate_cat(s_db: float, k: int = 1, N: int = 40, method: str = "ideal",
+                 eta_loss: float = 1.0, **kw) -> dict:
+    """
+    Generate an approximate cat at a given squeezing level and characterize it.
+
+    method: 'ideal'        -> apply a^k
+            'beamsplitter' -> tap + PNR heralding (pass tap_db, eta_det)
+    eta_loss: optional downstream transmissivity applied AFTER generation.
+    """
+    sv = squeezed_vacuum(N, s_db)
+    if method == "ideal":
+        state = subtract_ideal(sv, k)
+    elif method == "beamsplitter":
+        state = subtract_beamsplitter(sv, k, **kw)
+    else:
+        raise ValueError("method must be 'ideal' or 'beamsplitter'")
+
+    if eta_loss < 1.0:
+        state = apply_loss(state, eta_loss)
+
+    parity_hint = "odd" if (k % 2 == 1) else "even"
+    fid_bare, alpha_bare = best_cat_fidelity(state, parity_hint)
+    fid_uncon, a_uncon, s_uncon = best_squeezed_cat_fidelity(
+        state, parity_hint, alpha_min=0.3)
+    fid_use, a_use, s_use = best_squeezed_cat_fidelity(
+        state, parity_hint, alpha_min=1.0)   # demand a usable (well-separated) cat
+    return {
+        "s_db": s_db,
+        "k": k,
+        "method": method,
+        "eta_loss": eta_loss,
+        # primary engineering metric: fidelity to a usable squeezed cat (|a|>=1)
+        "fidelity": fid_use,
+        "alpha": a_use,
+        "out_squeeze": s_use,
+        # intrinsic (unconstrained) squeezed-cat fidelity
+        "fidelity_uncon": fid_uncon,
+        "alpha_uncon": a_uncon,
+        # bare-cat fidelity (no output squeezing allowed)
+        "fidelity_bare": fid_bare,
+        "alpha_bare": alpha_bare,
+        "purity": purity(state),
+        "mean_n": mean_n(state),
+        "parity": parity(state),
+        "state": state,
+    }

dyberforge/cat_loss_budget.py

@@ -0,0 +1,104 @@
+"""
+Cat loss budget and parity stabilization: "how long does a cat last, and how do
+we make it last longer?"
+
+Vendored into dyberforge so the package is self-contained. This module ships the
+public physics only: the parity-stabilized loss-curve calculation. The
+architecture-specific component loss chain, the plotting, and the file output of
+the research script are deliberately not included here.
+
+For a flying photonic cat, "lifetime" = loss budget. Photon loss (transmissivity
+eta) does TWO physically distinct things to a cat |C(alpha)>:
+
+  (1) PARITY FLIP per lost photon, detectable by a parity measurement and
+      correctable by a classical feedforward (Pauli-frame) update.
+  (2) AMPLITUDE DECAY  alpha -> sqrt(eta)*alpha, the no-jump shrinkage; NOT
+      visible to parity and NOT correctable without re-amplification (breeding).
+
+Key consequence:
+
+  * WITHOUT correction, loss looks like dephasing whose rate ~ |alpha|^2, so
+    bigger cats die faster.
+  * WITH parity stabilization, the dephasing channel is removed; the cat stays a
+    perfect (smaller) cat and the only limit is amplitude decay below the usable
+    threshold alpha_min. The survivable loss budget is then
+
+        budget(dB) = 20 * log10(alpha0 / alpha_min)
+
+    which GROWS with alpha0: parity stabilization inverts the size/lifetime
+    tradeoff.
+"""
+from __future__ import annotations
+
+import numpy as np
+import qutip as qt
+
+from . import cat_generation as cg
+
+N = 50
+ALPHA_MIN = 1.0          # usable-cat threshold (well-separated lobes)
+
+
+def parity_projectors(n):
+    P = (1j * np.pi * cg._num(n)).expm()
+    Peven = (qt.qeye(n) + P) / 2
+    Podd = (qt.qeye(n) - P) / 2
+    return Peven, Podd
+
+
+def loss_curves(alpha0, etas, eta_det=1.0):
+    """
+    For each transmissivity eta, return logical fidelities of an even-cat |+_L>:
+      F_unc        : fidelity to the original even cat, no correction (dephasing)
+      F_cor_fixed  : parity-frame corrected, compared to original-amplitude cat
+                     (residual error = amplitude mismatch only)
+      F_cor_shrunk : parity-frame corrected, compared to the decayed-amplitude cat
+                     (coherence preserved -> ~1; this is the stabilized lifetime)
+    eta_det < 1 models an imperfect parity measurement (mis-assigns the sector with
+    probability (1-eta_det)/2), which re-introduces some dephasing into the
+    corrected curves.
+    """
+    Peven, Podd = parity_projectors(N)
+    cat0 = cg.ideal_cat(N, alpha0, "even")
+    rows = []
+    for eta in etas:
+        rho = cg.apply_loss(cat0, float(eta))
+        a_dec = np.sqrt(eta) * alpha0
+
+        even0 = cg.ideal_cat(N, alpha0, "even")
+        odd0 = cg.ideal_cat(N, alpha0, "odd")
+        evend = cg.ideal_cat(N, a_dec, "even")
+        oddd = cg.ideal_cat(N, a_dec, "odd")
+
+        F_unc = float(np.real(qt.expect(rho, even0)))
+
+        pe = float(np.real((Peven * rho).tr()))
+        po = float(np.real((Podd * rho).tr()))
+        rho_e = (Peven * rho * Peven) / max(pe, 1e-12)
+        rho_o = (Podd * rho * Podd) / max(po, 1e-12)
+
+        # perfect parity assignment
+        Fcf = pe * float(np.real(qt.expect(rho_e, even0))) + \
+              po * float(np.real(qt.expect(rho_o, odd0)))
+        Fcs = pe * float(np.real(qt.expect(rho_e, evend))) + \
+              po * float(np.real(qt.expect(rho_o, oddd)))
+
+        # imperfect parity measurement: probability em of mis-assigning sector
+        if eta_det < 1.0:
+            em = (1.0 - eta_det) / 2.0
+            Fcf = (1 - em) * Fcf + em * (
+                pe * float(np.real(qt.expect(rho_e, odd0))) +
+                po * float(np.real(qt.expect(rho_o, even0))))
+            Fcs = (1 - em) * Fcs + em * (
+                pe * float(np.real(qt.expect(rho_e, oddd))) +
+                po * float(np.real(qt.expect(rho_o, evend))))
+
+        rows.append({"eta": float(eta), "loss_db": float(-10 * np.log10(eta)),
+                     "alpha0": alpha0, "alpha_decayed": float(a_dec),
+                     "F_unc": F_unc, "F_cor_fixed": Fcf, "F_cor_shrunk": Fcs})
+    return rows
+
+
+def budget_db(alpha0, alpha_min=ALPHA_MIN):
+    """Parity-stabilized amplitude-decay loss budget, 20 log10(alpha0/alpha_min)."""
+    return 20 * np.log10(alpha0 / alpha_min)

dyberforge/resource_model.py

@@ -0,0 +1,259 @@
+"""
+H-cat integrated end-to-end resource model (v2 calibrated, v1 preserved).
+
+Vendored into dyberforge so the package is self-contained. This module ships the
+public physics-to-logical estimate: the loss split, the outer-code distance, the
+cats-per-logical count, and the production-throughput estimate. The internal
+roadmap tables, the architecture loss-chain ledger, the plotting, and the file
+output of the research script are deliberately not included here.
+
+Chains the validated sub-results into one physical-to-logical estimate:
+
+  squeezing -> kitten -> breeding (multiplexing) -> usable cat
+            -> photon loss -> heralded erasure + quadratic Pauli residue
+            -> outer surface code (distance d) -> logical qubit
+
+Two model versions
+------------------
+model="v1"  pure exact-Kraus loss split on the ideal cat, phenomenological
+            sub-threshold scaling with p_th = 0.68 percent.
+model="v2"  (default) recalibrated loss split (digital-twin correction factors)
+            and circuit-level code distance, threshold p_th_circ = 0.79 percent
+            (corrected; 0.898 percent uncorrected option),
+            Lambda(gamma) = (p_th_circ/gamma)^1.61, LER(d) = A_CIRC*Lambda^(-(d+1)/2).
+"""
+from __future__ import annotations
+
+from math import factorial, ceil, log
+import numpy as np
+
+from . import cat_generation as cg
+
+MODEL_DEFAULT = "v2"
+
+# ---- validated constants ----
+P_GEN = 0.30           # heralded subtraction success
+P_BREED = 0.24         # breeding herald success (realistic)
+P_TH = 0.0068          # v1 phenomenological surface threshold
+ERASURE_TH = 0.5       # surface-code erasure threshold (literature/standard)
+C_SUB = 0.1            # v1 sub-threshold prefactor (standard QEC scaling)
+ALPHA0 = 1.0           # kitten amplitude
+ALPHA_TARGET = 2.0     # usable computational cat
+ALPHA_MIN = 1.0        # parity-stabilized amplitude floor
+
+# ---- v2 calibration constants ----
+# Circuit-level calibration:
+P_TH_CIRC = 0.0079             # corrected threshold (3x p_pauli folded in); default
+P_TH_CIRC_UNCORRECTED = 0.00898  # uncorrected circuit-level threshold
+LAMBDA_EXP = 1.61              # Lambda(gamma) = (p_th/gamma)^1.61 (margin ladder fit)
+A_CIRC = 0.30                  # LER(d) = A_CIRC * Lambda^(-(d+1)/2)
+
+# Mux/feedforward herald-collision tax (16-candidate architecture):
+MUX_ATTEMPT_FACTOR = 239.0 / 231.0
+
+# v2 operating points
+GAMMA_SPEC = 0.005           # per-cycle loss spec
+GAMMA_STRETCH = 0.004        # stretch case
+
+# ---- digital-twin loss-split correction factors ----
+# exact channel measured on the bred-cat density matrix vs the Poisson closed form
+_SPLIT_GAMMA_GRID = np.array([0.005, 0.010, 0.020, 0.030])
+_SPLIT_F_ERASE = np.array([0.9583507007766099, 0.9205203546179248,
+                           0.854608265667542, 0.7994035470416974])
+_SPLIT_F_PAULI = np.array([3.0846032998386854, 2.919170374042666,
+                           2.629331412714363, 2.384856621831815])
+
+
+def split_correction(gamma):
+    """
+    Digital-twin correction factors (f_erase, f_pauli) for the Poisson loss
+    split, linearly interpolated on the measured grid gamma in [0.5, 3] percent.
+    Outside the grid the interpolation is CLIPPED (constant extrapolation at the
+    nearest measured point).
+    """
+    g = float(np.clip(gamma, _SPLIT_GAMMA_GRID[0], _SPLIT_GAMMA_GRID[-1]))
+    f_e = float(np.interp(g, _SPLIT_GAMMA_GRID, _SPLIT_F_ERASE))
+    f_p = float(np.interp(g, _SPLIT_GAMMA_GRID, _SPLIT_F_PAULI))
+    return f_e, f_p
+
+
+# ---------------------------------------------------------------------------
+# Stage A -- cat production throughput
+# ---------------------------------------------------------------------------
+def breeding_rounds(alpha0=ALPHA0, alpha_target=ALPHA_TARGET):
+    """alpha *= sqrt(2) per round -> rounds to reach target."""
+    return max(0, ceil(2 * np.log2(alpha_target / alpha0)))
+
+
+def attempts_per_cat(p_gen=P_GEN, p_breed=P_BREED, alpha0=ALPHA0, alpha_target=ALPHA_TARGET):
+    """Expected raw subtraction attempts to deliver one usable cat (ideal
+    routing; estimate() applies the MUX_ATTEMPT_FACTOR collision tax on top)."""
+    R = breeding_rounds(alpha0, alpha_target)
+    kittens = (2.0 / p_breed) ** R          # binary breeding tree w/ herald losses
+    return kittens / p_gen, R
+
+
+# ---------------------------------------------------------------------------
+# Stage B -- loss -> erasure + Pauli, and outer-code distance
+# ---------------------------------------------------------------------------
+def _loss_distribution(alpha, gamma, N=50):
+    cat = cg.ideal_cat(N, alpha, "even")
+    rho = cat * cat.dag()
+    eta = 1.0 - gamma
+    a = cg._destroy(N)
+    eta_half_n = (0.5 * np.log(eta) * cg._num(N)).expm()
+    P = []
+    for l in range(N):
+        E = np.sqrt((1.0 - eta) ** l / factorial(l)) * eta_half_n * (a ** l)
+        P.append(float(np.real((E * rho * E.dag()).tr())))
+    return np.array(P)
+
+
+def poisson_loss_split(gamma, alpha=ALPHA_TARGET):
+    """Closed-form Poisson loss split at lambda = alpha^2 gamma:
+    p_erase = (1 - exp(-2 lam))/2, p_pauli = (1 + exp(-2 lam))/2 - exp(-lam)."""
+    lam = alpha * alpha * gamma
+    p_e = 0.5 * (1.0 - np.exp(-2.0 * lam))
+    p_z = 0.5 * (1.0 + np.exp(-2.0 * lam)) - np.exp(-lam)
+    return float(p_e), float(p_z)
+
+
+def loss_to_errors(gamma, alpha=ALPHA_TARGET, model=MODEL_DEFAULT):
+    """
+    Per-cycle physical loss -> (erasure rate, unheralded Pauli rate).
+
+    v1: exact Kraus loss distribution on the IDEAL cat (odd losses -> heralded
+        erasure, even >= 2 -> silent Pauli).
+    v2: Poisson closed form x digital-twin correction factors (split_correction).
+    """
+    if model == "v1":
+        P = _loss_distribution(alpha, gamma)
+        p_e = P[1::2].sum()      # odd losses -> heralded erasure
+        p_z = P[2::2].sum()      # even(>=2) losses -> unheralded Pauli
+        return p_e, p_z
+    p_e0, p_z0 = poisson_loss_split(gamma, alpha)
+    f_e, f_p = split_correction(gamma)
+    return p_e0 * f_e, p_z0 * f_p
+
+
+def code_distance(p_z, target_logical_err, p_th=P_TH, c=C_SUB):
+    """v1: smallest odd distance d with C (p_z/p_th)^((d+1)/2) <= target."""
+    if p_z >= p_th:
+        return None          # above threshold: no distance helps
+    ratio = p_z / p_th
+    m = log(target_logical_err / c) / log(ratio)     # = (d+1)/2
+    d = int(2 * ceil(m) - 1)
+    return max(d, 3)
+
+
+def lambda_circ(gamma, corrected=True):
+    """Circuit-level error-suppression factor per distance step,
+    Lambda(gamma) = (p_th_circ/gamma)^1.61."""
+    p_th = P_TH_CIRC if corrected else P_TH_CIRC_UNCORRECTED
+    return (p_th / gamma) ** LAMBDA_EXP
+
+
+def code_distance_v2(gamma, target_logical_err, corrected=True):
+    """
+    v2: smallest odd distance d with A_CIRC * Lambda^(-(d+1)/2) <= target,
+    Lambda = (p_th_circ/gamma)^1.61. corrected=True (default) folds in the
+    digital-twin 3x p_pauli correction via the 0.79 percent threshold. Returns
+    None at or above threshold (Lambda <= 1: increasing d makes the logical
+    error worse).
+    """
+    lam = lambda_circ(gamma, corrected)
+    if lam <= 1.0:
+        return None
+    m = ceil(log(A_CIRC / target_logical_err) / log(lam))   # = (d+1)/2
+    d = int(2 * m - 1)
+    return max(d, 3)
+
+
+def cats_per_logical(d):
+    """Rotated surface code: d^2 data + (d^2 - 1) ancilla."""
+    return 2 * d * d - 1
+
+
+# ---------------------------------------------------------------------------
+# Stage C -- hardware split
+# ---------------------------------------------------------------------------
+def hardware_modes_per_logical(attempts, cats_per_log, spatial, wavelength):
+    """
+    Total attempt-throughput is spread over spatial x wavelength x temporal
+    multiplexing. hardware sources per cat = spatial; temporal bins absorb the
+    rest: T = ceil(D / (spatial*wavelength)).
+    hardware modes per logical = spatial * cats_per_logical.
+    """
+    T = max(1, ceil(attempts / (spatial * wavelength)))
+    hw_modes = spatial * cats_per_log
+    return hw_modes, T
+
+
+# ---------------------------------------------------------------------------
+# end-to-end
+# ---------------------------------------------------------------------------
+QLDPC_GAIN = 10.0      # quantum-LDPC overhead reduction vs surface code
+                       # (Panteleev-Kalachev 2022 / Bravyi 2024)
+
+
+def estimate(gamma, target_logical_err, p_gen=P_GEN, p_breed=P_BREED,
+             alpha_target=ALPHA_TARGET, spatial=8, wavelength=32,
+             use_outer_code=True, verbose=False, model=MODEL_DEFAULT,
+             corrected_threshold=True):
+    """
+    End-to-end physical-to-logical estimate at one operating point.
+
+    model="v2" (default) applies the calibrated digital-twin loss split, the
+    circuit-level code distance (corrected_threshold selects 0.79 vs 0.898
+    percent), and the mux herald-collision attempts tax. model="v1" reproduces
+    the historical phenomenological model.
+    """
+    att_ideal, R = attempts_per_cat(p_gen, p_breed, ALPHA0, alpha_target)
+    if model == "v1":
+        att = att_ideal
+        p_e, p_z = loss_to_errors(gamma, alpha_target, model="v1")
+    else:
+        att = att_ideal * MUX_ATTEMPT_FACTOR
+        p_e, p_z = loss_to_errors(gamma, alpha_target, model="v2")
+
+    # NISQ regime: H-cat loss detection only, no outer code (target ~>= 1e-2)
+    if not use_outer_code:
+        cpl = 1
+        hw, T = hardware_modes_per_logical(att, cpl, spatial, wavelength)
+        return {"gamma": gamma, "target_err": target_logical_err, "rounds": R,
+                "attempts_per_cat": att, "p_erase": p_e, "p_pauli": p_z,
+                "distance": 1, "cats_per_logical": cpl,
+                "throughput_per_logical": att * cpl, "hw_modes_per_logical": hw,
+                "time_bins": T, "erasure_ok": p_e < ERASURE_TH, "model": model}
+
+    if model == "v1":
+        d = code_distance(p_z, target_logical_err)
+    else:
+        d = code_distance_v2(gamma, target_logical_err, corrected_threshold)
+    res = {"gamma": gamma, "target_err": target_logical_err,
+           "rounds": R, "attempts_per_cat": att,
+           "p_erase": p_e, "p_pauli": p_z, "distance": d, "model": model}
+    if d is None:
+        res.update({"cats_per_logical": None, "throughput_per_logical": None,
+                    "hw_modes_per_logical": None, "time_bins": None,
+                    "erasure_ok": p_e < ERASURE_TH})
+        return res
+    cpl = cats_per_logical(d)
+    hw, T = hardware_modes_per_logical(att, cpl, spatial, wavelength)
+    res.update({"cats_per_logical": cpl,
+                "throughput_per_logical": att * cpl,
+                "hw_modes_per_logical": hw, "time_bins": T,
+                "erasure_ok": p_e < ERASURE_TH})
+    if verbose:
+        thr = (P_TH if model == "v1" else
+               (P_TH_CIRC if corrected_threshold else P_TH_CIRC_UNCORRECTED))
+        print(f"  [{model}] gamma={gamma*100:.2f}%/cycle, "
+              f"target eL={target_logical_err:.0e}")
+        print(f"    breeding rounds R={R}, attempts/cat={att:.0f}")
+        print(f"    loss -> erasure p_e={p_e:.3e} (<{ERASURE_TH}: {res['erasure_ok']}),"
+              f" Pauli p_z={p_z:.3e} (threshold ref {thr})")
+        print(f"    code distance d={d}, cats/logical={cpl}")
+        print(f"    throughput/logical={att*cpl:.3e} attempts; "
+              f"hw modes/logical={hw} (spatial {spatial} x wl {wavelength}, "
+              f"{T} time bins)")
+    return res

dyberforge-0.1.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: dyberforge
+Version: 0.1.0
+Summary: Open H-cat photonic quantum computing simulation SDK (Dyber Forge Workbench)
+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.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: qutip>=5
+Requires-Dist: matplotlib
+Requires-Dist: stim>=1.13
+Requires-Dist: pymatching>=2
+Provides-Extra: devices
+Requires-Dist: meep; extra == "devices"
+Provides-Extra: crosscheck
+Requires-Dist: strawberryfields; extra == "crosscheck"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# dyberforge (Workbench SDK)
+
+Open-source H-cat photonic quantum computing simulation SDK. One import surface over the
+validated Dyber simulation code.
+
+## Install (development)
+
+```bash
+conda create -n dyber python=3.11 -y && conda activate dyber
+pip install numpy scipy qutip matplotlib stim pymatching
+pip install -e .            # from forge/sdk/
+```
+
+## Use
+
+```python
+import dyberforge as df
+df.generate_cat(s_db=6.0, k=1, N=40)        # cat fidelity, parity, Wigner-ready state
+df.loss_curves(2.0, [10**-0.32])            # loss budget, parity stabilization
+df.estimate(gamma=0.005, target_logical_err=1e-9)  # 0.5% spec -> device spec (v2)
+```
+
+Run the example: `python examples/quickstart.py`.
+
+## Notes
+
+- The physics modules are vendored into `dyberforge/`, so the package is fully
+  self-contained: `pip install dyberforge` works standalone with no path injection.
+- Public science only. The OpenForge compiler passes, calibration internals, the
+  architecture loss-chain ledger, and foundry recipes are proprietary and are not part of
+  this package.
+- Optional extras: `pip install .[devices]` (Meep), `.[crosscheck]` (Strawberry Fields),
+  `.[dev]` (pytest).

dyberforge-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dyberforge/__init__.py,sha256=GfrvHr6V7vmu-YFeAmVkkuQFZOcQyTvr9WKIgUpStiQ,1519
+dyberforge/cat_generation.py,sha256=spiKSFt-sN6EB7wxa2GGk6ePaD21hwVok2CQqfWxLM4,12560
+dyberforge/cat_loss_budget.py,sha256=DBsCd4NgqVUXMOxT1a9a3jQqH2V8VxEPRP67OwCjvaw,4222
+dyberforge/resource_model.py,sha256=S3uYB15AC4c3IBDHDAh4Qh762du07F20tO7inX66n3Q,11383
+dyberforge-0.1.0.dist-info/licenses/LICENSE,sha256=f7DuGEDcRwcVk0yt1RxHL5gFqq5gfHOCjguwsCziuIo,11342
+dyberforge-0.1.0.dist-info/METADATA,sha256=yXPs_XXIPtBEqYRpuCmO0zrih0ZmDBSXTt-Rbt9C9GM,2076
+dyberforge-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dyberforge-0.1.0.dist-info/top_level.txt,sha256=ZWWTjXO1W4bEmKWOF8_Uj1_d1m1K5-No6VozVnDG4uA,11
+dyberforge-0.1.0.dist-info/RECORD,,

dyberforge-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
+

dyberforge-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.

dyberforge-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dyberforge