qubasic 0.9.0__tar.gz → 0.10.0__tar.gz

{qubasic-0.9.0 → qubasic-0.10.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.10.0 (2026-06-19)
+
+Completes the frontier set: fault-tolerant QEC extras and a compilation/resources
+group. All offline on Qiskit/Aer/numpy.
+
+### Added
+- Surface code: `QEC SURFACE [d]`, a rotated surface code at odd distance d (validated to correct every weight-1 error).
+- Union-find / matching decoder: exact minimum-weight matching of syndrome defects, scalable and dependency-free, selected with the `UF` flag on `LOGICAL_ERROR_RATE`. It tracks the optimal lookup decoder on the repetition and surface codes; the lookup decoder remains the default and the right choice for non-topological codes like Steane and Shor.
+- Magic-state distillation: `DISTILL <p>` runs the 15-to-1 protocol (via the [15,11,3] Hamming detection), with cubic output-error suppression ~35 p^3.
+- Lattice surgery: `LATTICE <a> <b>` performs the joint Zbar_A Zbar_B measurement that merges two repetition patches (the building block of a lattice-surgery CNOT).
+- Fault-tolerant resource estimation: `RESOURCES <target_pL> <physical_p>` reports the surface-code distance, physical qubits per logical, T-count, T-factory overhead, and an approximate runtime.
+- Calibrated device models: `DEVICE linear|ring|heavyhex|all [n] [T1us] [T2us]` builds a per-qubit thermal-relaxation noise model and coupling map for offline hardware-realistic simulation.
+- `NOISE crosstalk <p>`: a correlated two-qubit ZZ crosstalk channel on entangling gates.
+- `OPTIMIZE [level]`: transpiles the program and reports the depth and gate-count reduction.
+
 ## 0.9.0 (2026-06-19)
 
 Frontier and experimental methods. All offline on Qiskit/Aer/numpy; nothing

{qubasic-0.9.0/qubasic.egg-info → qubasic-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.9.0
+Version: 0.10.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -514,11 +514,18 @@ CHANNEL AD = [[1,0],[0,0.95]] ; [[0,0.31],[0,0]]   Define a Kraus channel
 ## Error correction
 
 ```
-QEC STEANE               Show a code (REP [d], STEANE, SHOR) and its stabilizers
-LOGICAL_ERROR_RATE STEANE 0.02   Monte-Carlo logical error rate at physical p
+QEC STEANE               Show a code (REP [d], STEANE, SHOR, SURFACE [d]) and its stabilizers
+LOGICAL_ERROR_RATE STEANE 0.02   Monte-Carlo logical error rate (optimal lookup decoder)
+LOGICAL_ERROR_RATE SURFACE 0.02 UF   Same, with the union-find / matching decoder
 THRESHOLD REP 0.0 0.5 11         Sweep p across distances 3/5/7 (crossing at 0.5)
+DISTILL 0.02             15-to-1 magic-state distillation (output error ~35 p^3)
+LATTICE 0 1              Lattice-surgery joint Zbar-Zbar measurement of two patches
 ```
 
+Codes: repetition (any odd distance), Steane [[7,1,3]], Shor [[9,1,3]], rotated
+surface. Decoders: an optimal minimum-weight lookup table (all codes) and a
+scalable union-find / matching decoder (topological codes, via the `UF` flag).
+
 ## Benchmarking and verification
 
 ```
@@ -554,6 +561,16 @@ BOSONIC 1 25             Continuous-variable Fock modes
 DISPLACE 0 1.0           ...DISPLACE, SQUEEZE, CAT, BS, BSTATE
 ```
 
+## Compilation and resources
+
+```
+RESOURCES 1e-12 0.001    Fault-tolerant estimate (surface-code distance, qubits, runtime)
+DEVICE linear 5          Calibrated offline device model (per-qubit T1/T2 + coupling map)
+DEVICE ring 5 80 60      ...with custom T1/T2 in microseconds (also: heavyhex, all, OFF)
+OPTIMIZE 3               Transpile the program and report the depth/gate reduction
+NOISE crosstalk 0.01     Correlated two-qubit ZZ crosstalk on entangling gates
+```
+
 ## Noise models
 
 ```

{qubasic-0.9.0 → qubasic-0.10.0}/README.md

@@ -481,11 +481,18 @@ CHANNEL AD = [[1,0],[0,0.95]] ; [[0,0.31],[0,0]]   Define a Kraus channel
 ## Error correction
 
 ```
-QEC STEANE               Show a code (REP [d], STEANE, SHOR) and its stabilizers
-LOGICAL_ERROR_RATE STEANE 0.02   Monte-Carlo logical error rate at physical p
+QEC STEANE               Show a code (REP [d], STEANE, SHOR, SURFACE [d]) and its stabilizers
+LOGICAL_ERROR_RATE STEANE 0.02   Monte-Carlo logical error rate (optimal lookup decoder)
+LOGICAL_ERROR_RATE SURFACE 0.02 UF   Same, with the union-find / matching decoder
 THRESHOLD REP 0.0 0.5 11         Sweep p across distances 3/5/7 (crossing at 0.5)
+DISTILL 0.02             15-to-1 magic-state distillation (output error ~35 p^3)
+LATTICE 0 1              Lattice-surgery joint Zbar-Zbar measurement of two patches
 ```
 
+Codes: repetition (any odd distance), Steane [[7,1,3]], Shor [[9,1,3]], rotated
+surface. Decoders: an optimal minimum-weight lookup table (all codes) and a
+scalable union-find / matching decoder (topological codes, via the `UF` flag).
+
 ## Benchmarking and verification
 
 ```
@@ -521,6 +528,16 @@ BOSONIC 1 25             Continuous-variable Fock modes
 DISPLACE 0 1.0           ...DISPLACE, SQUEEZE, CAT, BS, BSTATE
 ```
 
+## Compilation and resources
+
+```
+RESOURCES 1e-12 0.001    Fault-tolerant estimate (surface-code distance, qubits, runtime)
+DEVICE linear 5          Calibrated offline device model (per-qubit T1/T2 + coupling map)
+DEVICE ring 5 80 60      ...with custom T1/T2 in microseconds (also: heavyhex, all, OFF)
+OPTIMIZE 3               Transpile the program and report the depth/gate reduction
+NOISE crosstalk 0.01     Correlated two-qubit ZZ crosstalk on entangling gates
+```
+
 ## Noise models
 
 ```

{qubasic-0.9.0 → qubasic-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.9.0"
+version = "0.10.0"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"

{qubasic-0.9.0 → qubasic-0.10.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.9.0
+Version: 0.10.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -514,11 +514,18 @@ CHANNEL AD = [[1,0],[0,0.95]] ; [[0,0.31],[0,0]]   Define a Kraus channel
 ## Error correction
 
 ```
-QEC STEANE               Show a code (REP [d], STEANE, SHOR) and its stabilizers
-LOGICAL_ERROR_RATE STEANE 0.02   Monte-Carlo logical error rate at physical p
+QEC STEANE               Show a code (REP [d], STEANE, SHOR, SURFACE [d]) and its stabilizers
+LOGICAL_ERROR_RATE STEANE 0.02   Monte-Carlo logical error rate (optimal lookup decoder)
+LOGICAL_ERROR_RATE SURFACE 0.02 UF   Same, with the union-find / matching decoder
 THRESHOLD REP 0.0 0.5 11         Sweep p across distances 3/5/7 (crossing at 0.5)
+DISTILL 0.02             15-to-1 magic-state distillation (output error ~35 p^3)
+LATTICE 0 1              Lattice-surgery joint Zbar-Zbar measurement of two patches
 ```
 
+Codes: repetition (any odd distance), Steane [[7,1,3]], Shor [[9,1,3]], rotated
+surface. Decoders: an optimal minimum-weight lookup table (all codes) and a
+scalable union-find / matching decoder (topological codes, via the `UF` flag).
+
 ## Benchmarking and verification
 
 ```
@@ -554,6 +561,16 @@ BOSONIC 1 25             Continuous-variable Fock modes
 DISPLACE 0 1.0           ...DISPLACE, SQUEEZE, CAT, BS, BSTATE
 ```
 
+## Compilation and resources
+
+```
+RESOURCES 1e-12 0.001    Fault-tolerant estimate (surface-code distance, qubits, runtime)
+DEVICE linear 5          Calibrated offline device model (per-qubit T1/T2 + coupling map)
+DEVICE ring 5 80 60      ...with custom T1/T2 in microseconds (also: heavyhex, all, OFF)
+OPTIMIZE 3               Transpile the program and report the depth/gate reduction
+NOISE crosstalk 0.01     Correlated two-qubit ZZ crosstalk on entangling gates
+```
+
 ## Noise models
 
 ```

{qubasic-0.9.0 → qubasic-0.10.0}/qubasic.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ qubasic_core/protocol.py
 qubasic_core/qec.py
 qubasic_core/qol.py
 qubasic_core/qudits.py
+qubasic_core/resources.py
 qubasic_core/scope.py
 qubasic_core/screen.py
 qubasic_core/state_display.py

{qubasic-0.9.0 → qubasic-0.10.0}/qubasic_core/__init__.py

@@ -28,7 +28,7 @@ __all__ = [
     'GATE_TABLE', 'GATE_ALIASES',
 ]
 
-__version__ = '0.9.0'
+__version__ = '0.10.0'
 
 def __getattr__(name):
     """Lazy import heavy modules on first access."""

{qubasic-0.9.0 → qubasic-0.10.0}/qubasic_core/noise_mixin.py

@@ -106,10 +106,17 @@ class NoiseMixin:
                 p1 = float(parts[2]) if len(parts) > 2 else 0.01
                 nm.add_all_qubit_quantum_error(reset_error(p0, p1), _1q)
                 self.io.writeln(f"NOISE reset p0={p0} p1={p1}")
+            elif ntype == 'crosstalk':
+                # Correlated (non-product) two-qubit error after each 2-qubit gate:
+                # a ZZ Pauli with probability p, otherwise identity.
+                p = float(parts[1]) if len(parts) > 1 else 0.01
+                err = pauli_error([('ZZ', p), ('II', 1 - p)])
+                nm.add_all_qubit_quantum_error(err, _2q)
+                self.io.writeln(f"NOISE crosstalk (correlated ZZ on 2-qubit gates) p={p}")
             else:
                 self.io.writeln(f"?UNKNOWN NOISE TYPE: {ntype}")
                 self.io.writeln("  Types: depolarizing, amplitude_damping, phase_flip, thermal,")
-                self.io.writeln("         readout, combined, pauli, reset")
+                self.io.writeln("         readout, combined, pauli, reset, crosstalk")
                 return
             self._noise_model = nm
             self._noise_spec = rest.strip()  # for SAVE round-tripping

qubasic-0.10.0/qubasic_core/qec.py

@@ -0,0 +1,434 @@
+"""QUBASIC quantum error correction.
+
+Stabilizer codes with an optimal (minimum-weight lookup) decoder, logical error
+rates, and threshold sweeps, computed by classical Pauli-frame simulation (no
+statevector needed, so it is exact and fast). Built-in codes: the repetition
+(bit-flip) code at any odd distance, the [[7,1,3]] Steane code, and the [[9,1,3]]
+Shor code.
+
+  QEC LIST                       List the built-in codes
+  QEC STEANE                     Show a code's stabilizers and logical operators
+  LOGICAL_ERROR_RATE STEANE 0.05 Monte-Carlo logical error rate at physical rate p
+  THRESHOLD REP 0.0 0.5 11       Sweep p and compare code distances (find the crossing)
+"""
+
+from __future__ import annotations
+
+import re
+import itertools
+
+import numpy as np
+
+# Phase-free single-qubit Pauli multiplication (we only need the group structure).
+_PMUL = {
+    ('I', 'I'): 'I', ('I', 'X'): 'X', ('I', 'Y'): 'Y', ('I', 'Z'): 'Z',
+    ('X', 'I'): 'X', ('X', 'X'): 'I', ('X', 'Y'): 'Z', ('X', 'Z'): 'Y',
+    ('Y', 'I'): 'Y', ('Y', 'X'): 'Z', ('Y', 'Y'): 'I', ('Y', 'Z'): 'X',
+    ('Z', 'I'): 'Z', ('Z', 'X'): 'Y', ('Z', 'Y'): 'X', ('Z', 'Z'): 'I',
+}
+
+
+def _anticommute(a: str, b: str) -> int:
+    """1 if Pauli strings a and b anticommute, else 0."""
+    cnt = 0
+    for pa, pb in zip(a, b):
+        if pa != 'I' and pb != 'I' and pa != pb:
+            cnt ^= 1
+    return cnt
+
+
+def _pmul(a: str, b: str) -> str:
+    return ''.join(_PMUL[(pa, pb)] for pa, pb in zip(a, b))
+
+
+def _weight(p: str) -> int:
+    return sum(1 for c in p if c != 'I')
+
+
+class QECMixin:
+    """Stabilizer codes, decoding, and logical error rates for QBasicTerminal.
+
+    Requires: TerminalProtocol — uses self._eval_with_vars(), self._seed, self.io.
+    """
+
+    def _qec_code(self, name: str, distance: int = 3) -> dict:
+        """Return a code descriptor: data qubit count, stabilizers, logical X/Z,
+        distance, and the error alphabet the decoder corrects."""
+        name = name.upper()
+        if name in ('REP', 'REPETITION', 'BITFLIP'):
+            d = distance if distance % 2 == 1 else distance + 1
+            stab = []
+            for i in range(d - 1):
+                s = ['I'] * d
+                s[i] = 'Z'; s[i + 1] = 'Z'
+                stab.append(''.join(s))
+            return {'n': d, 'stab': stab, 'lx': 'X' * d, 'lz': 'Z' + 'I' * (d - 1),
+                    'd': d, 'alphabet': 'IX', 'name': f'repetition d={d}'}
+        if name == 'STEANE':
+            Hm = [[0, 0, 0, 1, 1, 1, 1], [0, 1, 1, 0, 0, 1, 1], [1, 0, 1, 0, 1, 0, 1]]
+            stab = [''.join('X' if b else 'I' for b in row) for row in Hm]
+            stab += [''.join('Z' if b else 'I' for b in row) for row in Hm]
+            return {'n': 7, 'stab': stab, 'lx': 'X' * 7, 'lz': 'Z' * 7,
+                    'd': 3, 'alphabet': 'IXYZ', 'name': 'Steane [[7,1,3]]'}
+        if name == 'SHOR':
+            stab = []
+            for b in range(3):
+                base = b * 3
+                for a, c in ((base, base + 1), (base + 1, base + 2)):
+                    s = ['I'] * 9; s[a] = 'Z'; s[c] = 'Z'; stab.append(''.join(s))
+            stab.append('XXXXXX' + 'III')
+            stab.append('III' + 'XXXXXX')
+            return {'n': 9, 'stab': stab, 'lx': 'X' * 9, 'lz': 'ZIIZIIZII',
+                    'd': 3, 'alphabet': 'IXYZ', 'name': 'Shor [[9,1,3]]'}
+        if name in ('SURFACE', 'SURF'):
+            return self._surface_code(distance)
+        raise ValueError(f"unknown code '{name}' (try REP, STEANE, SHOR, SURFACE; QEC LIST)")
+
+    def _surface_code(self, d: int) -> dict:
+        """Rotated surface code of odd distance d (d^2 data qubits on a d x d grid).
+
+        Bulk faces are weight-4 stabilizers alternating X/Z by checkerboard parity;
+        boundary faces are weight-2, X on the top/bottom edges and Z on the
+        left/right edges. Logical X is an X string along the top row, logical Z a
+        Z string down the left column. The construction is validated by the
+        caller's checks (it must correct every weight-1 error)."""
+        if d % 2 == 0:
+            d += 1
+        n = d * d
+
+        def idx(r, c):
+            return r * d + c
+
+        stab = []
+        for r in range(-1, d):
+            for c in range(-1, d):
+                corners = [(r, c), (r, c + 1), (r + 1, c), (r + 1, c + 1)]
+                qs = [idx(i, j) for (i, j) in corners if 0 <= i < d and 0 <= j < d]
+                if len(qs) < 2:
+                    continue
+                typ = 'Z' if (r + c) % 2 == 0 else 'X'
+                if len(qs) == 4:
+                    stab.append((typ, qs))
+                else:
+                    on_tb = (r == -1 or r == d - 1)
+                    on_lr = (c == -1 or c == d - 1)
+                    if on_tb and not on_lr and typ == 'X':
+                        stab.append((typ, qs))
+                    elif on_lr and not on_tb and typ == 'Z':
+                        stab.append((typ, qs))
+        stab_strs = []
+        for typ, qs in stab:
+            s = ['I'] * n
+            for q in qs:
+                s[q] = typ
+            stab_strs.append(''.join(s))
+        # Logical X runs down a column (between the top/bottom X boundaries);
+        # logical Z runs along a row (between the left/right Z boundaries). They
+        # cross at qubit 0 and so anticommute.
+        lx = ['I'] * n
+        for r in range(d):
+            lx[idx(r, 0)] = 'X'
+        lz = ['I'] * n
+        for c in range(d):
+            lz[idx(0, c)] = 'Z'
+        return {'n': n, 'stab': stab_strs, 'lx': ''.join(lx), 'lz': ''.join(lz),
+                'd': d, 'alphabet': 'IXYZ', 'name': f'rotated surface d={d}'}
+
+    def _qec_decoder(self, code: dict) -> dict:
+        """Build the minimum-weight lookup decoder: syndrome -> recovery Pauli.
+
+        Enumerates every error over the code's alphabet, keeping the lowest-weight
+        representative per syndrome. Optimal for these small codes."""
+        n = code['n']
+        stab = code['stab']
+        alphabet = code['alphabet']
+        table: dict = {}
+        for combo in itertools.product(alphabet, repeat=n):
+            err = ''.join(combo)
+            synd = tuple(_anticommute(err, s) for s in stab)
+            w = _weight(err)
+            if synd not in table or w < table[synd][1]:
+                table[synd] = (err, w)
+        return {synd: err for synd, (err, _w) in table.items()}
+
+    def _random_pauli_error(self, code: dict, p: float, rng) -> str:
+        """Sample an i.i.d. error per qubit: X for a bit-flip code, depolarizing else."""
+        n = code['n']
+        out = []
+        if code['alphabet'] == 'IX':
+            for _ in range(n):
+                out.append('X' if rng.random() < p else 'I')
+        else:
+            for _ in range(n):
+                r = rng.random()
+                if r < p:
+                    out.append('XYZ'[rng.integers(3)])
+                else:
+                    out.append('I')
+        return ''.join(out)
+
+    def _logical_error_rate(self, code: dict, p: float, trials: int, rng, uf: bool = False) -> float:
+        decoder = None if uf else self._qec_decoder(code)
+        stab, lx, lz = code['stab'], code['lx'], code['lz']
+        fails = 0
+        for _ in range(trials):
+            err = self._random_pauli_error(code, p, rng)
+            synd = tuple(_anticommute(err, s) for s in stab)
+            recovery = self._qec_matching_decode(code, synd) if uf \
+                else decoder.get(synd, 'I' * code['n'])
+            residual = _pmul(err, recovery)
+            if _anticommute(residual, lx) or _anticommute(residual, lz):
+                fails += 1
+        return fails / trials
+
+    def _qec_matching_decode(self, code: dict, syndrome) -> str:
+        """Union-find / matching decoder: minimum-weight matching of syndrome
+        defects on the matching graph, correcting the connecting qubits.
+
+        Scalable alternative to the exponential lookup table (it never enumerates
+        all errors). Defects are matched to each other or to the boundary by exact
+        minimum-weight matching over shortest paths, and the path qubits flipped.
+        """
+        import functools
+        from collections import deque
+        n = code['n']
+        stabs = code['stab']
+        xr = ['I'] * n
+        zr = ['I'] * n
+        for etype, dtype, rec in (('X', 'Z', xr), ('Z', 'X', zr)):
+            det = [i for i, s in enumerate(stabs) if set(s) - {'I'} == {dtype}]
+            defects = tuple(i for i in det if syndrome[i])
+            if not defects:
+                continue
+            adj = {i: [] for i in det}
+            adj['B'] = []
+            for q in range(n):
+                touch = [i for i in det if stabs[i][q] == dtype]
+                if len(touch) == 2:
+                    adj[touch[0]].append((touch[1], q)); adj[touch[1]].append((touch[0], q))
+                elif len(touch) == 1:
+                    adj[touch[0]].append(('B', q)); adj['B'].append((touch[0], q))
+
+            def bfs(src):
+                prev = {src: (None, None)}
+                dq = deque([src])
+                while dq:
+                    u = dq.popleft()
+                    for v, q in adj.get(u, []):
+                        if v not in prev:
+                            prev[v] = (u, q); dq.append(v)
+                return prev
+
+            prevs = {s: bfs(s) for s in defects}
+
+            def path_qubits(src, tgt):
+                prev = prevs[src]
+                qs, node = [], tgt
+                while node != src and prev.get(node, (None, None))[0] is not None:
+                    par, q = prev[node]
+                    qs.append(q); node = par
+                return qs
+
+            def dist(src, tgt):
+                return len(path_qubits(src, tgt)) if tgt in prevs[src] else 10 ** 9
+
+            @functools.lru_cache(maxsize=None)
+            def solve(rem):
+                if not rem:
+                    return (0, ())
+                i, rest = rem[0], rem[1:]
+                best_c, best_m = dist(i, 'B') + solve(rest)[0], ((i, 'B'),) + solve(rest)[1]
+                for k, j in enumerate(rest):
+                    sub = solve(rest[:k] + rest[k + 1:])
+                    c = dist(i, j) + sub[0]
+                    if c < best_c:
+                        best_c, best_m = c, ((i, j),) + sub[1]
+                return (best_c, best_m)
+
+            _, matches = solve(defects)
+            for a, b in matches:
+                for q in path_qubits(a, b):
+                    rec[q] = etype
+        out = []
+        for q in range(n):
+            x, z = xr[q] == 'X', zr[q] == 'Z'
+            out.append('Y' if (x and z) else 'X' if x else 'Z' if z else 'I')
+        return ''.join(out)
+
+    def cmd_distill(self, rest: str) -> None:
+        """DISTILL <p> [trials] — 15-to-1 magic-state (T-state) distillation.
+
+        Models the protocol's error detection by the [15,11,3] Hamming code:
+        15 noisy T-states (Z error rate p), accept on a trivial syndrome, and a
+        logical output error occurs only for an undetected nonzero codeword. The
+        output error rate scales as ~35 p^3, well below the input p."""
+        parts = rest.split()
+        if not parts:
+            self.io.writeln("?USAGE: DISTILL <p> [trials]")
+            return
+        try:
+            p = float(self._eval_with_vars(parts[0], {}))
+            trials = int(parts[1]) if len(parts) > 1 else 200000
+            # [15,11,3] Hamming parity-check matrix: columns are 1..15 in binary.
+            H = np.array([[ (c >> b) & 1 for c in range(1, 16)] for b in range(4)])
+            rng = np.random.default_rng(self._seed)
+            accepted = 0
+            errors = 0
+            for _ in range(trials):
+                e = (rng.random(15) < p).astype(int)
+                synd = H.dot(e) % 2
+                if not synd.any():            # accept: trivial syndrome
+                    accepted += 1
+                    if e.any():               # nonzero codeword -> logical error
+                        errors += 1
+            acc = accepted / trials
+            p_out = errors / accepted if accepted else 0.0
+            self.io.writeln(f"\n  15-to-1 magic-state distillation:")
+            self.io.writeln(f"    input error p      = {p:g}")
+            self.io.writeln(f"    acceptance rate    = {acc:.4f}")
+            self.io.writeln(f"    output error p_out = {p_out:.3e}   (~35 p^3 = {35 * p ** 3:.3e})")
+            self.io.writeln(f"    suppression p/p_out= {p / p_out:.1f}x" if p_out > 0 else
+                            "    output error: none observed")
+            self.variables['_DISTILL_POUT'] = p_out
+        except Exception as e:
+            self.io.writeln(f"?DISTILL ERROR: {e}")
+
+    def cmd_lattice(self, rest: str) -> None:
+        """LATTICE <stateA> <stateB> — lattice-surgery logical ZZ measurement.
+
+        Encodes two distance-3 repetition logical qubits in the given logical
+        states (0, 1, +, -), then performs a merge that measures the joint
+        operator Zbar_A Zbar_B (the basis of a lattice-surgery CNOT) via an
+        ancilla, and reports the logical parity outcome."""
+        parts = rest.split()
+        if len(parts) < 2:
+            self.io.writeln("?USAGE: LATTICE <stateA> <stateB>   (states: 0, 1, +, -)")
+            return
+        from qiskit import QuantumCircuit, transpile
+        from qiskit_aer import AerSimulator
+        try:
+            sa, sb = parts[0], parts[1]
+            # 3 data qubits per patch (A: 0-2, B: 3-5) + 1 merge ancilla (6).
+            qc = QuantumCircuit(7, 1)
+
+            def encode(base, state):
+                if state in ('1',):
+                    qc.x(base)
+                elif state in ('+', '-'):
+                    qc.h(base)
+                    if state == '-':
+                        qc.z(base)
+                qc.cx(base, base + 1); qc.cx(base, base + 2)   # repetition encode
+            encode(0, sa); encode(3, sb)
+            # Merge: measure Zbar_A Zbar_B = Z_{A0} Z_{B0} via an ancilla.
+            anc = 6
+            qc.h(anc)
+            qc.cz(anc, 0)
+            qc.cz(anc, 3)
+            qc.h(anc)
+            qc.measure(anc, 0)
+            backend = AerSimulator(noise_model=self._noise_model) if self._noise_model else AerSimulator()
+            counts = backend.run(transpile(qc, backend), shots=max(500, self.shots)).result().get_counts()
+            par = '+1 (even)' if counts.get('0', 0) >= counts.get('1', 0) else '-1 (odd)'
+            self.io.writeln(f"\n  Lattice surgery: merge of |{sa}>_L (A) and |{sb}>_L (B)")
+            self.io.writeln(f"    joint Zbar_A Zbar_B measurement -> {par}   {dict(counts)}")
+            self.io.writeln(f"    (a deterministic joint parity for computational inputs; the "
+                            f"building block of a lattice-surgery CNOT)")
+        except Exception as e:
+            self.io.writeln(f"?LATTICE ERROR: {e}")
+
+    # ── Commands ────────────────────────────────────────────────────────
+
+    def cmd_qec(self, rest: str) -> None:
+        """QEC LIST | QEC <code> [distance] — show a stabilizer code.
+
+        Lists the built-in codes, or prints a code's stabilizer generators and
+        logical operators (and verifies they form a valid code)."""
+        arg = rest.strip().upper()
+        if not arg or arg == 'LIST':
+            self.io.writeln("\n  Built-in QEC codes:")
+            self.io.writeln("    REP [d]     repetition / bit-flip code, odd distance d (default 3)")
+            self.io.writeln("    STEANE      [[7,1,3]] CSS code")
+            self.io.writeln("    SHOR        [[9,1,3]] code")
+            self.io.writeln("    SURFACE [d] rotated surface code, odd distance d (default 3)")
+            self.io.writeln("  Decoders: optimal lookup (default), union-find (LOGICAL_ERROR_RATE ... UF)")
+            return
+        parts = arg.split()
+        try:
+            d = int(parts[1]) if len(parts) > 1 else 3
+            code = self._qec_code(parts[0], d)
+        except Exception as e:
+            self.io.writeln(f"?QEC ERROR: {e}")
+            return
+        self.io.writeln(f"\n  {code['name']}: {code['n']} data qubits, distance {code['d']}")
+        self.io.writeln(f"  Stabilizers ({len(code['stab'])}):")
+        for s in code['stab']:
+            self.io.writeln(f"    {s}")
+        self.io.writeln(f"  Logical X: {code['lx']}")
+        self.io.writeln(f"  Logical Z: {code['lz']}")
+        # Validity self-check: logicals commute with every stabilizer and
+        # anticommute with each other.
+        ok = bool(all(not _anticommute(code['lx'], s) for s in code['stab'])
+                  and all(not _anticommute(code['lz'], s) for s in code['stab'])
+                  and _anticommute(code['lx'], code['lz']))
+        self.io.writeln(f"  Valid code (logicals normalize the stabilizer group): {ok}")
+
+    def cmd_logical_error_rate(self, rest: str) -> None:
+        """LOGICAL_ERROR_RATE <code> [distance] <p> [trials] — Monte-Carlo logical error rate.
+
+        Injects i.i.d. physical errors at rate p, extracts the syndrome, decodes
+        with the optimal lookup decoder, applies the recovery, and reports the
+        fraction of trials left with a logical error."""
+        parts = rest.split()
+        if len(parts) < 2:
+            self.io.writeln("?USAGE: LOGICAL_ERROR_RATE <code> [distance] <p> [trials]")
+            return
+        try:
+            name = parts[0]
+            idx = 1
+            distance = 3
+            if len(parts) > 2 and parts[1].isdigit() and float(parts[1]) >= 1:
+                distance = int(parts[1]); idx = 2
+            uf = any(t.upper() in ('UF', 'UNION-FIND', 'MATCHING') for t in parts)
+            tail = [t for t in parts[idx:] if t.upper() not in ('UF', 'UNION-FIND', 'MATCHING')]
+            p = float(self._eval_with_vars(tail[0], {}))
+            trials = int(tail[1]) if len(tail) > 1 else 20000
+            code = self._qec_code(name, distance)
+            rng = np.random.default_rng(self._seed)
+            ler = self._logical_error_rate(code, p, trials, rng, uf=uf)
+            self.io.writeln(f"\n  {code['name']}: physical p={p}, {trials} trials"
+                            f"{' (union-find decoder)' if uf else ' (lookup decoder)'}")
+            self.io.writeln(f"  Logical error rate = {ler:.6f}")
+            self.variables['_LER'] = ler
+        except Exception as e:
+            self.io.writeln(f"?LOGICAL_ERROR_RATE ERROR: {e}")
+
+    def cmd_threshold(self, rest: str) -> None:
+        """THRESHOLD <code> <p1> <p2> <steps> [d1 d2 ...] — sweep physical error rate.
+
+        Reports the logical error rate across [p1, p2] for several code distances
+        (default 3, 5, 7 for the repetition code), so the threshold crossing where
+        larger codes start helping is visible."""
+        parts = rest.split()
+        if len(parts) < 4:
+            self.io.writeln("?USAGE: THRESHOLD <code> <p1> <p2> <steps> [distances]")
+            return
+        try:
+            name = parts[0]
+            p1 = float(self._eval_with_vars(parts[1], {}))
+            p2 = float(self._eval_with_vars(parts[2], {}))
+            steps = int(parts[3])
+            distances = [int(x) for x in parts[4:]] if len(parts) > 4 else [3, 5, 7]
+            ps = [p1 + (p2 - p1) * i / max(1, steps - 1) for i in range(steps)]
+            codes = [self._qec_code(name, d) for d in distances]
+            rng = np.random.default_rng(self._seed)
+            trials = 8000
+            self.io.writeln(f"\n  Threshold sweep ({name.upper()}), {trials} trials/point:")
+            self.io.writeln("    p      " + ''.join(f"  d={c['d']:<8}" for c in codes))
+            for p in ps:
+                row = f"  {p:5.3f}  "
+                for c in codes:
+                    row += f"  {self._logical_error_rate(c, p, trials, rng):<8.4f}"
+                self.io.writeln(row)
+        except Exception as e:
+            self.io.writeln(f"?THRESHOLD ERROR: {e}")

{qubasic-0.9.0 → qubasic-0.10.0}/qubasic_core/qol.py

@@ -98,12 +98,13 @@ _ALL_COMMANDS = [
     'MINIMIZE', 'GRADIENT', 'FIDELITY', 'TOMOGRAPHY', 'COUPLING', 'BASIS',
     'LOADQASM', 'SET_DENSITY', 'SAVEPNG', 'PTOMOGRAPHY', 'RB', 'MEASURE',
     'HAMILTONIAN', 'EVOLVE', 'LINDBLAD', 'CHANNEL', 'APPLYCHANNEL',
-    'QEC', 'LOGICAL_ERROR_RATE', 'THRESHOLD',
+    'QEC', 'LOGICAL_ERROR_RATE', 'THRESHOLD', 'DISTILL', 'LATTICE',
     'XEB', 'QVOLUME', 'RBINT', 'MIRROR', 'GST', 'CONCURRENCE', 'NEGATIVITY',
     'IQPE', 'AMPEST', 'AMPLIFY', 'QWALK', 'GRAPHSTATE', 'FEATUREMAP', 'QKERNEL',
     'SHOR', 'HHL', 'PAULIPROP',
     'QUDIT', 'QX', 'QZ', 'QF', 'QSUM', 'QSTATE', 'QMEASURE',
     'BOSONIC', 'DISPLACE', 'SQUEEZE', 'CAT', 'BS', 'BSTATE',
+    'RESOURCES', 'DEVICE', 'OPTIMIZE',
     # Gates
     'H', 'X', 'Y', 'Z', 'S', 'T', 'SDG', 'TDG', 'SX', 'ID',
     'RX', 'RY', 'RZ', 'P', 'U', 'CX', 'CZ', 'CY', 'CH',