qubasic 0.6.3__tar.gz → 0.6.5__tar.gz

{qubasic-0.6.3 → qubasic-0.6.5}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.5 (2026-06-19)
+
+### Fixed
+- The Bloch sphere Y component had an inverted sign, so a qubit in |+i> was reported at -Y (and |-i> at +Y). `BLOCH`, `DRAW`, `PRINT QUBIT(n)`, and the memory-mapped Bloch-Y field (`$0100 + q*8 + 2`) were all affected, and `BLOCH` mislabeled |+i> as "|-i>". X and Z were already correct. Y now matches the standard convention (`<Y> = +2 Im(<1|rho|0>)`), verified against Qiskit expectation values.
+
+## 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

{qubasic-0.6.3/qubasic.egg-info → qubasic-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.3
+Version: 0.6.5
 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.3 → qubasic-0.6.5}/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.3 → qubasic-0.6.5}/pyproject.toml

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

{qubasic-0.6.3 → qubasic-0.6.5/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.3
+Version: 0.6.5
 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.3 → qubasic-0.6.5}/qubasic_core/__init__.py

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

{qubasic-0.6.3 → qubasic-0.6.5}/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.3 → qubasic-0.6.5}/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:

{qubasic-0.6.3 → qubasic-0.6.5}/qubasic_core/display.py

@@ -292,10 +292,12 @@ class DisplayMixin:
 
         rho_00 = np.sum(np.abs(t0)**2)
         rho_11 = np.sum(np.abs(t1)**2)
-        rho_01 = np.sum(np.conj(t0) * t1)
+        # conj(t0)*t1 sums to rho_10 = <1|rho|0>. <X> = 2 Re(rho_10) (Re is
+        # symmetric in rho_01/rho_10), and <Y> = -2 Im(rho_01) = +2 Im(rho_10).
+        rho_10 = np.sum(np.conj(t0) * t1)
 
-        x = float(2 * rho_01.real)
-        y = float(-2 * rho_01.imag)
+        x = float(2 * rho_10.real)
+        y = float(2 * rho_10.imag)
         z = float(rho_00 - rho_11)
 
         return x, y, z

{qubasic-0.6.3 → qubasic-0.6.5}/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):
@@ -685,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.3 → qubasic-0.6.5}/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.3 → qubasic-0.6.5}/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.3 → qubasic-0.6.5}/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.3 → qubasic-0.6.5}/qubasic_core/memory.py

@@ -112,17 +112,19 @@ class MemoryMixin:
         t0, t1 = t[0].flatten(), t[1].flatten()
         rho_00 = float(np.sum(np.abs(t0) ** 2))
         rho_11 = float(np.sum(np.abs(t1) ** 2))
-        rho_01 = complex(np.sum(np.conj(t0) * t1))
+        # conj(t0)*t1 sums to rho_10 = <1|rho|0>. Bloch X = 2 Re(rho_10) and
+        # Bloch Y = -2 Im(rho_01) = +2 Im(rho_10).
+        rho_10 = complex(np.sum(np.conj(t0) * t1))
         # Recover amplitudes with alpha as the real phase reference; beta then
         # carries the relative phase (real and imaginary parts both exposed).
         alpha = np.sqrt(max(0.0, rho_00))
         if alpha > 1e-12:
-            beta = rho_01 / alpha
+            beta = rho_10 / alpha
         else:
             beta = complex(np.sqrt(max(0.0, rho_11)))
         return [rho_11,
-                float(2 * rho_01.real),
-                float(-2 * rho_01.imag),
+                float(2 * rho_10.real),
+                float(2 * rho_10.imag),
                 float(rho_00 - rho_11),
                 float(alpha),
                 0.0,

{qubasic-0.6.3 → qubasic-0.6.5}/qubasic_core/terminal.py

@@ -928,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>")

{qubasic-0.6.3 → qubasic-0.6.5}/tests/test_features.py

@@ -2595,6 +2595,31 @@ class TestCommandSurfaceCoverage(unittest.TestCase):
         self.assertIsInstance(t._status_prompt(), str)
         capture(t._suggest_command, 'XYZ')
 
+    def test_bloch_vector_axes(self):
+        """_bloch_vector and the $0100 By field carry the right sign on every
+        axis. Regression: the Y component was inverted (|+i> read as -Y)."""
+        import numpy as np
+        from qubasic_core.terminal import QBasicTerminal
+        t = QBasicTerminal()
+        r2 = 1.0 / np.sqrt(2)
+        cases = [
+            (np.array([1, 0], dtype=complex),       (0.0, 0.0, +1.0)),   # |0>  +Z
+            (np.array([0, 1], dtype=complex),       (0.0, 0.0, -1.0)),   # |1>  -Z
+            (np.array([r2, r2], dtype=complex),     (+1.0, 0.0, 0.0)),   # |+>  +X
+            (np.array([r2, -r2], dtype=complex),    (-1.0, 0.0, 0.0)),   # |->  -X
+            (np.array([r2, 1j * r2], dtype=complex),  (0.0, +1.0, 0.0)), # |+i> +Y
+            (np.array([r2, -1j * r2], dtype=complex), (0.0, -1.0, 0.0)), # |-i> -Y
+        ]
+        for sv, (ex, ey, ez) in cases:
+            x, y, z = t._bloch_vector(sv, 0, 1)
+            self.assertAlmostEqual(x, ex, places=6)
+            self.assertAlmostEqual(y, ey, places=6)
+            self.assertAlmostEqual(z, ez, places=6)
+        # Memory-mapped Bloch Y for q0 ($0102) must agree for |+i>.
+        t.num_qubits = 1
+        t.last_sv = np.array([r2, 1j * r2], dtype=complex)
+        self.assertAlmostEqual(t._peek(0x0102), +1.0, places=6)
+
     def test_program_and_io_surface(self):
         import builtins
         t = self._ready()