qubasic 0.1.0__py3-none-any.whl

qbasic_core/debug.py

@@ -0,0 +1,327 @@
+"""QBASIC debug — ON ERROR, TRON/TROFF, STOP/CONT, breakpoints, watch, ASSERT, callbacks."""
+
+from __future__ import annotations
+
+import time
+
+MAX_SV_CHECKPOINTS = 1000
+from typing import Any
+
+from qbasic_core.engine import (
+    ExecResult, ExecOutcome,
+    RE_ON_ERROR, RE_RESUME, RE_ERROR_STMT, RE_ASSERT,
+    RE_ON_MEASURE, RE_ON_TIMER,
+)
+
+
+class DebugMixin:
+    """Error handling, debugging, and event callbacks for QBasicTerminal.
+
+    Requires: TerminalProtocol — uses self.program, self.variables,
+    self._eval_condition(), self._gosub_stack.
+    """
+
+    def _init_debug(self) -> None:
+        self._error_target: int | None = None
+        self._err_code: int = 0
+        self._err_line: int = 0
+        self._in_error_handler: bool = False
+        self._trace_mode: bool = False
+        self._stopped_ip: int | None = None
+        self._cont_skip_stop_ip: int | None = None
+        self._breakpoints: set[int] = set()
+        self._watches: list[str] = []
+        self._on_measure_target: int | None = None
+        self._on_timer_target: int | None = None
+        self._on_timer_interval: float = 0.0
+        self._on_timer_last: float = 0.0
+        # Time-travel: statevector checkpoints indexed by gate count
+        self._sv_checkpoints: list[tuple[int, Any]] = []  # [(line_num, sv_copy)]
+        self._tt_position: int = -1  # current position in checkpoint list
+
+    # ── Error handling ─────────────────────────────────────────────────
+
+    def _cf_on_error(self, stmt: str, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is not None:
+            target = parsed.target
+        else:
+            m = RE_ON_ERROR.match(stmt)
+            if not m:
+                return None
+            target = int(m.group(1))
+        if target == 0:
+            self._error_target = None
+        else:
+            self._error_target = target
+        return True, ExecResult.ADVANCE
+
+    def _cf_resume(self, stmt: str, sorted_lines: list[int], *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is not None:
+            self._in_error_handler = False
+            arg = parsed.arg
+        else:
+            m = RE_RESUME.match(stmt)
+            if not m:
+                return None
+            self._in_error_handler = False
+            arg = m.group(1)
+        if arg is None or arg.strip() == '':
+            # RESUME — retry the line that caused the error
+            for i, ln in enumerate(sorted_lines):
+                if ln == self._err_line:
+                    return True, i
+            return True, ExecResult.ADVANCE
+        if arg.strip().upper() == 'NEXT':
+            for i, ln in enumerate(sorted_lines):
+                if ln == self._err_line:
+                    return True, i + 1
+            return True, ExecResult.ADVANCE
+        # RESUME <line>
+        target = int(arg.strip())
+        for i, ln in enumerate(sorted_lines):
+            if ln == target:
+                return True, i
+        raise RuntimeError(f"RESUME: LINE {target} NOT FOUND")
+
+    def _cf_error(self, stmt: str, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is not None:
+            code = parsed.code
+        else:
+            m = RE_ERROR_STMT.match(stmt)
+            if not m:
+                return None
+            code = int(m.group(1))
+        raise RuntimeError(f"ERROR {code}")
+
+    def _handle_error(self, err: Exception, line_num: int,
+                      sorted_lines: list[int]) -> int | None:
+        """Handle a runtime error. Returns ip to jump to, or None to propagate."""
+        if self._error_target is not None and not self._in_error_handler:
+            self._err_code = 1
+            self._err_line = line_num
+            self._in_error_handler = True
+            # Extract error code from "ERROR N" messages
+            msg = str(err)
+            if msg.startswith('ERROR '):
+                try:
+                    self._err_code = int(msg.split()[1])
+                except (IndexError, ValueError):
+                    pass
+            self.variables['ERR'] = self._err_code
+            self.variables['ERL'] = self._err_line
+            for i, ln in enumerate(sorted_lines):
+                if ln == self._error_target:
+                    return i
+        return None
+
+    # ── ASSERT ─────────────────────────────────────────────────────────
+
+    def _cf_assert(self, stmt: str, run_vars: dict[str, Any], *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is not None:
+            cond = parsed.condition
+        else:
+            m = RE_ASSERT.match(stmt)
+            if not m:
+                return None
+            cond = m.group(1).strip()
+        if not self._eval_condition(cond, run_vars):
+            raise RuntimeError(f"ASSERTION FAILED: {cond}")
+        return True, ExecResult.ADVANCE
+
+    # ── 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:
+            import numpy as np
+            self._sv_checkpoints.append((line_num, np.array(self.last_sv).copy()))
+            if len(self._sv_checkpoints) > MAX_SV_CHECKPOINTS:
+                excess = len(self._sv_checkpoints) - MAX_SV_CHECKPOINTS
+                del self._sv_checkpoints[:excess]
+            self._tt_position = len(self._sv_checkpoints) - 1
+
+    def cmd_rewind(self, rest: str = '') -> None:
+        """REWIND [N] — go back N steps in the statevector history."""
+        if not self._sv_checkpoints:
+            self.io.writeln("?NO CHECKPOINTS — use STEP mode to build history")
+            return
+        n = int(rest.strip()) if rest.strip() else 1
+        new_pos = max(0, self._tt_position - n)
+        self._tt_position = new_pos
+        line_num, sv = self._sv_checkpoints[new_pos]
+        self.last_sv = sv.copy()
+        self.io.writeln(f"REWIND to step {new_pos} (line {line_num})")
+        self._print_sv_compact(sv)
+
+    def cmd_forward(self, rest: str = '') -> None:
+        """FORWARD [N] — go forward N steps in the statevector history."""
+        if not self._sv_checkpoints:
+            self.io.writeln("?NO CHECKPOINTS")
+            return
+        n = int(rest.strip()) if rest.strip() else 1
+        new_pos = min(len(self._sv_checkpoints) - 1, self._tt_position + n)
+        self._tt_position = new_pos
+        line_num, sv = self._sv_checkpoints[new_pos]
+        self.last_sv = sv.copy()
+        self.io.writeln(f"FORWARD to step {new_pos} (line {line_num})")
+        self._print_sv_compact(sv)
+
+    def cmd_history(self, rest: str = '') -> None:
+        """HISTORY — show statevector checkpoint list."""
+        if not self._sv_checkpoints:
+            self.io.writeln("?NO CHECKPOINTS")
+            return
+        for i, (ln, _) in enumerate(self._sv_checkpoints):
+            marker = " <<" if i == self._tt_position else ""
+            self.io.writeln(f"  [{i}] line {ln}{marker}")
+
+    # ── TRON / TROFF ───────────────────────────────────────────────────
+
+    def cmd_tron(self) -> None:
+        """TRON — trace on, print each line number during execution."""
+        self._trace_mode = True
+        self.io.writeln("TRACE ON")
+
+    def cmd_troff(self) -> None:
+        """TROFF — trace off."""
+        self._trace_mode = False
+        self.io.writeln("TRACE OFF")
+
+    def _trace_line(self, line_num: int) -> None:
+        """Print trace output if trace mode is on."""
+        if self._trace_mode:
+            self.io.write(f"[{line_num}]" + ' ')
+
+    # ── STOP / CONT ────────────────────────────────────────────────────
+
+    def _cf_stop(self, stmt: str, sorted_lines: list[int], ip: int, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is None and stmt.strip().upper() != 'STOP':
+            return None
+        # CONT sets _cont_skip_stop_ip to replay past this STOP
+        if self._cont_skip_stop_ip is not None and self._cont_skip_stop_ip == ip:
+            self._cont_skip_stop_ip = None
+            return True, ExecResult.ADVANCE
+        line_num = sorted_lines[ip]
+        self.io.writeln(f"STOPPED AT LINE {line_num}")
+        self._stopped_ip = ip
+        self._print_watches()
+        return True, ExecResult.END
+
+    def cmd_cont(self) -> None:
+        """CONT — continue execution after STOP, resuming from the next line.
+
+        Re-executes the program from the top but skips the STOP that fired,
+        so lines after STOP are reached. Variable state is rebuilt by
+        replaying all lines before the STOP.
+        """
+        if self._stopped_ip is None:
+            self.io.writeln("?CANNOT CONTINUE")
+            return
+        self.io.writeln("CONTINUING...")
+        self._cont_skip_stop_ip = self._stopped_ip
+        self._stopped_ip = None
+        self.cmd_run()
+
+    # ── Breakpoints ────────────────────────────────────────────────────
+
+    def cmd_breakpoint(self, rest: str) -> None:
+        """BREAK <line> — set/clear/list breakpoints."""
+        if not rest.strip():
+            if self._breakpoints:
+                self.io.writeln(f"  Breakpoints: {sorted(self._breakpoints)}")
+            else:
+                self.io.writeln("  No breakpoints set")
+            return
+        rest = rest.strip().upper()
+        if rest == 'CLEAR':
+            self._breakpoints.clear()
+            self.io.writeln("BREAKPOINTS CLEARED")
+            return
+        try:
+            line = int(rest)
+            if line in self._breakpoints:
+                self._breakpoints.discard(line)
+                self.io.writeln(f"BREAKPOINT REMOVED: {line}")
+            else:
+                self._breakpoints.add(line)
+                self.io.writeln(f"BREAKPOINT SET: {line}")
+        except ValueError:
+            self.io.writeln("?USAGE: BREAK <line> | BREAK CLEAR")
+
+    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."""
+        if line_num in self._breakpoints:
+            self.io.writeln(f"BREAKPOINT AT LINE {line_num}")
+            self._stopped_ip = ip
+            self._print_watches()
+            return True
+        return False
+
+    # ── Watch expressions ──────────────────────────────────────────────
+
+    def cmd_watch(self, rest: str) -> None:
+        """WATCH <expr> — add/remove/list watch expressions."""
+        if not rest.strip():
+            if self._watches:
+                self.io.writeln("  Watch expressions:")
+                for w in self._watches:
+                    self.io.writeln(f"    {w}")
+            else:
+                self.io.writeln("  No watches set")
+            return
+        rest = rest.strip()
+        if rest.upper() == 'CLEAR':
+            self._watches.clear()
+            self.io.writeln("WATCHES CLEARED")
+            return
+        if rest in self._watches:
+            self._watches.remove(rest)
+            self.io.writeln(f"WATCH REMOVED: {rest}")
+        else:
+            self._watches.append(rest)
+            self.io.writeln(f"WATCHING: {rest}")
+
+    def _print_watches(self) -> None:
+        for w in self._watches:
+            try:
+                val = self._safe_eval(w)
+                self.io.writeln(f"  {w} = {val}")
+            except Exception:
+                self.io.writeln(f"  {w} = ?")
+
+    # ── Callbacks ──────────────────────────────────────────────────────
+
+    def _cf_on_measure(self, stmt: str, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is not None:
+            self._on_measure_target = parsed.target
+        else:
+            m = RE_ON_MEASURE.match(stmt)
+            if not m:
+                return None
+            self._on_measure_target = int(m.group(1))
+        return True, ExecResult.ADVANCE
+
+    def _cf_on_timer(self, stmt: str, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        if parsed is not None:
+            self._on_timer_interval = float(parsed.interval)
+            self._on_timer_target = parsed.target
+        else:
+            m = RE_ON_TIMER.match(stmt)
+            if not m:
+                return None
+            self._on_timer_interval = float(m.group(1))
+            self._on_timer_target = int(m.group(2))
+        self._on_timer_last = time.time()
+        return True, ExecResult.ADVANCE
+
+    def _check_timer_callback(self, sorted_lines: list[int], ip: int) -> int | None:
+        """Check if ON TIMER callback should fire. Returns ip to jump to, or None."""
+        if self._on_timer_target is not None and self._on_timer_interval > 0:
+            now = time.time()
+            if now - self._on_timer_last >= self._on_timer_interval:
+                self._on_timer_last = now
+                self._gosub_stack.append(ip)
+                for i, ln in enumerate(sorted_lines):
+                    if ln == self._on_timer_target:
+                        return i
+        return None

qbasic_core/demos.py

@@ -0,0 +1,356 @@
+"""QBASIC built-in demo circuits."""
+
+
+class DemoMixin:
+    """Built-in quantum computing demos.
+
+    Requires: TerminalProtocol — uses self.program, self.num_qubits,
+    self.shots, self.cmd_new(), self.cmd_run(), self.cmd_list(), self.cmd_locc().
+    """
+
+    def cmd_demo(self, name):
+        demos = {
+            'BELL':        self._demo_bell,
+            'GHZ':         self._demo_ghz,
+            'TELEPORT':    self._demo_teleport,
+            'GROVER':      self._demo_grover,
+            'QFT':         self._demo_qft,
+            'DEUTSCH':     self._demo_deutsch,
+            'BERNSTEIN':   self._demo_bernstein,
+            'SUPERDENSE':  self._demo_superdense,
+            'RANDOM':      self._demo_random,
+            'STRESS':      self._demo_stress,
+            'LOCC-TELEPORT': self._demo_locc_teleport,
+            'LOCC-COORD':    self._demo_locc_coord,
+        }
+        name = name.upper().strip()
+        if not name or name == 'LIST':
+            self.io.writeln("  Available demos:")
+            for d in demos:
+                prefix = "  (LOCC)" if d.startswith('LOCC') else ""
+                self.io.writeln(f"    DEMO {d}{prefix}")
+            return
+        if name not in demos:
+            self.io.writeln(f"?UNKNOWN DEMO: {name}")
+            self.io.writeln(f"  Try: DEMO LIST")
+            return
+        demos[name]()
+
+    def _demo_bell(self):
+        self.cmd_new()
+        self.num_qubits = 2
+        self.program = {
+            10: "REM === Bell State ===",
+            20: "REM The simplest entanglement. Two qubits, perfectly correlated.",
+            30: "H 0",
+            40: "CX 0,1",
+            50: "MEASURE",
+        }
+        self.io.writeln("LOADED: Bell State (2 qubits)")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_ghz(self):
+        self.cmd_new()
+        n = min(self.num_qubits, 8)
+        self.num_qubits = n
+        self.program = {
+            10: "REM === GHZ State ===",
+            20: f"REM {n}-qubit Greenberger-Horne-Zeilinger state",
+            30: "REM All qubits entangled: 50% all-zeros, 50% all-ones.",
+            40: "REM Einstein called this 'spooky action at a distance.'",
+            50: "H 0",
+        }
+        line = 60
+        for i in range(1, n):
+            self.program[line] = f"CX 0,{i}"
+            line += 10
+        self.program[line] = "MEASURE"
+        self.io.writeln(f"LOADED: GHZ State ({n} qubits)")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_teleport(self):
+        self.cmd_new()
+        self.num_qubits = 3
+        self.program = {
+            10:  "REM === Quantum Teleportation (circuit only) ===",
+            20:  "REM Qubit 0: state to teleport (prepared as |+>)",
+            30:  "REM Qubit 1-2: entangled Bell pair (the 'channel')",
+            40:  "REM Shows the entangling stage of teleportation.",
+            50:  "REM Classical correction requires mid-circuit measurement",
+            60:  "REM with feedforward, which needs LOCC mode.",
+            70:  "REM >>> For full teleportation: DEMO LOCC-TELEPORT <<<",
+            80:  "REM",
+            90:  "REM Prepare state to teleport (|+> on qubit 0)",
+            100: "H 0",
+            110: "REM Create Bell pair on qubits 1,2",
+            120: "H 1",
+            130: "CX 1,2",
+            140: "REM Teleportation circuit (without classical correction)",
+            150: "CX 0,1",
+            160: "H 0",
+            170: "MEASURE",
+        }
+        self.io.writeln("LOADED: Quantum Teleportation — circuit stage (3 qubits)")
+        self.io.writeln("  Without correction: uniform over all 8 outcomes.")
+        self.io.writeln("  For full protocol with correction: DEMO LOCC-TELEPORT")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_grover(self):
+        self.cmd_new()
+        self.num_qubits = 3
+        self.shots = 1024
+        self.program = {
+            10:  "REM === Grover's Search Algorithm ===",
+            20:  "REM Searching for |101> among 8 states",
+            30:  "REM Classically: ~4 queries. Quantumly: 2 iterations, ~95%.",
+            40:  "REM Quadratic speedup over classical unstructured search.",
+            50:  "REM",
+            60:  "REM Superposition",
+            70:  "H 0 : H 1 : H 2",
+            80:  "REM",
+            90:  "REM === Grover iteration 1 ===",
+            100: "REM Oracle: flip phase of |101> (X on q1, CCZ, undo X)",
+            110: "X 1",
+            120: "H 2 : CCX 0,1,2 : H 2",
+            130: "X 1",
+            140: "REM Diffusion: 2|s><s| - I",
+            150: "H 0 : H 1 : H 2",
+            160: "X 0 : X 1 : X 2",
+            170: "H 2 : CCX 0,1,2 : H 2",
+            180: "X 0 : X 1 : X 2",
+            190: "H 0 : H 1 : H 2",
+            200: "REM",
+            210: "REM === Grover iteration 2 ===",
+            220: "X 1",
+            230: "H 2 : CCX 0,1,2 : H 2",
+            240: "X 1",
+            250: "H 0 : H 1 : H 2",
+            260: "X 0 : X 1 : X 2",
+            270: "H 2 : CCX 0,1,2 : H 2",
+            280: "X 0 : X 1 : X 2",
+            290: "H 0 : H 1 : H 2",
+            300: "REM",
+            310: "MEASURE",
+        }
+        self.io.writeln("LOADED: Grover's Search (3 qubits, target=|101>)")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_qft(self):
+        self.cmd_new()
+        self.num_qubits = 4
+        self.program = {
+            10:  "REM === Quantum Fourier Transform ===",
+            20:  "REM The quantum analog of the discrete Fourier transform.",
+            30:  "REM Exponentially faster than classical FFT.",
+            40:  "REM QFT is typically used as a subroutine (phase info lost on measure).",
+            50:  "REM",
+            60:  "REM Prepare input state |5> = |0101>",
+            70:  "X 0 : X 2",
+            80:  "REM",
+            90:  "REM QFT on 4 qubits",
+            100: "H 3",
+            110: "CP PI/2, 2, 3",
+            120: "CP PI/4, 1, 3",
+            130: "CP PI/8, 0, 3",
+            140: "H 2",
+            150: "CP PI/2, 1, 2",
+            160: "CP PI/4, 0, 2",
+            170: "H 1",
+            180: "CP PI/2, 0, 1",
+            190: "H 0",
+            200: "REM Swap for bit reversal",
+            210: "SWAP 0,3",
+            220: "SWAP 1,2",
+            230: "MEASURE",
+        }
+        self.io.writeln("LOADED: QFT on |0101> (4 qubits)")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_deutsch(self):
+        self.cmd_new()
+        self.num_qubits = 2
+        self.program = {
+            10:  "REM === Deutsch-Jozsa Algorithm ===",
+            20:  "REM Determines if a function is constant or balanced",
+            30:  "REM in ONE query. Classically needs 2.",
+            40:  "REM Published 1992. The first to demonstrate quantum advantage.",
+            50:  "REM",
+            60:  "REM Oracle qubit in |->",
+            70:  "X 1",
+            80:  "H 0 : H 1",
+            90:  "REM Oracle (balanced function: f(x) = x)",
+            100: "CX 0,1",
+            110: "REM Interfere and measure",
+            120: "H 0",
+            130: "MEASURE",
+        }
+        self.io.writeln("LOADED: Deutsch-Jozsa (2 qubits, balanced oracle)")
+        self.io.writeln("  Expect: qubit 0 = 1 (balanced)")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_bernstein(self):
+        self.cmd_new()
+        self.num_qubits = 5
+        self.program = {
+            10:  "REM === Bernstein-Vazirani Algorithm ===",
+            20:  "REM Finds a hidden bit string s in ONE query.",
+            30:  "REM Secret: s = 1011 (4 bits, display order q3q2q1q0)",
+            40:  "REM Classically you'd need 4 queries. Quantum: 1.",
+            50:  "REM",
+            60:  "REM Ancilla in |->",
+            70:  "X 4",
+            80:  "H 0 : H 1 : H 2 : H 3 : H 4",
+            90:  "REM Oracle: CX from each bit where s=1",
+            100: "CX 0,4",
+            110: "CX 1,4",
+            120: "CX 3,4",
+            130: "REM Interfere",
+            140: "H 0 : H 1 : H 2 : H 3",
+            150: "MEASURE",
+        }
+        self.io.writeln("LOADED: Bernstein-Vazirani (5 qubits, secret=1011)")
+        self.io.writeln("  Expect: measurement shows ...1011 (q3q2q1q0)")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_superdense(self):
+        self.cmd_new()
+        self.num_qubits = 2
+        self.program = {
+            10:  "REM === Superdense Coding ===",
+            20:  "REM Send 2 classical bits using 1 qubit.",
+            30:  "REM Encoding: 00->I, 01->X, 10->Z, 11->ZX (=iY)",
+            40:  "REM Sending message '11'",
+            50:  "REM",
+            60:  "REM Create Bell pair",
+            70:  "H 0",
+            80:  "CX 0,1",
+            90:  "REM Encode '11': apply Z then X to qubit 0",
+            100: "Z 0",
+            110: "X 0",
+            120: "REM Decode: reverse Bell circuit",
+            130: "CX 0,1",
+            140: "H 0",
+            150: "MEASURE",
+        }
+        self.io.writeln("LOADED: Superdense Coding (message='11')")
+        self.io.writeln("  Expect: |11> with high probability")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_random(self):
+        self.cmd_new()
+        n = min(self.num_qubits, 8)
+        self.num_qubits = n
+        self.shots = 1
+        self.program = {
+            10: "REM === Quantum Random Number Generator ===",
+            20: f"REM {n} qubits = {n}-bit truly random number",
+            30: "REM (as random as a simulator's PRNG allows)",
+        }
+        line = 40
+        for i in range(n):
+            self.program[line] = f"H {i}"
+            line += 10
+        self.program[line] = "MEASURE"
+        self.io.writeln(f"LOADED: Quantum RNG ({n} bits)")
+        self.cmd_list()
+        self.cmd_run()
+        self.shots = 1024
+
+    def _demo_stress(self):
+        self.cmd_new()
+        n = 20
+        self.num_qubits = n
+        self.program = {
+            10: f"REM === {n}-Qubit Stress Test ===",
+            20: f"REM H on all {n} qubits + nearest-neighbor CX chain",
+            30: f"REM Creates a highly entangled {n}-qubit state",
+        }
+        line = 40
+        for i in range(n):
+            self.program[line] = f"H {i}"
+            line += 10
+        for i in range(n - 1):
+            self.program[line] = f"CX {i},{i+1}"
+            line += 10
+        for i in range(n):
+            self.program[line] = f"RZ PI/4,{i}"
+            line += 10
+        for i in range(0, n - 1, 2):
+            self.program[line] = f"CX {i},{i+1}"
+            line += 10
+        self.program[line] = "MEASURE"
+        self.io.writeln(f"LOADED: {n}-Qubit Stress Test")
+        self.cmd_run()
+
+    def _demo_locc_teleport(self):
+        """Quantum teleportation across A/B boundary (JOINT mode)."""
+        self.cmd_new()
+        self.cmd_locc('JOINT 3 3')
+        self.shots = 1024
+        self.program = {
+            10:  "REM === LOCC Teleportation ===",
+            20:  "REM Alice (A) teleports qubit 0 to Bob (B) qubit 0",
+            30:  "REM Pre-shared Bell pair: A[2] <-> B[0]",
+            40:  "REM",
+            50:  "REM Prepare state to teleport: |+> on A[0]",
+            60:  "@A H 0",
+            70:  "REM Create shared entanglement",
+            80:  "SHARE A 2, B 0",
+            90:  "REM",
+            100: "REM === Teleportation protocol ===",
+            110: "REM Alice entangles her data qubit with her half of the pair",
+            120: "@A CX 0, 2",
+            130: "@A H 0",
+            140: "REM Alice measures and sends classical bits to Bob",
+            150: "SEND A 0 -> m0",
+            160: "SEND A 2 -> m1",
+            170: "REM Bob applies corrections based on Alice's results",
+            180: "IF m1 THEN @B X 0",
+            190: "IF m0 THEN @B Z 0",
+            200: "REM Bob's qubit 0 now holds Alice's original state",
+            210: "MEASURE",
+        }
+        self.io.writeln("LOADED: LOCC Teleportation (JOINT 3+3)")
+        self.io.writeln("  Alice sends |+> to Bob. Expect Bob's qubit ~ 50/50.")
+        self.cmd_list()
+        self.cmd_run()
+
+    def _demo_locc_coord(self):
+        """Classical coordination between independent registers (SPLIT mode)."""
+        self.cmd_new()
+        self.cmd_locc('SPLIT 4 4')
+        self.shots = 1024
+        self.program = {
+            10:  "REM === LOCC Classical Coordination ===",
+            20:  "REM Two independent quantum processors sharing classical bits",
+            30:  "REM Alice generates a random 2-bit key, Bob copies it",
+            40:  "REM",
+            50:  "REM Alice: generate random bits",
+            60:  "@A H 0 : @A H 1",
+            70:  "SEND A 0 -> k0",
+            80:  "SEND A 1 -> k1",
+            90:  "REM Bob: set qubits to match Alice's key",
+            100: "IF k0 THEN @B X 0",
+            110: "IF k1 THEN @B X 1",
+            120: "REM Both sides now agree on a 2-bit key",
+            130: "REM Alice uses her key to prepare an entangled state",
+            140: "@A H 2",
+            150: "@A CX 2,3",
+            160: "REM Bob does the same — they independently create matching states",
+            170: "@B H 2",
+            180: "@B CX 2,3",
+            190: "MEASURE",
+        }
+        self.io.writeln("LOADED: LOCC Classical Coordination (SPLIT 4+4)")
+        self.io.writeln("  Alice and Bob share a random key, then prepare matching states.")
+        self.cmd_list()
+        self.cmd_run()
+