qubasic 0.9.0__tar.gz → 0.10.1__tar.gz

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

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.10.1 (2026-06-19)
+
+Expression, string, and PRINT fixes in the classic-BASIC layer. The quantum
+engine is unchanged.
+
+### Fixed
+- Math functions resolve in any case: `SQRT`, `SIN`, `ABS`, `INT`, ... now work as well as their lowercase spellings, matching the rest of the language. Runtime and string functions (`RND`, `LEFT$`, ...) are likewise case-insensitive.
+- `AND`, `OR`, `NOT`, `XOR`, and `<>` work in every expression context (`LET`, `PRINT`, gate parameters), not only in `IF` conditions. `AND`/`OR`/`XOR` are bitwise on integers (`6 AND 3` = 2) while preserving operator precedence below comparison, so `IF a > b AND c > d` still groups correctly; `NOT` is logical.
+- String variables are fully usable: `LET s$ = "foo" + "bar"`, `LET t$ = LEFT$(s$, 3)`, and other computed strings store their real value in both immediate and program mode, instead of being mistaken for a quoted literal or forced through `float()`.
+- `PRINT` surfaces evaluation errors instead of silently printing the unevaluated source text. Assigning a string to a numeric variable reports a `TYPE MISMATCH` rather than crashing on a float conversion.
+
+## 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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.9.0
+Version: 0.10.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -242,7 +242,7 @@ CLEAR x                  Remove a variable
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
 Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
 Logical: `AND`, `OR`, `NOT`, `XOR`
-Bitwise: `AND`, `OR`, `XOR`, `NOT` (on integers)
+Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`
 
 ## Arrays
@@ -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.1}/README.md

@@ -209,7 +209,7 @@ CLEAR x                  Remove a variable
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
 Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
 Logical: `AND`, `OR`, `NOT`, `XOR`
-Bitwise: `AND`, `OR`, `XOR`, `NOT` (on integers)
+Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`
 
 ## Arrays
@@ -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.1}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.9.0
+Version: 0.10.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -242,7 +242,7 @@ CLEAR x                  Remove a variable
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
 Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
 Logical: `AND`, `OR`, `NOT`, `XOR`
-Bitwise: `AND`, `OR`, `XOR`, `NOT` (on integers)
+Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`
 
 ## Arrays
@@ -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.1}/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.1}/qubasic_core/__init__.py

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

{qubasic-0.9.0 → qubasic-0.10.1}/qubasic_core/control_flow.py

@@ -12,7 +12,7 @@ from qubasic_core.engine import ExecResult, ExecOutcome
 from qubasic_core.parser import parse_stmt
 from qubasic_core.statements import (
     RawStmt, RemStmt, MeasureStmt, EndStmt, ReturnStmt, WendStmt,
-    LetArrayStmt, LetStmt, PrintStmt, GotoStmt, GosubStmt,
+    LetArrayStmt, LetStmt, LetStrStmt, PrintStmt, GotoStmt, GosubStmt,
     ForStmt, NextStmt, WhileStmt, IfThenStmt,
     DataStmt, ReadStmt, OnGotoStmt, OnGosubStmt,
     SelectCaseStmt, CaseStmt, EndSelectStmt, ElseStmt, EndIfStmt,
@@ -106,7 +106,20 @@ class ControlFlowMixin:
     def _cf_let_var(self, stmt: str, run_vars: dict[str, Any],
                     parsed: LetStmt) -> tuple[bool, ExecOutcome]:
         name, expr = parsed.name, parsed.expr
-        val = self._eval_with_vars(expr, run_vars)
+        raw = self._safe_eval(expr, extra_ns=run_vars)
+        if isinstance(raw, str):
+            raise RuntimeError(
+                f"TYPE MISMATCH: '{name}' is numeric; use '{name}$' for strings")
+        val = float(raw)
+        run_vars[name] = val
+        self.variables[name] = val
+        return True, ExecResult.ADVANCE
+
+    def _cf_let_str(self, stmt: str, run_vars: dict[str, Any],
+                    parsed: LetStrStmt) -> tuple[bool, ExecOutcome]:
+        """LET v$ = <expr> — assign a string (or number) to a string variable."""
+        name, expr = parsed.name, parsed.expr
+        val = self._eval_string_expr(expr, run_vars)
         run_vars[name] = val
         self.variables[name] = val
         return True, ExecResult.ADVANCE
@@ -167,12 +180,12 @@ class ControlFlowMixin:
         text = re.sub(r'\bTAB\s*\(([^)]+)\)', _spaces, text, flags=re.IGNORECASE)
         if not text.strip():
             return text                      # standalone SPC/TAB -> whitespace
-        try:
-            ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else (
-                run_vars if isinstance(run_vars, dict) else dict(run_vars))
-            return str(self._safe_eval(text, extra_ns=ns))
-        except Exception:
-            return text
+        ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else (
+            run_vars if isinstance(run_vars, dict) else dict(run_vars))
+        # Surface evaluation errors instead of silently printing the raw source
+        # text (which used to turn PRINT SQRT(9) into the literal "SQRT(9)" and
+        # an undefined variable into its own name).
+        return str(self._safe_eval(text, extra_ns=ns))
 
     def _cf_print(self, stmt: str, run_vars: dict[str, Any],
                   parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
@@ -400,6 +413,7 @@ class ControlFlowMixin:
         WendStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_wend(rv, ls, sl, ip),
         LetArrayStmt:    lambda s, st, p, ls, sl, ip, rv, ef: s._cf_let_array(st, rv, p),
         LetStmt:         lambda s, st, p, ls, sl, ip, rv, ef: s._cf_let_var(st, rv, p),
+        LetStrStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_let_str(st, rv, p),
         PrintStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_print(st, rv, p),
         GotoStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_goto(st, sl, p),
         GosubStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_gosub(st, sl, ip, p),

{qubasic-0.9.0 → qubasic-0.10.1}/qubasic_core/expression.py

@@ -94,6 +94,36 @@ def _rewrite_logical_outside_strings(cond: str) -> str:
     return ''.join(parts)
 
 
+def _as_int(x: Any) -> int:
+    """Coerce a BASIC value to int for bitwise AND/OR/XOR.
+
+    QBasic rounds non-integers; truth values and non-numerics fold to 1/0 so
+    ``(a > 0) AND (b > 0)`` works the same as ``6 AND 3``.
+    """
+    if isinstance(x, bool):
+        return int(x)
+    if isinstance(x, int):
+        return x
+    if isinstance(x, float):
+        return int(round(x))
+    return 1 if x else 0
+
+
+def _basic_and(a: Any, b: Any) -> int:
+    """BASIC AND — bitwise on integers, and correct for truth values
+    (1 & 1 == 1, 1 & 0 == 0). Parsed from ``and`` so precedence stays below
+    comparison: ``a > b AND c > d`` groups as ``(a>b) AND (c>d)``."""
+    return _as_int(a) & _as_int(b)
+
+
+def _basic_or(a: Any, b: Any) -> int:
+    return _as_int(a) | _as_int(b)
+
+
+def _basic_xor(a: Any, b: Any) -> int:
+    return _as_int(a) ^ _as_int(b)
+
+
 class ExpressionMixin:
     """AST-based safe expression evaluation. No eval().
 
@@ -126,11 +156,14 @@ class ExpressionMixin:
         ast.Eq: operator.eq, ast.NotEq: operator.ne,
         ast.Lt: operator.lt, ast.LtE: operator.le,
         ast.Gt: operator.gt, ast.GtE: operator.ge,
-        ast.And: lambda a, b: a and b,
-        ast.Or: lambda a, b: a or b,
-        ast.BitAnd: operator.and_,
-        ast.BitOr: operator.or_,
-        ast.BitXor: operator.xor,
+        # AND/OR/XOR are BASIC's bitwise-logical operators (6 AND 3 == 2),
+        # robust to float operands; NOT stays logical so IF NOT flag works
+        # with 0/1 truth values.
+        ast.And: _basic_and,
+        ast.Or: _basic_or,
+        ast.BitAnd: _basic_and,
+        ast.BitOr: _basic_or,
+        ast.BitXor: _basic_xor,
         ast.Invert: operator.invert,
     }
 
@@ -237,6 +270,13 @@ class ExpressionMixin:
             ns['FRE'] = lambda x=0: psutil.virtual_memory().available
         except ImportError:
             ns['FRE'] = lambda x=0: 0
+        # BASIC is case-insensitive for built-in functions and constants, so
+        # register upper- and lower-case aliases for every builtin (SQRT and
+        # sqrt, RND and rnd, LEFT$ and left$). Variables are merged with their
+        # own case in _safe_eval and shadow these.
+        for _name in list(ns.keys()):
+            ns.setdefault(_name.upper(), ns[_name])
+            ns.setdefault(_name.lower(), ns[_name])
         self._base_ns = ns
         return ns
 
@@ -301,9 +341,17 @@ class ExpressionMixin:
         expr_str = str(expr).strip()
         # Normalize FN prefix: "FN square(x)" -> "square(x)"
         expr_str = re.sub(r'\bFN\s+(\w+)\s*\(', r'\1(', expr_str, flags=re.IGNORECASE)
+        # Rewrite BASIC logical/relational operators (AND, OR, NOT, XOR, <>) to
+        # the Python forms the AST understands, only outside quoted strings.
+        # Applied to every expression (LET, PRINT, gate params), not just IF
+        # conditions, so the documented operators work everywhere.
+        expr_str = _rewrite_logical_outside_strings(expr_str)
         # Rewrite numeric literals (&H, &B, $hex addresses) and the string
         # sigil, each only outside quoted string literals.
         expr_str = _replace_dollar_outside_strings(expr_str)
+        # The operator rewrite can pad a leading token (NOT x -> " not x"); strip
+        # so ast.parse(mode='eval') does not reject it as an unexpected indent.
+        expr_str = expr_str.strip()
         if not expr_str:
             raise ValueError("EMPTY EXPRESSION")
         try:
@@ -351,8 +399,11 @@ class ExpressionMixin:
         return float(self._safe_eval(expr, extra_ns=run_vars))
 
     def _eval_condition(self, cond: str, run_vars: dict[str, Any]) -> bool:
-        """Evaluate a boolean condition."""
-        cond = _rewrite_logical_outside_strings(cond)
+        """Evaluate a boolean condition.
+
+        The operator rewrite (AND/OR/NOT/XOR/<>) now happens inside _safe_eval,
+        so conditions and ordinary expressions share one consistent path.
+        """
         return bool(self._safe_eval(cond, extra_ns=run_vars))
 
     def _run_timer(self) -> float:

{qubasic-0.9.0 → qubasic-0.10.1}/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