qubasic 0.3.0__tar.gz → 0.4.0__tar.gz

qubasic-0.4.0/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+## 0.4.0 (2026-03-29)
+
+- **Noise correctness**: transpile with optimization_level=0 when noisy so gates survive for noise attachment
+- **Noisy statevector**: STATE/BLOCH/DENSITY now reflect the noisy executed state, not the ideal state
+- **LOCC noise**: Monte Carlo depolarizing noise in the numpy LOCC engine with per-shot execution
+- **GPU**: _make_backend centralizes device flag to all execution paths; graceful probe and fallback
+- **cmd_run decomposition**: extracted _run_no_measure, _run_with_fallback, _extract_statevector, _finalize_run, _select_method, _build_backend_opts, _run_kwargs
+- **State consistency**: _active_sv/_active_nqubits unify LOCC and standard paths for all state commands
+- **SPLIT mode**: EXPECT/DENSITY correctly report that per-register commands are needed
+- **Non-depolarizing noise warning**: entering LOCC mode with unsupported noise types warns explicitly
+- SEED command for deterministic reproducible results
+- VERSION command with build ID, simulator versions, and feature flags
+- PROBE command: one-shot exercise of CPU, noise, LOCC, conditional, and combined paths
+- CONSISTENCY command: cross-check SV norm, purity, Bloch vectors, EXPECT, and histogram
+- METHOD capability map: real probing of each method and GPU availability
+- HELP STATUS: tags all 93 commands as native/experimental/partial
+- CATALOG shows backend behind each SYS routine
+- RUN prints method, device, noise params in summary line
+- Demo self-verification: Bell, GHZ, Grover, Deutsch, BV, Superdense auto-check with pass/fail thresholds
+- Teleportation fidelity output with X-basis verification
+- LOCCINFO: entanglement creation, correction log, branch statistics, noise status
+- Method-device pre-check blocks incompatible combinations before execution
+- Runtime errors identify failing subsystem (GPU/noise/stabilizer/MPS)
+- Run manifest captures all execution parameters for replay
+- Correction log in LOCC engine tracks SEND outcomes
+- NOISE INFO prints exact channels, operations, qubits
+- 25 new tests covering noise, LOCC noise, SEED, VERSION, PROBE, CONSISTENCY, demos, state-after-LOCC, manifest, and method-device pre-check (196 total, up from 171)
+- real_sim pytest marker for tests requiring actual Qiskit Aer simulation
+
+## 0.3.1 (2026-03-29)
+
+- Fix f-string backslash escapes that broke import on Python 3.10/3.11
+
+## 0.3.0 (2026-03-28)
+
+- FUNCTION return value fix, APPLY_CIRCUIT in programs, stabilizer fallback
+- Bump to 0.3.0
+
+## 0.2.0 (2026-03-28)
+
+- Rename qbasic -> qubasic everywhere (PyPI name conflict)
+
+## 0.1.0 (2026-03-28)
+
+Initial PyPI release.
+
+- BASIC REPL with line-numbered program editing
+- 30+ quantum gates (H, X, Y, Z, CX, CCX, RX, RY, RZ, CP, SWAP, etc.)
+- LOCC mode: 2-26 party distributed quantum simulation (SPLIT and JOINT)
+- Full BASIC language: FOR/NEXT, WHILE/WEND, DO/LOOP, SELECT CASE, SUB/FUNCTION, IF/THEN/ELSE
+- AST-based expression evaluator (no eval)
+- Noise models: depolarizing, amplitude damping, phase flip, thermal, readout, combined, Pauli, reset
+- Debugging: STEP, TRON/TROFF, breakpoints, watch, time-travel (REWIND/FORWARD), PROFILE
+- Memory map: PEEK/POKE/SYS/DUMP/MAP/MONITOR
+- Analysis: EXPECT, ENTROPY, DENSITY, SWEEP, BENCH, RAM
+- File I/O: SAVE/LOAD/INCLUDE/IMPORT, OPEN/CLOSE/PRINT#/INPUT#, CSV, OpenQASM 3.0 export
+- 12 built-in demos: Bell, GHZ, Grover, QFT, Deutsch-Jozsa, Bernstein-Vazirani, Superdense, Teleport, LOCC
+- JSON output mode for agent/pipeline integration
+- String variable resolution in PRINT (LEFT$, RIGHT$, CHR$, concatenation)
+- DEF FN and parameterized DEF subroutine invocation
+- Trusted publisher CI/CD to PyPI

{qubasic-0.3.0/qubasic.egg-info → qubasic-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.3.0
+Version: 0.4.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT

{qubasic-0.3.0 → qubasic-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.3.0"
+version = "0.4.0"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -53,6 +53,9 @@ packages = ["qubasic_core"]
 [tool.setuptools.data-files]
 "share/qubasic/examples" = ["examples/*.qb"]
 
+[tool.pytest.ini_options]
+markers = ["real_sim: test requires real Qiskit Aer simulation (no mock)"]
+
 [tool.coverage.run]
 source = ["qubasic_core"]
 omit = ["*/test_*"]
@@ -65,7 +68,7 @@ skip_empty = true
 python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
-disallow_untyped_defs = false
+disallow_untyped_defs = true
 check_untyped_defs = true
 warn_redundant_casts = true
 warn_unused_ignores = true

{qubasic-0.3.0 → qubasic-0.4.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.3.0
+Version: 0.4.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT

{qubasic-0.3.0 → qubasic-0.4.0}/qubasic_core/__init__.py

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

{qubasic-0.3.0 → qubasic-0.4.0}/qubasic_core/analysis.py

@@ -25,8 +25,12 @@ class AnalysisMixin:
     def cmd_expect(self, rest: str) -> None:
         """EXPECT <pauli> [qubits] — compute expectation value.
         Examples: EXPECT Z 0, EXPECT ZZ 0 1, EXPECT X 0"""
-        if self.last_sv is None:
-            self.io.writeln("?NO STATE — RUN first")
+        sv = self._active_sv
+        if sv is None:
+            if self.locc_mode and self.locc and not self.locc.joint:
+                self.io.writeln("?SPLIT mode: use STATE A / STATE B for per-register inspection")
+            else:
+                self.io.writeln("?NO STATE — RUN first")
             return
         parts = rest.split()
         if not parts:
@@ -35,16 +39,16 @@ class AnalysisMixin:
         pauli_str = parts[0].upper()
         qubits = [int(q) for q in parts[1:]] if len(parts) > 1 else list(range(len(pauli_str)))
 
+        n = self._active_nqubits
         try:
             from qiskit.quantum_info import Statevector, SparsePauliOp
-            sv = Statevector(np.ascontiguousarray(self.last_sv).ravel())
-            # Build Pauli string for full system
-            full_pauli = ['I'] * self.num_qubits
+            sv_q = Statevector(np.ascontiguousarray(sv).ravel())
+            full_pauli = ['I'] * n
             for i, p in enumerate(pauli_str):
                 if i < len(qubits):
-                    full_pauli[self.num_qubits - 1 - qubits[i]] = p
+                    full_pauli[n - 1 - qubits[i]] = p
             op = SparsePauliOp(''.join(full_pauli))
-            val = sv.expectation_value(op)
+            val = sv_q.expectation_value(op)
             self.io.writeln(f"  <{pauli_str}> on qubits {qubits} = {val.real:.6f}")
         except Exception as e:
             self.io.writeln(f"?EXPECT ERROR: {e}")
@@ -52,17 +56,18 @@ class AnalysisMixin:
     def cmd_entropy(self, rest: str = '') -> None:
         """ENTROPY [qubits] — entanglement entropy of specified qubits vs rest.
         Examples: ENTROPY 0  |  ENTROPY 0 1  |  ENTROPY (defaults to qubit 0)"""
-        if self.last_sv is None:
+        sv = self._active_sv
+        if sv is None:
             self.io.writeln("?NO STATE — RUN first")
             return
         if rest.strip():
             partition_a = [int(q) for q in rest.replace(',', ' ').split() if q.strip()]
         else:
             partition_a = [0]
-        n = self.num_qubits
+        n = self._active_nqubits
         try:
             from qiskit.quantum_info import Statevector, entropy, partial_trace
-            sv_obj = Statevector(np.ascontiguousarray(self.last_sv).ravel())
+            sv_obj = Statevector(np.ascontiguousarray(sv).ravel())
             keep = partition_a
             rho_a = partial_trace(sv_obj, [q for q in range(n) if q not in keep])
             ent = entropy(rho_a, base=2)
@@ -78,12 +83,13 @@ class AnalysisMixin:
 
     def cmd_density(self) -> None:
         """Show density matrix (or partial trace for small systems)."""
-        if self.last_sv is None:
+        sv = self._active_sv
+        if sv is None:
             self.io.writeln("?NO STATE — RUN first")
             return
-        sv = np.ascontiguousarray(self.last_sv).ravel()
+        sv = np.ascontiguousarray(sv).ravel()
         rho = np.outer(sv, sv.conj())
-        n = self.num_qubits
+        n = self._active_nqubits
         dim = 2**n
         if dim > 16:
             self.io.writeln(f"  Density matrix: {dim}x{dim} (too large to display)")
@@ -140,6 +146,82 @@ class AnalysisMixin:
                 self.io.writeln(f"  {n:>8}  {method:>20}  FAILED: {e}")
         self.io.writeln('')
 
+    def cmd_consistency(self, rest: str = '') -> None:
+        """CONSISTENCY — cross-check histogram, SV, density, Bloch, and EXPECT."""
+        sv = self._active_sv
+        if sv is None:
+            self.io.writeln("?NO STATE — RUN first")
+            return
+        n = self._active_nqubits
+        sv = np.ascontiguousarray(sv).ravel()
+        checks = []
+
+        # 1. SV normalization
+        norm = float(np.sum(np.abs(sv)**2))
+        ok = abs(norm - 1.0) < 1e-6
+        checks.append(('SV norm == 1', ok, f"{norm:.8f}"))
+
+        # 2. Density matrix purity
+        rho = np.outer(sv, sv.conj())
+        purity = float(np.real(np.trace(rho @ rho)))
+        ok2 = purity <= 1.0 + 1e-6
+        checks.append(('Purity <= 1', ok2, f"{purity:.8f}"))
+
+        # 3. Bloch vector length <= 1 for each qubit
+        bloch_ok = True
+        for q in range(min(n, 8)):
+            x, y, z = self._bloch_vector(sv, q, n)
+            r = (x**2 + y**2 + z**2) ** 0.5
+            if r > 1.0 + 1e-4:
+                bloch_ok = False
+                break
+        checks.append(('Bloch |r| <= 1', bloch_ok, ''))
+
+        # 4. EXPECT Z on qubit 0 matches P(0) - P(1)
+        try:
+            from qiskit.quantum_info import Statevector, SparsePauliOp
+            sv_q = Statevector(sv)
+            pauli_z = ['I'] * n
+            pauli_z[n - 1] = 'Z'
+            op = SparsePauliOp(''.join(pauli_z))
+            ez = float(sv_q.expectation_value(op).real)
+            # Compare with direct calculation
+            sv_t = sv.reshape([2] * n)
+            ax = n - 1
+            t0 = np.moveaxis(sv_t, ax, 0)[0].flatten()
+            t1 = np.moveaxis(sv_t, ax, 0)[1].flatten()
+            p0 = float(np.sum(np.abs(t0)**2))
+            p1 = float(np.sum(np.abs(t1)**2))
+            ez_direct = p0 - p1
+            ok4 = abs(ez - ez_direct) < 1e-6
+            checks.append(('<Z> consistent', ok4, f"qiskit={ez:.6f} direct={ez_direct:.6f}"))
+        except Exception as _e:
+            checks.append(('<Z> consistent', None, f"skip: {_e}"))
+
+        # 5. Histogram vs SV (if counts available)
+        if self.last_counts:
+            total = sum(self.last_counts.values())
+            hist_p0 = self.last_counts.get('0' * n, 0) / total
+            sv_p0 = float(np.abs(sv[0])**2)
+            # Loose check: histogram is statistical, allow 10% deviation
+            ok5 = abs(hist_p0 - sv_p0) < 0.15 or total < 50
+            checks.append(('Hist~SV P(|0>)', ok5,
+                          f"hist={hist_p0:.3f} sv={sv_p0:.3f}"))
+
+        self.io.writeln(f"\n  Consistency checks ({n} qubits):")
+        all_pass = True
+        for name, ok, detail in checks:
+            if ok is None:
+                status = 'SKIP'
+            elif ok:
+                status = 'PASS'
+            else:
+                status = 'FAIL'
+                all_pass = False
+            extra = f"  {detail}" if detail else ""
+            self.io.writeln(f"    {name:25s} {status}{extra}")
+        self.io.writeln(f"\n  {'ALL CONSISTENT' if all_pass else 'INCONSISTENCY DETECTED'}")
+
     def cmd_ram(self) -> None:
         """RAM — show memory budget, per-instance cost, and parallelism estimates."""
         ram = _get_ram_gb()

{qubasic-0.3.0 → qubasic-0.4.0}/qubasic_core/classic.py

@@ -409,6 +409,7 @@ class ClassicMixin:
     # ── OPTION BASE ───────────────────────────────────────────────────
 
     def _cf_option_base(self, stmt: str, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        # Parsed and stored; array indexing always starts at 0 in this implementation.
         if parsed is not None:
             self._option_base = parsed.base
         else:

qubasic-0.4.0/qubasic_core/control_flow.py

@@ -0,0 +1,309 @@
+"""Control flow helpers extracted from QBasicTerminal.
+
+Requires: TerminalProtocol (see qubasic_core.protocol).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Callable
+
+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,
+    ForStmt, NextStmt, WhileStmt, IfThenStmt,
+    DataStmt, ReadStmt, OnGotoStmt, OnGosubStmt,
+    SelectCaseStmt, CaseStmt, EndSelectStmt,
+    DoStmt, LoopStmt, ExitStmt,
+    SwapStmt, DefFnStmt, OptionBaseStmt,
+    SubStmt, EndSubStmt, FunctionStmt, EndFunctionStmt, CallStmt,
+    LocalStmt, StaticStmt, SharedStmt,
+    OnErrorStmt, ResumeStmt, ErrorStmt, AssertStmt, StopStmt,
+    OnMeasureStmt, OnTimerStmt,
+)
+
+
+class ControlFlowMixin:
+    """Mixin providing control flow helpers for QBasicTerminal.
+
+    Requires: TerminalProtocol — uses self.program, self.variables,
+    self.arrays, self.locc_mode, self.locc, self._gosub_stack,
+    self._eval_with_vars(), self._eval_condition(), self._substitute_vars().
+    """
+
+    # ── Control flow helpers (decomposed from _exec_control_flow) ────
+    #
+    # Each _cf_* method accepts (self, stmt, parsed, ...) where parsed is
+    # a required typed Stmt object.  The stmt parameter is retained in the
+    # signature for compatibility with _exec_control_flow's argument
+    # passing but is not used by the methods themselves.
+
+    def _cf_let_array(self, stmt: str, run_vars: dict[str, Any],
+                      parsed: LetArrayStmt) -> tuple[bool, ExecOutcome]:
+        name, idx_expr, val_expr = parsed.name, parsed.index_expr, parsed.value_expr
+        idx = int(self._eval_with_vars(idx_expr, run_vars))
+        val = self._eval_with_vars(val_expr, run_vars)
+        if name not in self.arrays:
+            self.arrays[name] = [0.0] * (idx + 1)
+        while idx >= len(self.arrays[name]):
+            self.arrays[name].append(0.0)
+        self.arrays[name][idx] = val
+        return True, ExecResult.ADVANCE
+
+    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)
+        run_vars[name] = val
+        self.variables[name] = val
+        return True, ExecResult.ADVANCE
+
+    def _cf_print(self, stmt: str, run_vars: dict[str, Any],
+                  parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
+        raw_expr = parsed.expr
+        text = self._substitute_vars(raw_expr.strip(), run_vars)
+        # Determine trailing separator: ; suppresses newline, , advances to tab
+        suppress_newline = raw_expr.rstrip().endswith(';')
+        tab_advance = raw_expr.rstrip().endswith(',')
+        if suppress_newline:
+            text = text.rstrip().removesuffix(';').rstrip()
+        elif tab_advance:
+            text = text.rstrip().removesuffix(',').rstrip()
+        # Evaluate SPC(n) and TAB(n) inline
+        def _replace_spc(m_spc):
+            n = int(self._eval_with_vars(m_spc.group(1), run_vars))
+            return ' ' * max(0, n)
+        def _replace_tab(m_tab):
+            n = int(self._eval_with_vars(m_tab.group(1), run_vars))
+            return ' ' * max(0, n)
+        text = re.sub(r'\bSPC\s*\(([^)]+)\)', _replace_spc, text, flags=re.IGNORECASE)
+        text = re.sub(r'\bTAB\s*\(([^)]+)\)', _replace_tab, text, flags=re.IGNORECASE)
+        # Evaluate the expression
+        if (text.startswith('"') and text.endswith('"')) or \
+           (text.startswith("'") and text.endswith("'")):
+            output = text[1:-1]
+        else:
+            try:
+                ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else dict(run_vars) if not isinstance(run_vars, dict) else run_vars
+                result = self._safe_eval(text, extra_ns=ns)
+                output = str(result)
+            except Exception:
+                output = text
+        # Output with separator behavior
+        if suppress_newline:
+            self.io.write(output)
+        elif tab_advance:
+            col = len(output) % 14
+            padding = 14 - col if col > 0 else 14
+            self.io.write(output + ' ' * padding)
+        else:
+            self.io.writeln(output)
+        return True, ExecResult.ADVANCE
+
+    def _cf_goto(self, stmt: str, sorted_lines: list[int],
+                 parsed: GotoStmt) -> tuple[bool, int]:
+        target = parsed.target
+        for idx, ln in enumerate(sorted_lines):
+            if ln == target:
+                return True, idx
+        raise RuntimeError(f"GOTO {target}: LINE NOT FOUND")
+
+    def _cf_gosub(self, stmt: str, sorted_lines: list[int], ip: int,
+                  parsed: GosubStmt) -> tuple[bool, int]:
+        target = parsed.target
+        self._gosub_stack.append(ip + 1)
+        for idx, ln in enumerate(sorted_lines):
+            if ln == target:
+                return True, idx
+        raise RuntimeError(f"GOSUB {target}: LINE NOT FOUND")
+
+    def _cf_for(self, stmt: str, run_vars: dict[str, Any], loop_stack: list[dict[str, Any]], ip: int,
+                parsed: ForStmt) -> tuple[bool, ExecOutcome]:
+        var = parsed.var
+        start_expr, end_expr, step_expr = parsed.start_expr, parsed.end_expr, parsed.step_expr
+        start = self._eval_with_vars(start_expr, run_vars)
+        end = self._eval_with_vars(end_expr, run_vars)
+        step = self._eval_with_vars(step_expr, run_vars) if step_expr else 1
+        try:
+            if start == int(start): start = int(start)
+        except (OverflowError, ValueError):
+            pass
+        try:
+            if end == int(end): end = int(end)
+        except (OverflowError, ValueError):
+            pass
+        try:
+            if isinstance(step, float) and step == int(step): step = int(step)
+        except (OverflowError, ValueError):
+            pass
+        run_vars[var] = start
+        self.variables[var] = start
+        loop_stack.append({'var': var, 'current': start, 'end': end,
+                           'step': step, 'return_ip': ip})
+        return True, ExecResult.ADVANCE
+
+    def _cf_next(self, stmt: str, run_vars: dict[str, Any], loop_stack: list[dict[str, Any]],
+                 parsed: NextStmt) -> tuple[bool, ExecOutcome]:
+        var = parsed.var
+        if not loop_stack or loop_stack[-1].get('var') != var:
+            if loop_stack:
+                expected = loop_stack[-1].get('var', '?')
+                raise RuntimeError(f"NEXT {var} does not match current FOR {expected}")
+            raise RuntimeError(f"NEXT {var} without matching FOR")
+        loop = loop_stack[-1]
+        loop['current'] += loop['step']
+        if (loop['step'] > 0 and loop['current'] <= loop['end']) or \
+           (loop['step'] < 0 and loop['current'] >= loop['end']):
+            run_vars[var] = loop['current']
+            self.variables[var] = loop['current']
+            return True, loop['return_ip'] + 1
+        else:
+            loop_stack.pop()
+            return True, ExecResult.ADVANCE
+
+    def _find_matching_wend(self, sorted_lines: list[int], ip: int) -> int:
+        """Find the ip after the WEND matching the WHILE at ip.
+
+        Scans forward with proper nesting depth tracking. Returns the ip
+        index past the matching WEND. Raises with the WHILE line number
+        for clear diagnostics.
+        """
+        depth = 1
+        scan = ip + 1
+        while scan < len(sorted_lines):
+            s = self.program[sorted_lines[scan]].strip().upper()
+            if s.startswith('WHILE '):
+                depth += 1
+            elif s == 'WEND':
+                depth -= 1
+                if depth == 0:
+                    return scan + 1
+            scan += 1
+        line_num = sorted_lines[ip]
+        raise RuntimeError(f"WHILE at line {line_num} has no matching WEND")
+
+    def _cf_while(self, stmt: str, run_vars: dict[str, Any], loop_stack: list[dict[str, Any]],
+                  sorted_lines: list[int], ip: int,
+                  parsed: WhileStmt) -> tuple[bool, ExecOutcome]:
+        cond = parsed.condition
+        if self._eval_condition(cond, run_vars):
+            loop_stack.append({'type': 'while', 'cond': cond, 'return_ip': ip})
+            return True, ExecResult.ADVANCE
+        else:
+            return True, self._find_matching_wend(sorted_lines, ip)
+
+    def _cf_wend(self, run_vars: dict[str, Any], loop_stack: list[dict[str, Any]],
+                 sorted_lines: list[int] | None = None, ip: int | None = None) -> tuple[bool, ExecOutcome] | None:
+        if not loop_stack or loop_stack[-1].get('type') != 'while':
+            ctx = f" at line {sorted_lines[ip]}" if sorted_lines and ip is not None else ""
+            raise RuntimeError(f"WEND{ctx} without matching WHILE")
+        loop = loop_stack[-1]
+        if self._eval_condition(loop['cond'], run_vars):
+            return True, loop['return_ip']
+        else:
+            loop_stack.pop()
+            return True, ExecResult.ADVANCE
+
+    def _cf_if_then(self, stmt: str, run_vars: dict[str, Any], loop_stack: list[dict[str, Any]],
+                    sorted_lines: list[int], ip: int,
+                    exec_fn: Callable[..., Any],
+                    parsed: IfThenStmt) -> tuple[bool, ExecOutcome]:
+        cond_str = parsed.condition
+        then_clause = parsed.then_clause
+        else_clause = parsed.else_clause
+        cond_vars = run_vars
+        if self.locc_mode and self.locc:
+            cond_vars = {**run_vars, **self.locc.classical}
+        result = ExecResult.ADVANCE
+        if self._eval_condition(cond_str, cond_vars):
+            if then_clause:
+                r = exec_fn(then_clause, loop_stack, sorted_lines, ip, run_vars)
+                if r is not None and r is not ExecResult.ADVANCE:
+                    result = r
+        elif else_clause:
+            r = exec_fn(else_clause, loop_stack, sorted_lines, ip, run_vars)
+            if r is not None and r is not ExecResult.ADVANCE:
+                result = r
+        return True, result
+
+    # ── Type-based dispatch table ────────────────────────────────────
+    # Maps parsed Stmt types to handler lambdas.  Each lambda receives
+    # (self, stmt, parsed, loop_stack, sorted_lines, ip, run_vars,
+    # exec_fn) and returns (handled: bool, result).
+
+    _CF_DISPATCH: dict[type, Callable] = {
+        # Trivial handlers (no _cf_* method needed)
+        RemStmt:         lambda s, st, p, ls, sl, ip, rv, ef: (True, ExecResult.ADVANCE),
+        MeasureStmt:     lambda s, st, p, ls, sl, ip, rv, ef: (True, ExecResult.ADVANCE),
+        EndStmt:         lambda s, st, p, ls, sl, ip, rv, ef: (True, ExecResult.END),
+        ReturnStmt:      lambda s, st, p, ls, sl, ip, rv, ef: (_ for _ in ()).throw(RuntimeError("RETURN WITHOUT GOSUB")) if not s._gosub_stack else (True, s._gosub_stack.pop()),
+        # Handlers defined in control_flow.py (parsed is positional)
+        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),
+        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),
+        ForStmt:         lambda s, st, p, ls, sl, ip, rv, ef: s._cf_for(st, rv, ls, ip, p),
+        NextStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_next(st, rv, ls, p),
+        WhileStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_while(st, rv, ls, sl, ip, p),
+        IfThenStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_if_then(st, rv, ls, sl, ip, ef, p),
+        # Handlers defined in classic.py (parsed is keyword-only)
+        DataStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_data(st, parsed=p),
+        ReadStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_read(st, rv, parsed=p),
+        OnGotoStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_on_goto(st, rv, sl, parsed=p),
+        OnGosubStmt:     lambda s, st, p, ls, sl, ip, rv, ef: s._cf_on_gosub(st, rv, sl, ip, parsed=p),
+        SelectCaseStmt:  lambda s, st, p, ls, sl, ip, rv, ef: s._cf_select_case(st, rv, sl, ip, parsed=p),
+        CaseStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_case(st, sl, ip, parsed=p),
+        EndSelectStmt:   lambda s, st, p, ls, sl, ip, rv, ef: s._cf_end_select(st, parsed=p),
+        DoStmt:          lambda s, st, p, ls, sl, ip, rv, ef: s._cf_do(st, rv, ls, sl, ip, parsed=p),
+        LoopStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_loop(st, rv, ls, sl, ip, parsed=p),
+        ExitStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_exit(st, ls, sl, ip, parsed=p),
+        SwapStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_swap(st, rv, parsed=p),
+        DefFnStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_def_fn(st, rv, parsed=p),
+        OptionBaseStmt:  lambda s, st, p, ls, sl, ip, rv, ef: s._cf_option_base(st, parsed=p),
+        # Handlers defined in subs.py (parsed is keyword-only)
+        SubStmt:         lambda s, st, p, ls, sl, ip, rv, ef: s._cf_sub(st, sl, ip, parsed=p),
+        EndSubStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_end_sub(st, parsed=p),
+        FunctionStmt:    lambda s, st, p, ls, sl, ip, rv, ef: s._cf_function(st, sl, ip, parsed=p),
+        EndFunctionStmt: lambda s, st, p, ls, sl, ip, rv, ef: s._cf_end_function(st, parsed=p),
+        CallStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_call(st, rv, sl, ip, parsed=p),
+        LocalStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_local(st, rv, parsed=p),
+        StaticStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_static(st, rv, parsed=p),
+        SharedStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_shared(st, rv, parsed=p),
+        # Handlers defined in debug.py (parsed is keyword-only)
+        OnErrorStmt:     lambda s, st, p, ls, sl, ip, rv, ef: s._cf_on_error(st, parsed=p),
+        ResumeStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_resume(st, sl, parsed=p),
+        ErrorStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_error(st, parsed=p),
+        AssertStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_assert(st, rv, parsed=p),
+        StopStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_stop(st, sl, ip, parsed=p),
+        OnMeasureStmt:   lambda s, st, p, ls, sl, ip, rv, ef: s._cf_on_measure(st, parsed=p),
+        OnTimerStmt:     lambda s, st, p, ls, sl, ip, rv, ef: s._cf_on_timer(st, parsed=p),
+    }
+
+    def _exec_control_flow(
+        self, stmt: str, loop_stack: list[dict[str, Any]],
+        sorted_lines: list[int], ip: int, run_vars: dict[str, Any],
+        exec_fn: Callable[..., Any],
+        *, parsed=None,
+    ) -> tuple[bool, ExecOutcome | None]:
+        """Shared control flow for both Qiskit and LOCC execution paths.
+        Returns (handled, result) -- if handled is True, result is the
+        return value.  exec_fn is the recursive line executor for
+        IF/multi-statement dispatch.
+
+        Dispatches via dict lookup on the parsed Stmt type (O(1)).
+
+        If *parsed* is provided, the parse_stmt call is skipped (avoids
+        redundant parsing when the caller has already parsed the statement).
+        """
+        if parsed is None:
+            parsed = parse_stmt(stmt)
+        handler = self._CF_DISPATCH.get(type(parsed))
+        if handler is not None:
+            return handler(self, stmt, parsed, loop_stack, sorted_lines, ip, run_vars, exec_fn)
+
+        # RawStmt or unmapped type -- not handled by control flow
+        return False, None

{qubasic-0.3.0 → qubasic-0.4.0}/qubasic_core/debug.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import time
 
-MAX_SV_CHECKPOINTS = 1000
+MAX_SV_CHECKPOINTS = 200
 from typing import Any
 
 from qubasic_core.engine import (
@@ -131,8 +131,14 @@ class DebugMixin:
     # ── Time-travel debugging ─────────────────────────────────────────
 
     def _checkpoint_sv(self, line_num: int) -> None:
-        """Save a statevector checkpoint (for small qubit counts)."""
-        if self.last_sv is not None and self.num_qubits <= 16:
+        """Save a statevector checkpoint (for small qubit counts).
+
+        Only checkpoints systems with <= 12 qubits to keep memory reasonable.
+        12 qubits = 2^12 complex128 = ~64KB per checkpoint.
+        At MAX_SV_CHECKPOINTS=200 that is ~12MB total, versus ~1GB for 16-qubit
+        systems at the old limit.
+        """
+        if self.last_sv is not None and self.num_qubits <= 12:
             import numpy as np
             self._sv_checkpoints.append((line_num, np.array(self.last_sv).copy()))
             if len(self._sv_checkpoints) > MAX_SV_CHECKPOINTS:
@@ -225,7 +231,7 @@ class DebugMixin:
     # ── Breakpoints ────────────────────────────────────────────────────
 
     def cmd_breakpoint(self, rest: str) -> None:
-        """BREAK <line> — set/clear/list breakpoints."""
+        """BREAK <line> | BREAK CLEAR | BREAK LIST | BREAK <start>-<end> — manage breakpoints."""
         if not rest.strip():
             if self._breakpoints:
                 self.io.writeln(f"  Breakpoints: {sorted(self._breakpoints)}")
@@ -233,10 +239,29 @@ class DebugMixin:
                 self.io.writeln("  No breakpoints set")
             return
         rest = rest.strip().upper()
-        if rest == 'CLEAR':
+        if rest in ('CLEAR', 'ALL'):
             self._breakpoints.clear()
             self.io.writeln("BREAKPOINTS CLEARED")
             return
+        if rest == 'LIST':
+            if self._breakpoints:
+                for bp in sorted(self._breakpoints):
+                    src = self.program.get(bp, '(no source)')
+                    self.io.writeln(f"  {bp}: {src}")
+            else:
+                self.io.writeln("  No breakpoints set")
+            return
+        # Range: BREAK 10-50
+        if '-' in rest:
+            try:
+                a, b = rest.split('-')
+                for bp in list(self._breakpoints):
+                    if int(a) <= bp <= int(b):
+                        self._breakpoints.discard(bp)
+                self.io.writeln(f"BREAKPOINTS CLEARED IN {a}-{b}")
+                return
+            except ValueError:
+                pass
         try:
             line = int(rest)
             if line in self._breakpoints:
@@ -246,7 +271,7 @@ class DebugMixin:
                 self._breakpoints.add(line)
                 self.io.writeln(f"BREAKPOINT SET: {line}")
         except ValueError:
-            self.io.writeln("?USAGE: BREAK <line> | BREAK CLEAR")
+            self.io.writeln("?USAGE: BREAK <line> | BREAK <start>-<end> | BREAK CLEAR | BREAK LIST")
 
     def _check_breakpoint(self, line_num: int, sorted_lines: list[int], ip: int) -> bool:
         """Check if we should break at this line. Returns True to stop."""