qubasic 0.6.1__tar.gz → 0.6.4__tar.gz

{qubasic-0.6.1 → qubasic-0.6.4}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.6.4 (2026-06-19)
+
+### Fixed
+- Immediate-mode `PRINT` at the REPL no longer prints a spurious statevector after its output. `PRINT` is not a dispatch-table command, so it fell through to the immediate gate path, which always dumped `|psi>`. That path now skips the dump when the typed line added no circuit operations, so gate and subroutine entries still show state while `PRINT`, `MEASURE`, and other classical statements do not.
+- `--quiet` now prints results with the banner suppressed, as documented. The results branch was unreachable (guarded by `elif not quiet` inside an `if quiet or json_mode` block), so `--quiet` previously produced no output at all.
+- A `MEASURE` reachable only inside a `DEF`/`SUB` body, an `IF ... THEN/ELSE` clause, or a colon compound is now detected, so the program takes the shots path (and `qubasic script.qb` auto-runs) instead of the no-measure statevector path.
+- `LET m(i, j) = x` writes a multi-dimensional array element using the same flat-stride convention the expression-side accessor reads, so multi-dimensional reads and writes agree.
+- Immediate-mode `LET a(i) = <expr>` at the REPL assigns the array element, matching the in-program `LET` (previously only the in-program form handled array targets).
+
+## 0.6.3 (2026-06-18)
+
+### Fixed
+- Colon-compound `@register` lines in LOCC mode now apply every gate. `@A H 0 : @A CX 0,1` (and the inherited form `@A H 0 : CX 0,1`) were captured as a single statement and mis-tokenized, so all but the first gate were silently dropped. The parser now splits them into per-statement parts with register inheritance, and the immediate-mode REPL path does the same.
+- `SAVE_EXPECT`, `SAVE_PROBS`, and `SAVE_AMPS` no longer overwrite their target variable with 0 at circuit-build time. The placeholder keeps any prior value, so a program that re-runs with the SAVE line still present can read the previous result during the build pass (the post-run extraction then fills in the fresh value).
+- `PRINT` honors `;` and `,` between multiple items: `PRINT "S ="; x` concatenates and `PRINT a, b` advances to the next 14-column zone. Separators inside quoted strings and inside call parentheses (`PRINT LEFT$(s$, 3)`) are no longer treated as item breaks.
+- `PRINT` variable substitution no longer rewrites identifiers inside quoted string literals, so a label such as `PRINT "value of S"` is emitted verbatim even when `S` is a defined variable.
+
+## 0.6.2 (2026-06-18)
+
+### Fixed
+- Changing the qubit count after a run (via `QUBITS n` or `POKE $D000`) now invalidates the cached statevector, so `MAP`, a `PEEK` of the qubit-state block, and `BLOCH` no longer reshape a stale statevector to the new qubit count and crash.
+
 ## 0.6.1 (2026-06-18)
 
 ### Fixed

{qubasic-0.6.1/qubasic.egg-info → qubasic-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.1
+Version: 0.6.4
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -661,7 +661,7 @@ QBASIC detects available RAM, estimates per-instance memory, and reports maximum
 ### Simulation method selection
 - **automatic**: stabilizer for Clifford-only circuits, MPS for >28 qubits, statevector otherwise
 - **stabilizer**: polynomial-time for Clifford circuits (H, S, CX, SWAP, etc.)
-- **matrix_product_state**: scales to 50+ qubits for low-entanglement circuits
+- **matrix_product_state**: memory-efficient for low-entanglement circuits; handles the full 32-qubit range that would exhaust statevector
 - **extended_stabilizer**: approximate simulation for near-Clifford circuits
 - **statevector**: exact, limited by RAM (~28 qubits on 16GB)
 - **density_matrix**: includes mixed states, ~14 qubits on 16GB

{qubasic-0.6.1 → qubasic-0.6.4}/README.md

@@ -628,7 +628,7 @@ QBASIC detects available RAM, estimates per-instance memory, and reports maximum
 ### Simulation method selection
 - **automatic**: stabilizer for Clifford-only circuits, MPS for >28 qubits, statevector otherwise
 - **stabilizer**: polynomial-time for Clifford circuits (H, S, CX, SWAP, etc.)
-- **matrix_product_state**: scales to 50+ qubits for low-entanglement circuits
+- **matrix_product_state**: memory-efficient for low-entanglement circuits; handles the full 32-qubit range that would exhaust statevector
 - **extended_stabilizer**: approximate simulation for near-Clifford circuits
 - **statevector**: exact, limited by RAM (~28 qubits on 16GB)
 - **density_matrix**: includes mixed states, ~14 qubits on 16GB

{qubasic-0.6.1 → qubasic-0.6.4}/pyproject.toml

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

{qubasic-0.6.1 → qubasic-0.6.4/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.1
+Version: 0.6.4
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -661,7 +661,7 @@ QBASIC detects available RAM, estimates per-instance memory, and reports maximum
 ### Simulation method selection
 - **automatic**: stabilizer for Clifford-only circuits, MPS for >28 qubits, statevector otherwise
 - **stabilizer**: polynomial-time for Clifford circuits (H, S, CX, SWAP, etc.)
-- **matrix_product_state**: scales to 50+ qubits for low-entanglement circuits
+- **matrix_product_state**: memory-efficient for low-entanglement circuits; handles the full 32-qubit range that would exhaust statevector
 - **extended_stabilizer**: approximate simulation for near-Clifford circuits
 - **statevector**: exact, limited by RAM (~28 qubits on 16GB)
 - **density_matrix**: includes mixed states, ~14 qubits on 16GB

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/__init__.py

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

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/cli.py

@@ -38,12 +38,8 @@ def run_script(path: str, terminal: 'QBasicTerminal') -> None:
     ProgramMgmtMixin._load_lines_with_defs(
         lines, lambda line: terminal.process(line, track_undo=False))
 
-    # Auto-run if the program has a MEASURE statement
-    has_measure = any(
-        terminal.program.get(ln, '').strip().upper() == 'MEASURE'
-        for ln in terminal.program
-    )
-    if terminal.program and has_measure:
+    # Auto-run if the program has a reachable MEASURE (incl. in subs / IF clauses)
+    if terminal.program and terminal._program_has_measure(sorted(terminal.program)):
         terminal.cmd_run()
 
 
@@ -125,8 +121,12 @@ def main():
                     print(_json.dumps({'error': err}, indent=2))
                     sys.exit(1)
                 print(_json.dumps(term.result(), indent=2))
-            elif not quiet:
-                print(buf.getvalue())
+            else:
+                # --quiet (no --json): the banner was never emitted into the
+                # buffer (only the non-captured path calls print_banner), so the
+                # captured text is exactly the results. Print them, matching the
+                # documented "suppress banner, output results only" behavior.
+                print(buf.getvalue(), end='')
                 if err is not None:
                     print(f"?ERROR: {err}")
                     sys.exit(1)
@@ -134,9 +134,8 @@ def main():
             term.print_banner()
             run_script(path, term)
         # Exit 0 on success; 1 if a measured program produced no counts.
-        sys.exit(0 if term.last_counts is not None or not any(
-            term.program.get(ln, '').strip().upper() == 'MEASURE'
-            for ln in term.program) else 1)
+        expects_measure = bool(term.program) and term._program_has_measure(sorted(term.program))
+        sys.exit(0 if term.last_counts is not None or not expects_measure else 1)
     else:
         term.repl()
 

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/control_flow.py

@@ -40,12 +40,60 @@ class ControlFlowMixin:
     # signature for compatibility with _exec_control_flow's argument
     # passing but is not used by the methods themselves.
 
+    @staticmethod
+    def _split_arg_list(s: str) -> list[str]:
+        """Split a comma list at top level (outside quotes and brackets)."""
+        parts: list[str] = []
+        buf = ''
+        depth = 0
+        quote: str | None = None
+        for ch in s:
+            if quote:
+                buf += ch
+                if ch == quote:
+                    quote = None
+            elif ch in ('"', "'"):
+                quote = ch
+                buf += ch
+            elif ch in '([':
+                depth += 1
+                buf += ch
+            elif ch in ')]':
+                depth = max(0, depth - 1)
+                buf += ch
+            elif ch == ',' and depth == 0:
+                parts.append(buf)
+                buf = ''
+            else:
+                buf += ch
+        if buf.strip():
+            parts.append(buf)
+        return [p.strip() for p in parts if p.strip()]
+
     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
         base = getattr(self, '_option_base', 0)
-        idx = int(self._eval_with_vars(idx_expr, run_vars)) - base
         val = self._eval_with_vars(val_expr, run_vars)
+        parts = self._split_arg_list(idx_expr)
+        if len(parts) > 1:
+            # Multi-dimensional write: flatten with the same stride convention
+            # the expression-side accessor uses, so reads and writes agree.
+            dims = getattr(self, '_array_dims', {}).get(name)
+            indices = [int(self._eval_with_vars(p, run_vars)) - base for p in parts]
+            if any(i < 0 for i in indices):
+                raise RuntimeError(f"ARRAY INDEX OUT OF RANGE: {name}({idx_expr})")
+            flat, stride = 0, 1
+            for k in range(len(indices) - 1, -1, -1):
+                flat += indices[k] * stride
+                stride *= dims[k] if dims and k < len(dims) else 1
+            if name not in self.arrays:
+                raise RuntimeError(f"ARRAY NOT DIMENSIONED: {name} (use DIM first)")
+            if flat < 0 or flat >= len(self.arrays[name]):
+                raise RuntimeError(f"ARRAY INDEX OUT OF RANGE: {name}({idx_expr})")
+            self.arrays[name][flat] = val
+            return True, ExecResult.ADVANCE
+        idx = int(self._eval_with_vars(idx_expr, run_vars)) - base
         if idx < 0:
             raise RuntimeError(f"ARRAY INDEX OUT OF RANGE: {name}({idx + base})")
         if name not in self.arrays:
@@ -63,46 +111,86 @@ class ControlFlowMixin:
         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:
+    @staticmethod
+    def _split_print_items(expr: str) -> list[tuple[str, str]]:
+        """Split a PRINT argument list into (item, trailing-separator) pairs.
+
+        ';' and ',' are recognized only at top level (outside quotes and
+        parentheses/brackets), so PRINT LEFT$(s$, 3) stays one item and a comma
+        inside a quoted literal is preserved. The separator recorded with each
+        item is the one that follows it; '' marks the final item / no trailing
+        separator.
+        """
+        items: list[tuple[str, str]] = []
+        buf = ''
+        depth = 0
+        quote: str | None = None
+        for ch in expr:
+            if quote:
+                buf += ch
+                if ch == quote:
+                    quote = None
+            elif ch in ('"', "'"):
+                quote = ch
+                buf += ch
+            elif ch in '([':
+                depth += 1
+                buf += ch
+            elif ch in ')]':
+                depth = max(0, depth - 1)
+                buf += ch
+            elif ch in ';,' and depth == 0:
+                items.append((buf.strip(), ch))
+                buf = ''
+            else:
+                buf += ch
+        if buf.strip():
+            items.append((buf.strip(), ''))
+        return items
+
+    def _eval_print_item(self, item: str, run_vars: dict[str, Any]) -> str:
+        """Evaluate a single PRINT item to its display string."""
+        item = item.strip()
+        if not item:
+            return ''
+        # Quoted literal: emit verbatim (no substitution, no SPC/TAB).
+        if (item[0] == '"' and item[-1] == '"') or (item[0] == "'" and item[-1] == "'"):
+            return item[1:-1]
+        text = self._substitute_vars(item, run_vars)
+
+        def _spaces(m):
             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)
+                return ' ' * max(0, int(self._eval_with_vars(m.group(1), run_vars)))
             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)
+                return ''
+        text = re.sub(r'\bSPC\s*\(([^)]+)\)', _spaces, text, flags=re.IGNORECASE)
+        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
+
+    def _cf_print(self, stmt: str, run_vars: dict[str, Any],
+                  parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
+        items = self._split_print_items(parsed.expr)
+        if not items:
+            self.io.writeln('')             # bare PRINT -> blank line
+            return True, ExecResult.ADVANCE
+        out = ''
+        for item, sep in items:
+            out += self._eval_print_item(item, run_vars)
+            if sep == ',':                  # advance to next 14-column zone
+                col = len(out) % 14
+                out += ' ' * (14 - col if col else 14)
+        # A trailing ';' or ',' suppresses the newline (cursor stays on line).
+        if items[-1][1] in (';', ','):
+            self.io.write(out)
         else:
-            self.io.writeln(output)
+            self.io.writeln(out)
         return True, ExecResult.ADVANCE
 
     def _cf_goto(self, stmt: str, sorted_lines: list[int],

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/engine_state.py

@@ -119,3 +119,17 @@ class Engine:
         self._circuit_cache = None
         self._pending_set_state = None
         self._poke_state_prep = {}
+
+    def _invalidate_run_state(self) -> None:
+        """Drop cached results that describe a now-stale configuration.
+
+        Called when the qubit count changes: last_sv, last_counts,
+        last_circuit, and the transpile cache all assume the previous
+        num_qubits, so reading them afterwards would mislabel (or, for
+        the reshape in _peek_qubit/_bloch_vector, crash) the state.
+        """
+        self.last_counts = None
+        self.last_sv = None
+        self.last_circuit = None
+        self._circuit_cache_key = None
+        self._circuit_cache = None

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/executor.py

@@ -66,6 +66,41 @@ class ExecutorMixin:
 
     # ── Circuit Building ──────────────────────────────────────────────
 
+    def _program_has_measure(self, sorted_lines) -> bool:
+        """True if any reachable statement measures.
+
+        The plain per-line scan misses a MEASURE that only appears inside a DEF
+        subroutine body or an IF/THEN-ELSE clause, which left the run on the
+        no-measure path with no counts. This recursion-guarded walk follows
+        colon compounds, IF clauses, and subroutine bodies so the shots path
+        fires whenever a measurement is actually reachable.
+        """
+        from qubasic_core.statements import MeasureStmt, CompoundStmt, IfThenStmt
+        from qubasic_core.parser import parse_stmt
+
+        def scan(text: str, seen: frozenset) -> bool:
+            p = parse_stmt(text)
+            if isinstance(p, MeasureStmt):
+                return True
+            if isinstance(p, CompoundStmt):
+                return any(scan(part, seen) for part in p.parts)
+            if isinstance(p, IfThenStmt):
+                if p.then_clause and scan(p.then_clause, seen):
+                    return True
+                if p.else_clause and scan(p.else_clause, seen):
+                    return True
+                return False
+            words = text.strip().split()
+            if words:
+                word = words[0].upper().split('(')[0]
+                if word in self.subroutines and word not in seen:
+                    sub = self.subroutines[word]
+                    body = sub['body'] if isinstance(sub, dict) else sub
+                    return any(scan(b, seen | {word}) for b in body)
+            return False
+
+        return any(scan(self.program[ln], frozenset()) for ln in sorted_lines)
+
     def build_circuit(self) -> tuple['QuantumCircuit', bool]:
         """Compile program lines into a QuantumCircuit. Returns (circuit, has_measure)."""
         from qubasic_core.exec_context import ExecContext
@@ -92,7 +127,9 @@ class ExecutorMixin:
             qc=qc,
             backend=backend,
         )
-        has_measure = False
+        # Reachability scan catches MEASURE inside subroutines and IF clauses,
+        # not just literal top-level MEASURE lines.
+        has_measure = self._program_has_measure(ctx.sorted_lines)
         self._on_measure_fired = False
 
         while ctx.ip < len(ctx.sorted_lines):
@@ -328,20 +365,42 @@ class ExecutorMixin:
             set(self.subroutines.keys()) |
             set(self._custom_gates.keys())
         )
-        # Tokenize: split on word boundaries, preserving delimiters
-        tokens = re.split(r'(\b\w+\b)', stmt)
-        for i, tok in enumerate(tokens):
-            if not tok or not tok[0].isalpha():
-                continue
-            if tok in protected or tok.upper() in protected or tok.lower() in protected:
-                continue
-            if tok in merged:
-                # Don't expand record bases (dicts) — leave p in p.x intact so
-                # the expression evaluator can resolve the field.
-                if isinstance(merged[tok], dict):
+
+        def _sub_segment(seg: str) -> str:
+            # Tokenize: split on word boundaries, preserving delimiters
+            tokens = re.split(r'(\b\w+\b)', seg)
+            for i, tok in enumerate(tokens):
+                if not tok or not tok[0].isalpha():
                     continue
-                tokens[i] = str(merged[tok])
-        return ''.join(tokens)
+                if tok in protected or tok.upper() in protected or tok.lower() in protected:
+                    continue
+                if tok in merged:
+                    # Don't expand record bases (dicts) — leave p in p.x intact
+                    # so the expression evaluator can resolve the field.
+                    if isinstance(merged[tok], dict):
+                        continue
+                    tokens[i] = str(merged[tok])
+            return ''.join(tokens)
+
+        # Substitute only outside quoted string literals: a variable named in a
+        # PRINT label (PRINT "S ="; S) must survive verbatim inside the quotes.
+        out: list[str] = []
+        i, n = 0, len(stmt)
+        while i < n:
+            ch = stmt[i]
+            if ch in ('"', "'"):
+                j = i + 1
+                while j < n and stmt[j] != ch:
+                    j += 1
+                out.append(stmt[i:j + 1])           # quoted span, verbatim
+                i = j + 1
+            else:
+                j = i
+                while j < n and stmt[j] not in ('"', "'"):
+                    j += 1
+                out.append(_sub_segment(stmt[i:j]))  # unquoted span
+                i = j
+        return ''.join(out)
 
     def _expand_statement(self, stmt, _call_stack: set[str] | None = None):
         """Expand subroutines. Returns list of gate strings.
@@ -636,18 +695,24 @@ class ExecutorMixin:
 
         Uses the same _exec_line pipeline as cmd_run for consistency.
         """
-        # In LOCC mode, handle @register prefix via the numpy engine
-        if self.locc_mode and self.locc:
-            m = RE_AT_REG_LINE.match(line)
-            if m:
+        # In LOCC mode, handle @register prefix via the numpy engine. Split
+        # colon-compound @REG lines so each gate is applied (a single @REG line
+        # is just the one-part case); a bare @REG line keeps prior behavior.
+        if self.locc_mode and self.locc and line.strip().startswith('@'):
+            parts = self._split_colon_stmts(line) if ':' in line else [line.strip()]
+            for part in parts:
+                m = RE_AT_REG_LINE.match(part)
+                if not m:
+                    self.io.writeln(f"?BAD @register statement: {part}")
+                    continue
                 reg = m.group(1).upper()
                 gate_stmt = m.group(2).strip()
                 if reg not in self.locc.names:
                     self.io.writeln(f"?UNKNOWN REGISTER: {reg} (have {', '.join(self.locc.names)})")
                     return
                 self._locc_apply_gate(reg, gate_stmt)
-                self._locc_state()
-                return
+            self._locc_state()
+            return
         if line.strip().startswith('@'):
             self.io.writeln("?@register syntax requires LOCC mode (try: LOCC <n1> <n2>)")
             return
@@ -657,6 +722,12 @@ class ExecutorMixin:
         imm_ctx = ExecContext(sorted_lines=[0], ip=0,
                               run_vars=dict(self.variables), qc=qc)
         self._exec_line(line, ctx=imm_ctx)
+        # A classical statement typed at the prompt (PRINT, MEASURE, an IF whose
+        # clause printed, ...) adds no circuit operations and has already emitted
+        # its own output via _exec_line. Simulating an empty circuit just to print
+        # an unchanged |psi> would be spurious, so skip the statevector dump.
+        if qc.size() == 0:
+            return
         qc.save_statevector()
         backend = self._make_backend('statevector')
         result = backend.run(transpile(qc, backend)).result()

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/file_io.py

@@ -195,8 +195,6 @@ class FileIOMixin:
         DEFs in the imported file are prefixed with the module name.
         E.g., IMPORT "math.qb" makes DEF ROT available as MATH.ROT.
         """
-        from qubasic_core.engine import RE_IMPORT
-        m = RE_IMPORT.match(f"IMPORT {rest}") if not rest.startswith('IMPORT') else RE_IMPORT.match(rest)
         path = rest.strip().strip('"').strip("'")
         if not path:
             self.io.writeln('?USAGE: IMPORT "filename"')

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/locc_engine.py

@@ -180,7 +180,13 @@ class LOCCEngine:
                 self._renormalize(reg)
 
     def apply(self, reg: str, gate_name: str, params: tuple[float, ...], qubits: list[int]) -> None:
-        """Apply a gate to a specific register, then apply noise if configured."""
+        """Apply a gate to a register, then apply noise if configured.
+
+        Qubit indices are register-LOCAL (0..size-1); the register offset into
+        the joint statevector is added internally. Callers that index the raw
+        statevector (e.g. for fidelity/inspection) must convert with
+        ``offsets[reg] + local`` themselves.
+        """
         self._check_qubits(reg, qubits)
         matrix = _np_gate_matrix(gate_name, tuple(params))
         if self.joint:
@@ -194,7 +200,10 @@ class LOCCEngine:
         self._contiguate(reg)
 
     def share(self, reg1: str, q1: int, reg2: str, q2: int) -> None:
-        """Create Bell pair |Phi+> between reg1[q1] and reg2[q2]. JOINT only."""
+        """Create Bell pair |Phi+> between reg1[q1] and reg2[q2]. JOINT only.
+
+        ``q1``/``q2`` are register-LOCAL indices; offsets are added internally.
+        """
         if not self.joint:
             raise RuntimeError("SHARE requires LOCC JOINT mode")
         self._check_qubits(reg1, [q1])
@@ -210,7 +219,10 @@ class LOCCEngine:
         self._apply_noise(reg2, [q2])
 
     def send(self, reg: str, qubit: int) -> int:
-        """Measure a qubit (Born rule) and return the classical outcome."""
+        """Measure a qubit (Born rule) and return the classical outcome.
+
+        ``qubit`` is register-LOCAL (0..size-1); the offset is added internally.
+        """
         self._check_qubits(reg, [qubit])
         if self.joint:
             actual = qubit + self.offsets[self._idx(reg)]
@@ -266,7 +278,10 @@ class LOCCEngine:
             return per_reg, {}
 
     def apply_matrix(self, reg: str, matrix: np.ndarray, qubits: list[int]) -> None:
-        """Apply a raw unitary matrix to qubits in a register."""
+        """Apply a raw unitary matrix to qubits in a register.
+
+        ``qubits`` are register-LOCAL indices; offsets are added internally.
+        """
         self._check_qubits(reg, qubits)
         if self.joint:
             idx = self._idx(reg)

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/locc_execution.py

@@ -33,8 +33,7 @@ class LOCCExecutionMixin:
         if not sorted_lines:
             self.io.writeln("NOTHING TO RUN")
             return
-        has_measure = any(self.program[l].strip().upper() == 'MEASURE'
-                         for l in sorted_lines)
+        has_measure = self._program_has_measure(sorted_lines)
         has_send = any(re.search(r'\bSEND\b', self.program[l], re.IGNORECASE)
                        for l in sorted_lines)
         if has_send:

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/memory.py

@@ -103,7 +103,10 @@ class MemoryMixin:
         qubit, field = off // QUBIT_BLOCK, off % QUBIT_BLOCK
         if self.last_sv is None or qubit >= self.num_qubits:
             return 0.0
-        sv = np.ascontiguousarray(self.last_sv).ravel().reshape([2] * self.num_qubits)
+        sv_flat = np.ascontiguousarray(self.last_sv).ravel()
+        if sv_flat.size != 2 ** self.num_qubits:
+            return 0.0  # stale statevector from a different qubit count
+        sv = sv_flat.reshape([2] * self.num_qubits)
         ax = self.num_qubits - 1 - qubit
         t = np.moveaxis(sv, ax, 0)
         t0, t1 = t[0].flatten(), t[1].flatten()
@@ -155,7 +158,10 @@ class MemoryMixin:
             self._zero_page[a] = v
             return
         if a == 0xD000:
-            self.num_qubits = max(1, min(32, int(v)))
+            new_n = max(1, min(32, int(v)))
+            if new_n != self.num_qubits:
+                self._invalidate_run_state()
+            self.num_qubits = new_n
         elif a == 0xD001:
             self.shots = max(1, int(v))
         elif a == 0xD002:

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/parser.py

@@ -554,6 +554,14 @@ def parse_stmt(raw: str) -> Stmt:
 
     # ── @REG lines ────────────────────────────────────────────────
     if text.startswith('@'):
+        # A colon-compound @REG line (e.g. "@A H 0 : @A CX 0,1" or
+        # "@A H 0 : CX 0,1") must split into per-statement parts with
+        # @register inheritance; otherwise the whole tail is captured as one
+        # AtRegStmt.inner and the LOCC executor mis-tokenizes it.
+        if ':' in text:
+            parts = _split_colon_stmts(text)
+            if len(parts) > 1:
+                return CompoundStmt(raw=raw, parts=tuple(parts))
         m = RE_AT_REG_LINE.match(text)
         if m:
             return AtRegStmt(raw=raw, reg=m.group(1).upper(),

{qubasic-0.6.1 → qubasic-0.6.4}/qubasic_core/terminal.py

@@ -571,6 +571,8 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             from qubasic_core.errors import QBasicRangeError
             raise QBasicRangeError(f"RANGE: 1-{MAX_QUBITS}")
 
+        if n != self.num_qubits:
+            self._invalidate_run_state()
         self.num_qubits = n
         self.registers.clear()
         est = _estimate_gb(n)
@@ -926,7 +928,18 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
 
     def cmd_let(self, rest: str) -> None:
         """LET <var> = <expr> — assign a computed value to a variable.
-        Supports record fields, e.g. LET p.x = 3.14 (see TYPE)."""
+        Supports record fields (LET p.x = 3.14) and array elements
+        (LET a(0) = PI, LET m(i, j) = x), matching the in-program LET."""
+        from qubasic_core.patterns import RE_LET_ARRAY
+        am = RE_LET_ARRAY.match(f"LET {rest}")
+        if am:
+            from qubasic_core.statements import LetArrayStmt
+            name, idx_expr, val_expr = am.group(1), am.group(2), am.group(3)
+            parsed = LetArrayStmt(raw=f"LET {rest}", name=name,
+                                  index_expr=idx_expr, value_expr=val_expr)
+            self._cf_let_array(f"LET {rest}", self.variables, parsed)
+            self.io.writeln(f"{name}({idx_expr.strip()}) = {self.eval_expr(val_expr)}")
+            return
         m = re.match(r'(\w+(?:\.\w+)?)\s*=\s*(.*)', rest)
         if not m:
             self.io.writeln("?USAGE: LET <var> = <expr>")
@@ -1980,8 +1993,13 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
                     full_pauli[self.num_qubits - 1 - qubits[i]] = p
             op = SparsePauliOp(''.join(full_pauli))
             qc.save_expectation_value(op, list(range(self.num_qubits)), label=f'exp_{var}')
-            run_vars[var] = 0  # actual value available after simulation
-            self.variables[var] = 0
+            # Placeholder until the run fills the real value via
+            # _extract_save_results. Preserve any prior value instead of
+            # zeroing it, so a re-run that re-includes this SAVE line leaves
+            # earlier results readable to LET/PRINT during the build pass.
+            _prev = self.variables.get(var, 0)
+            run_vars[var] = _prev
+            self.variables[var] = _prev
         except Exception as e:
             self.io.writeln(f"?SAVE_EXPECT ERROR: {e}")
         return True
@@ -1996,8 +2014,9 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         var = m.group(2)
         try:
             qc.save_probabilities(qubits, label=f'prob_{var}')
-            run_vars[var] = 0
-            self.variables[var] = 0
+            _prev = self.variables.get(var, 0)   # preserve prior value (see SAVE_EXPECT)
+            run_vars[var] = _prev
+            self.variables[var] = _prev
         except Exception as e:
             self.io.writeln(f"?SAVE_PROBS ERROR: {e}")
         return True
@@ -2012,8 +2031,9 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         var = m.group(2)
         try:
             qc.save_amplitudes(indices, label=f'amp_{var}')
-            run_vars[var] = 0
-            self.variables[var] = 0
+            _prev = self.variables.get(var, 0)   # preserve prior value (see SAVE_EXPECT)
+            run_vars[var] = _prev
+            self.variables[var] = _prev
         except Exception as e:
             self.io.writeln(f"?SAVE_AMPS ERROR: {e}")
         return True

{qubasic-0.6.1 → qubasic-0.6.4}/tests/test_features.py

@@ -359,6 +359,42 @@ class TestMemoryMap(unittest.TestCase):
         self.assertEqual(ntype, 2)
         self.assertAlmostEqual(nparam, 0.1)
 
+    def test_qubit_count_change_invalidates_stale_state(self):
+        """Changing the qubit count after a run must not leave a stale last_sv
+        that MAP/PEEK/BLOCH then reshape to the wrong size and crash."""
+        import numpy as np
+
+        # Run a 1-qubit circuit so last_sv has size 2.
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.process('10 H 0')
+        t.process('20 MEASURE')
+        capture(t.cmd_run)
+
+        # QUBITS grows the count: the size-2 statevector no longer applies.
+        capture(t.cmd_qubits, '2')
+        self.assertIsNone(t.last_sv)
+        self.assertIsNone(t._circuit_cache_key)
+        self.assertEqual(t._peek(0x0100), 0.0)   # would have crashed on reshape
+        capture(t.cmd_map)                        # MAP walks the qubit block
+        capture(t.cmd_bloch, '0')                 # BLOCH reshapes too
+
+        # The $D000 POKE path invalidates the same way.
+        t2 = QBasicTerminal()
+        t2.num_qubits = 1
+        t2.process('10 H 0')
+        t2.process('20 MEASURE')
+        capture(t2.cmd_run)
+        t2._poke(0xD000, 3)
+        self.assertIsNone(t2.last_sv)
+        self.assertEqual(t2._peek(0x0100), 0.0)
+
+        # Defensive guard: even a hand-set mismatched last_sv reads as 0, not a crash.
+        t3 = QBasicTerminal()
+        t3.num_qubits = 2
+        t3.last_sv = np.array([1.0, 0.0], dtype=complex)  # size 2, but 2 qubits
+        self.assertEqual(t3._peek(0x0100), 0.0)
+
     def test_sys(self):
         """SYS builtin BELL, SYS unmapped, SYS in program, SYS INSTALL."""
         # SYS 0xE000 BELL demo

{qubasic-0.6.1 → qubasic-0.6.4}/tests/test_qubasic.py

@@ -1432,6 +1432,92 @@ class TestAdditionalCoverage(unittest.TestCase):
         self.assertEqual(t4.last_counts.get('1', 0), 100)
 
 
+# ---------------------------------------------------------------------------
+# TestBugFixes063 — regressions fixed in 0.6.3
+# ---------------------------------------------------------------------------
+class TestBugFixes063(unittest.TestCase):
+    """Regression tests for the 0.6.3 fixes."""
+
+    def _ghz3(self):
+        v = np.zeros(8, dtype=complex)
+        v[0] = v[7] = 1 / np.sqrt(2)
+        return v
+
+    def test_locc_colon_compound_at_register(self):
+        """LOCC: colon-compound @REG lines apply every gate (explicit and inherited)."""
+        for line in ('@A H 0 : @A CX 0,1 : @A CX 0,2',   # explicit @A per clause
+                     '@A H 0 : CX 0,1 : CX 0,2'):         # @A inherited
+            t = QBasicTerminal()
+            t.locc = LOCCEngine([3], joint=True)
+            t.locc_mode = True
+            t.shots = 1
+            t.process(f'10 {line}', track_undo=False)
+            t.process('20 MEASURE', track_undo=False)
+            capture(t.cmd_run)
+            sv = np.ascontiguousarray(t.locc.sv).ravel()
+            fid = abs(np.vdot(self._ghz3(), sv)) ** 2
+            self.assertGreater(fid, 0.999, f"GHZ not built by: {line}")
+
+    def test_save_expect_preserved_across_rerun(self):
+        """SAVE_EXPECT keeps prior values on re-run instead of zeroing them."""
+        t = QBasicTerminal()
+        t.num_qubits = 2
+        t.shots = 64
+        t.process('10 H 0', track_undo=False)
+        t.process('20 CX 0,1', track_undo=False)
+        t.process('30 SAVE_EXPECT ZZ 0,1 -> zz', track_undo=False)
+        t.process('40 SAVE_EXPECT XX 0,1 -> xx', track_undo=False)
+        capture(t.cmd_run)
+        self.assertAlmostEqual(t.variables['zz'], 1.0, places=6)
+        self.assertAlmostEqual(t.variables['xx'], 1.0, places=6)
+        # A second run that still contains the SAVE lines must not zero zz/xx
+        # before the LET on line 50 reads them.
+        t.process('50 LET chsh = SQRT2 * (zz + xx)', track_undo=False)
+        capture(t.cmd_run)
+        self.assertAlmostEqual(t.variables['chsh'], 2 * math.sqrt(2), places=6)
+
+    def test_print_multi_item_separators(self):
+        """PRINT concatenates ';' items and tab-aligns ',' items."""
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.variables['S'] = 2.8284271247
+        t.process('10 PRINT "S ="; S', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('S =2.8284', out)
+
+        t2 = QBasicTerminal()
+        t2.num_qubits = 1
+        t2.process('10 PRINT "a", "b"', track_undo=False)
+        _, out2 = capture(t2.cmd_run)
+        line = next(l for l in out2.splitlines() if 'a' in l and 'b' in l)
+        self.assertGreaterEqual(line.index('b') - line.index('a'), 14)
+
+    def test_print_does_not_substitute_inside_quotes(self):
+        """A variable name inside a quoted PRINT literal is emitted verbatim."""
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.variables['S'] = 99.0
+        t.process('10 PRINT "value of S here"', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('value of S here', out)
+        self.assertNotIn('99', out)
+
+    def test_print_preserves_commas_in_quotes_and_calls(self):
+        """Top-level split skips commas inside quotes and inside call parens."""
+        t = QBasicTerminal()
+        t.num_qubits = 1
+        t.process('10 PRINT "x,y,z"', track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('x,y,z', out)
+
+        t2 = QBasicTerminal()
+        t2.num_qubits = 1
+        t2.process('10 LET name$ = "hello"', track_undo=False)
+        t2.process('20 PRINT LEFT$(name$, 3)', track_undo=False)
+        _, out2 = capture(t2.cmd_run)
+        self.assertIn('hel', out2)
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')