qubasic 0.10.1__tar.gz → 0.11.1__tar.gz

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

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.11.1 (2026-06-19)
+
+### Fixed
+- A configuration/session command (`QUBITS`, `SHOTS`, `METHOD`, `LOCC`, ...) placed on a numbered program line now reports a clear error explaining it must run without a line number (before `RUN`), instead of the misleading `UNKNOWN GATE`. Unnumbered config in a script was, and remains, the correct usage.
+
+## 0.11.0 (2026-06-19)
+
+Convention-conformance and observability pass: make the language behave the way
+a Qiskit/Python/BASIC user already expects, and make hidden state legible. The
+quantum engine is unchanged.
+
+### Added
+- `STATUS` (and `STATUS JSON`): dumps every active mode (qubits, shots, method, device, seed, `OPTION BASE`, LOCC mode, noise, coupling/basis, pending `SET_STATE`/`SET_DENSITY`, bank) so behavior can be read instead of inferred.
+- Implicit `LET`: a bare assignment works without the keyword (`x = 5`, `s$ = "hi"`, `a(1) = 5`), as in every BASIC.
+- `FIX(x)` truncates toward zero, complementing `INT`.
+- Histograms print a `q(n-1) ... q1 q0` bit-order header and the JSON result carries a `bit_order` field, making the little-endian convention (qubit 0 = rightmost) explicit.
+
+### Changed
+- `INT(x)` floors toward negative infinity (`INT(-3.2)` = -4), matching QBASIC; use `FIX` for truncation toward zero.
+- Built-in constants (`PI`, `E`, `TAU`, `SQRT2`) are reserved: a same-named variable can no longer silently shadow them, and assigning one is an error.
+- `MEAS` without a target bit reports a clear error distinguishing it from `MEASURE` (mid-circuit measurement into a classical bit vs collapse into the histogram) instead of `UNKNOWN GATE`.
+
 ## 0.10.1 (2026-06-19)
 
 Expression, string, and PRINT fixes in the classic-BASIC layer. The quantum

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.10.1
+Version: 0.11.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -209,6 +209,8 @@ QUBITS 8             Set qubit count (1-32)
 SHOTS 2048           Set measurement shots
 METHOD statevector   Set simulation method
 METHOD GPU           Set simulation device
+STATUS               Show every active mode (qubits, method, LOCC, noise, ...)
+STATUS JSON          Same, as machine-readable JSON
 ```
 
 ### Simulation methods
@@ -220,17 +222,19 @@ Automatic selection: stabilizer for Clifford-only circuits, MPS for >28 qubits,
 
 ```
 LET angle = PI/4
-LET x = sin(angle) * 2
+x = sin(angle) * 2       LET is optional (x = 5 also works)
 10 RX angle, 0           Use in gate parameters
 VARS                     List all variables
 CLEAR x                  Remove a variable
 ```
 
+Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
+
 ### Constants
-`PI`, `TAU`, `E`, `SQRT2`, `True`, `False`
+`PI`, `TAU`, `E`, `SQRT2`, `True`, `False` (reserved; not usable as variable names)
 
 ### Math functions
-`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int`, `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
+`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int` (floors), `fix` (truncates), `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
 
 ### Runtime functions
 `RND(x)` random, `TIMER` elapsed seconds, `FRE(0)` free RAM bytes, `POS(0)` cursor column, `PEEK(addr)` memory read, `USR(addr)` call routine
@@ -364,6 +368,8 @@ DECOMPOSE                Gate count breakdown
 DENSITY                  Density matrix
 ```
 
+Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

{qubasic-0.10.1 → qubasic-0.11.1}/README.md

@@ -176,6 +176,8 @@ QUBITS 8             Set qubit count (1-32)
 SHOTS 2048           Set measurement shots
 METHOD statevector   Set simulation method
 METHOD GPU           Set simulation device
+STATUS               Show every active mode (qubits, method, LOCC, noise, ...)
+STATUS JSON          Same, as machine-readable JSON
 ```
 
 ### Simulation methods
@@ -187,17 +189,19 @@ Automatic selection: stabilizer for Clifford-only circuits, MPS for >28 qubits,
 
 ```
 LET angle = PI/4
-LET x = sin(angle) * 2
+x = sin(angle) * 2       LET is optional (x = 5 also works)
 10 RX angle, 0           Use in gate parameters
 VARS                     List all variables
 CLEAR x                  Remove a variable
 ```
 
+Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
+
 ### Constants
-`PI`, `TAU`, `E`, `SQRT2`, `True`, `False`
+`PI`, `TAU`, `E`, `SQRT2`, `True`, `False` (reserved; not usable as variable names)
 
 ### Math functions
-`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int`, `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
+`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int` (floors), `fix` (truncates), `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
 
 ### Runtime functions
 `RND(x)` random, `TIMER` elapsed seconds, `FRE(0)` free RAM bytes, `POS(0)` cursor column, `PEEK(addr)` memory read, `USR(addr)` call routine
@@ -331,6 +335,8 @@ DECOMPOSE                Gate count breakdown
 DENSITY                  Density matrix
 ```
 
+Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

{qubasic-0.10.1 → qubasic-0.11.1}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.10.1
+Version: 0.11.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -209,6 +209,8 @@ QUBITS 8             Set qubit count (1-32)
 SHOTS 2048           Set measurement shots
 METHOD statevector   Set simulation method
 METHOD GPU           Set simulation device
+STATUS               Show every active mode (qubits, method, LOCC, noise, ...)
+STATUS JSON          Same, as machine-readable JSON
 ```
 
 ### Simulation methods
@@ -220,17 +222,19 @@ Automatic selection: stabilizer for Clifford-only circuits, MPS for >28 qubits,
 
 ```
 LET angle = PI/4
-LET x = sin(angle) * 2
+x = sin(angle) * 2       LET is optional (x = 5 also works)
 10 RX angle, 0           Use in gate parameters
 VARS                     List all variables
 CLEAR x                  Remove a variable
 ```
 
+Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
+
 ### Constants
-`PI`, `TAU`, `E`, `SQRT2`, `True`, `False`
+`PI`, `TAU`, `E`, `SQRT2`, `True`, `False` (reserved; not usable as variable names)
 
 ### Math functions
-`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int`, `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
+`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sqrt`, `log`, `exp`, `abs`, `int` (floors), `fix` (truncates), `float`, `min`, `max`, `round`, `ceil`, `floor`, `len`
 
 ### Runtime functions
 `RND(x)` random, `TIMER` elapsed seconds, `FRE(0)` free RAM bytes, `POS(0)` cursor column, `PEEK(addr)` memory read, `USR(addr)` call routine
@@ -364,6 +368,8 @@ DECOMPOSE                Gate count breakdown
 DENSITY                  Density matrix
 ```
 
+Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

{qubasic-0.10.1 → qubasic-0.11.1}/qubasic_core/__init__.py

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

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

@@ -73,6 +73,7 @@ class ControlFlowMixin:
     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
+        self._assert_assignable(name)
         base = getattr(self, '_option_base', 0)
         val = self._eval_with_vars(val_expr, run_vars)
         parts = self._split_arg_list(idx_expr)
@@ -106,6 +107,7 @@ class ControlFlowMixin:
     def _cf_let_var(self, stmt: str, run_vars: dict[str, Any],
                     parsed: LetStmt) -> tuple[bool, ExecOutcome]:
         name, expr = parsed.name, parsed.expr
+        self._assert_assignable(name)
         raw = self._safe_eval(expr, extra_ns=run_vars)
         if isinstance(raw, str):
             raise RuntimeError(

{qubasic-0.10.1 → qubasic-0.11.1}/qubasic_core/display.py

@@ -40,12 +40,33 @@ class DisplayMixin:
         Console(file=buf, highlight=False, force_terminal=force).print(*renderables)
         self.io.write(buf.getvalue())
 
+    def _bit_order_note(self, display: list) -> str | None:
+        """Human-facing reminder of which bit is which qubit.
+
+        Bitstrings are little-endian (qubit 0 is the rightmost character), the
+        most common source of off-by-reverse mistakes when reading a histogram.
+        When the result covers the whole register the positions are labelled
+        q(n-1) ... q1 q0; for a measured subset only the convention is shown.
+        """
+        if not display:
+            return None
+        nbits = len(display[0][0])
+        nq = getattr(self, 'num_qubits', nbits)
+        if nbits == nq and nbits <= 16:
+            labels = ' '.join(f'q{i}' for i in range(nbits - 1, -1, -1))
+            return f"  bit order  {labels}   (qubit 0 = rightmost)"
+        return "  bit order  qubit 0 = rightmost bit"
+
     def print_histogram(self, counts: dict[str, int]) -> None:
         """Measurement histogram with optional rich-table formatting."""
         total = sum(counts.values())
         sorted_counts = sorted(counts.items(), key=lambda x: -x[1])
         display = sorted_counts[:MAX_HISTOGRAM_STATES]
 
+        note = self._bit_order_note(display)
+        if note:
+            self.io.writeln(note)
+
         if _RICH:
             self._print_histogram_rich(display, sorted_counts, total)
         else:

{qubasic-0.10.1 → qubasic-0.11.1}/qubasic_core/executor.py

@@ -333,6 +333,19 @@ class ExecutorMixin:
                 return ExecResult.ADVANCE
             # Fall through to _apply_gate_str for custom gates not in GATE_TABLE
 
+        # A REPL/config command (QUBITS, SHOTS, METHOD, LOCC, ...) used as a
+        # numbered program line reaches here only because it is neither a gate
+        # nor a statement. Explain it instead of failing with "UNKNOWN GATE".
+        # SEND/SHARE are LOCC statements (handled on the LOCC path), so leave
+        # them to their own error.
+        _first = stmt.split(None, 1)[0].upper() if stmt.split() else ''
+        if ((_first in self._CMD_WITH_ARG or _first in self._CMD_NO_ARG)
+                and _first not in ('SEND', 'SHARE')):
+            raise QBasicBuildError(
+                f"{_first} is a configuration/session command, not a program "
+                f"statement; run it without a line number (before RUN), e.g. "
+                f"QUBITS 3 / SHOTS 1024 / METHOD statevector / LOCC 2 2")
+
         # Slow path: subroutine expansion + gate dispatch
         expanded = self._expand_statement(stmt)
         for gate_str in expanded:

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

@@ -135,7 +135,9 @@ class ExpressionMixin:
         'asin': math.asin, 'acos': math.acos, 'atan': math.atan,
         'atan2': math.atan2,
         'sqrt': math.sqrt, 'log': math.log, 'exp': math.exp,
-        'abs': abs, 'int': int, 'float': float,
+        # INT floors toward negative infinity, as in QBASIC (INT(-3.2) = -4).
+        # FIX truncates toward zero (FIX(-3.2) = -3) for the other convention.
+        'abs': abs, 'int': math.floor, 'fix': math.trunc, 'float': float,
         'min': min, 'max': max, 'round': round, 'len': len,
         'ceil': math.ceil, 'floor': math.floor,
     }
@@ -406,6 +408,16 @@ class ExpressionMixin:
         """
         return bool(self._safe_eval(cond, extra_ns=run_vars))
 
+    # Built-in constant names that may not be used as variable/array names, so a
+    # value like E never silently shadows (or is shadowed by) the constant.
+    _RESERVED_CONST_NAMES = frozenset({'PI', 'TAU', 'E', 'SQRT2', 'TRUE', 'FALSE'})
+
+    def _assert_assignable(self, name: str) -> None:
+        """Reject assignment to a built-in constant name (case-insensitive)."""
+        if name.upper() in self._RESERVED_CONST_NAMES:
+            raise ValueError(
+                f"RESERVED: '{name}' is a built-in constant; choose another name")
+
     def _run_timer(self) -> float:
         """Return elapsed time since terminal start."""
         return time.time() - getattr(self, '_start_time', time.time())

{qubasic-0.10.1 → qubasic-0.11.1}/qubasic_core/parser.py

@@ -22,6 +22,7 @@ from qubasic_core.patterns import (
     RE_LPRINT, RE_SCREEN, RE_COLOR, RE_LOCATE,
     RE_ON_MEASURE, RE_ON_TIMER, RE_IMPORT, RE_CHAIN, RE_MERGE,
     RE_LET_STR, RE_DIM_MULTI, RE_MEASURE_BASIS, RE_SYNDROME,
+    RE_IMPLICIT_ASSIGN,
 )
 from qubasic_core.statements import (
     Stmt, RawStmt, GateStmt, RemStmt, MeasureStmt, EndStmt, ReturnStmt,
@@ -578,6 +579,15 @@ def parse_stmt(raw: str) -> Stmt:
         if len(parts) > 1:
             return CompoundStmt(raw=raw, parts=tuple(parts))
 
+    # ── Implicit LET (assignment without the LET keyword) ──────────
+    # A line whose lvalue is followed by a single '=' is an assignment, even
+    # when it collides with a gate name (X = 5 is "assign X", not the X gate).
+    # Tried before gate dispatch so bare assignment works as in every BASIC.
+    if RE_IMPLICIT_ASSIGN.match(text):
+        result = _handle_let(f"LET {text}", raw)
+        if result is not None:
+            return result
+
     # ── Gate application ────────────────────────────────────────────
     canonical = GATE_ALIASES.get(first_word, first_word)
     if canonical in GATE_TABLE:

{qubasic-0.10.1 → qubasic-0.11.1}/qubasic_core/patterns.py

@@ -102,6 +102,11 @@ RE_ON_MEASURE = re.compile(r'ON\s+MEASURE\s+GOSUB\s+(\d+)', re.IGNORECASE)
 RE_ON_TIMER = re.compile(r'ON\s+TIMER\s*\((\d+)\)\s+GOSUB\s+(\d+)', re.IGNORECASE)
 RE_DIM_MULTI = re.compile(r'DIM\s+(\w+)\((\d+(?:\s*,\s*\d+)*)\)', re.IGNORECASE)
 RE_LET_STR = re.compile(r'LET\s+(\w+\$)\s*=\s*(.*)', re.IGNORECASE)
+# Implicit LET: an assignment written without the LET keyword (x = 5, s$ = "hi",
+# a(1) = 5, p.x = 3). Anchored lvalue followed by a single '=' that is not part
+# of '==' / '<=' / '>=' / '!=' / '<>'. Routed through the LET handlers.
+RE_IMPLICIT_ASSIGN = re.compile(
+    r'[A-Za-z_]\w*\$?(?:\.\w+)?(?:\([^)]*\))?\s*=(?!=)', re.IGNORECASE)
 
 __all__ = [
     "RE_LINE_NUM",
@@ -185,4 +190,5 @@ __all__ = [
     "RE_ON_TIMER",
     "RE_DIM_MULTI",
     "RE_LET_STR",
+    "RE_IMPLICIT_ASSIGN",
 ]

{qubasic-0.10.1 → qubasic-0.11.1}/qubasic_core/terminal.py

@@ -508,6 +508,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         'LIST': 'cmd_list', 'QUBITS': 'cmd_qubits', 'SHOTS': 'cmd_shots',
         'METHOD': 'cmd_method', 'DEF': 'cmd_def', 'REG': 'cmd_reg',
         'LET': 'cmd_let', 'STATE': 'cmd_state', 'BLOCH': 'cmd_bloch',
+        'STATUS': 'cmd_status',
         'DEMO': 'cmd_demo', 'DELETE': 'cmd_delete', 'RENUM': 'cmd_renum',
         'SAVE': 'cmd_save', 'LOAD': 'cmd_load', 'SWEEP': 'cmd_sweep',
         'INCLUDE': 'cmd_include', 'EXPORT': 'cmd_export',
@@ -593,6 +594,17 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             except Exception as e:
                 self.io.writeln(f"?ERROR: {e}")
         else:
+            # Implicit LET: a bare assignment (x = 5, s$ = "hi") routed to the
+            # LET handler so it works without the keyword, as in every BASIC.
+            from qubasic_core.patterns import RE_IMPLICIT_ASSIGN
+            if RE_IMPLICIT_ASSIGN.match(line.strip()):
+                try:
+                    self.cmd_let(line.strip())
+                except QBasicError as e:
+                    self.io.writeln(f"?{e.message}")
+                except Exception as e:
+                    self.io.writeln(f"?ERROR: {e}")
+                return
             # Try as immediate gate / subroutine
             try:
                 self.run_immediate(line)
@@ -1066,6 +1078,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             self.io.writeln("?USAGE: LET <var> = <expr>")
             return
         name = m.group(1)
+        self._assert_assignable(name)
         raw = self._safe_eval(m.group(2))
         if isinstance(raw, str):
             self.io.writeln(
@@ -1080,6 +1093,78 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
                 rec[field] = val
         self.io.writeln(f"{name} = {val}")
 
+    def _status_dict(self) -> dict:
+        """Snapshot every active mode that silently changes how a line behaves.
+
+        Returned as plain JSON-serializable values so a caller can read context
+        instead of inferring it from prior commands.
+        """
+        cmap = getattr(self, '_coupling_map', None)
+        return {
+            'qubits': self.num_qubits,
+            'shots': self.shots,
+            'method': self.sim_method,
+            'device': self.sim_device,
+            'seed': getattr(self, '_seed', None),
+            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
+            'option_base': getattr(self, '_option_base', 0),
+            'locc_mode': bool(getattr(self, 'locc_mode', False)),
+            'locc_registers': (list(self.locc.names)
+                               if getattr(self, 'locc_mode', False) and getattr(self, 'locc', None)
+                               else []),
+            'noise_active': getattr(self, '_noise_model', None) is not None,
+            'noise_spec': getattr(self, '_noise_spec', None),
+            'coupling_map': ([list(e) for e in cmap] if cmap else None),
+            'basis_gates': getattr(self, '_basis_gates', None),
+            'pending_set_state': getattr(self, '_pending_set_state', None) is not None,
+            'pending_set_density': getattr(self, '_pending_set_density', None) is not None,
+            'screen_mode': getattr(self, '_screen_mode', 0),
+            'trace_mode': bool(getattr(self, '_trace_mode', False)),
+            'bank': getattr(self, '_current_slot', 0),
+            'program_lines': len(self.program),
+            'variables': len(self.variables),
+            'arrays': len(self.arrays),
+            'subroutines': len(self.subroutines),
+            'custom_gates': sorted(self._custom_gates.keys()),
+        }
+
+    def cmd_status(self, rest: str = '') -> None:
+        """STATUS [JSON] — show every active mode (qubits, method, LOCC, noise,
+        OPTION BASE, pending state injections, bank, ...) so behavior is readable
+        rather than inferred. STATUS JSON emits the same data as JSON."""
+        d = self._status_dict()
+        if rest.strip().upper() == 'JSON':
+            import json
+            self.io.writeln(json.dumps(d, indent=2, default=str))
+            return
+        w = self.io.writeln
+        w("  QUBASIC status")
+        w(f"    qubits       {d['qubits']}    shots {d['shots']}    "
+          f"method {d['method']}    device {d['device']}")
+        w(f"    seed         {d['seed']}")
+        w(f"    bit order    {d['bit_order']}")
+        w(f"    option base  {d['option_base']}")
+        if d['locc_mode']:
+            w(f"    LOCC mode    on    registers {d['locc_registers']}")
+        w(f"    noise        {('on  ' + str(d['noise_spec'])) if d['noise_active'] else 'off'}")
+        if d['coupling_map']:
+            w(f"    coupling     {d['coupling_map']}")
+        if d['basis_gates']:
+            w(f"    basis gates  {d['basis_gates']}")
+        if d['pending_set_state']:
+            w("    pending      SET_STATE applies on next RUN")
+        if d['pending_set_density']:
+            w("    pending      SET_DENSITY applies on next RUN")
+        if d['screen_mode']:
+            w(f"    screen mode  {d['screen_mode']}")
+        if d['trace_mode']:
+            w("    trace        on")
+        w(f"    bank         {d['bank']}")
+        w(f"    program      {d['program_lines']} lines, {d['variables']} vars, "
+          f"{d['arrays']} arrays, {d['subroutines']} subs")
+        if d['custom_gates']:
+            w(f"    custom gates {d['custom_gates']}")
+
     # cmd_defs, cmd_regs, cmd_vars provided by ProgramMgmtMixin.
 
     # ── Run ───────────────────────────────────────────────────────────
@@ -1500,6 +1585,8 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             'counts': self.last_counts or {},
             'num_qubits': self.num_qubits,
             'shots': self.shots,
+            # Bitstrings are little-endian: the rightmost character is qubit 0.
+            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
         }
         uvars = {k: v for k, v in self.variables.items()
                  if not k.startswith('_') and isinstance(v, (int, float, str, bool))}
@@ -1760,6 +1847,14 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         """
         m = RE_MEAS.match(stmt)
         if not m:
+            # Bare MEAS (no "-> bit") is the classic confusion with MEASURE:
+            # MEAS is a mid-circuit measurement that must name a classical bit,
+            # MEASURE collapses qubits into the result histogram.
+            if re.match(r'MEAS\b', stmt, re.IGNORECASE):
+                raise ValueError(
+                    "MEAS needs a target bit: MEAS <qubit> -> <bit> "
+                    "(mid-circuit measurement used by IF). To collapse qubits "
+                    "into the result histogram, use MEASURE <qubit>.")
             return False
         qubit = int(self._eval_with_vars(m.group(1), run_vars))
         var = m.group(2)

{qubasic-0.10.1 → qubasic-0.11.1}/tests/test_qubasic.py

@@ -1963,7 +1963,8 @@ class TestExpressionStringRegressions(unittest.TestCase):
         self.assertAlmostEqual(self.t.eval_expr('SQRT(2)'), self.t.eval_expr('sqrt(2)'))
         self.assertAlmostEqual(self.t.eval_expr('SIN(0)'), 0.0)
         self.assertEqual(self.t.eval_expr('ABS(-5)'), 5.0)
-        self.assertEqual(self.t.eval_expr('INT(-3.2)'), self.t.eval_expr('int(-3.2)'))
+        self.assertEqual(self.t.eval_expr('INT(-3.2)'), -4.0)   # BASIC INT floors
+        self.assertEqual(self.t.eval_expr('FIX(-3.2)'), -3.0)   # FIX truncates toward zero
 
     def test_rnd_case_insensitive(self):
         for expr in ('RND(1)', 'rnd(1)'):
@@ -2016,6 +2017,85 @@ class TestExpressionStringRegressions(unittest.TestCase):
             self.t._eval_print_item('GARBAGEFUNC(3)', {})
 
 
+class TestConventionAndStateRegressions(unittest.TestCase):
+    """Convention-conformance and hidden-state fixes: INT floors, implicit LET,
+    MEAS/MEASURE disambiguation, reserved constants, STATUS, bit-order labels."""
+
+    def setUp(self):
+        self.t = QBasicTerminal()
+        self.t.num_qubits = 2
+
+    def test_int_floors_fix_truncates(self):
+        self.assertEqual(self.t.eval_expr('INT(-3.2)'), -4.0)
+        self.assertEqual(self.t.eval_expr('INT(3.7)'), 3.0)
+        self.assertEqual(self.t.eval_expr('FIX(-3.2)'), -3.0)
+        self.assertEqual(self.t.eval_expr('FIX(3.7)'), 3.0)
+
+    def test_implicit_let_parses_as_assignment(self):
+        from qubasic_core.parser import parse_stmt
+        from qubasic_core.statements import LetStmt, LetStrStmt, LetArrayStmt
+        self.assertIsInstance(parse_stmt('x = 5'), LetStmt)
+        self.assertIsInstance(parse_stmt('s$ = "hi"'), LetStrStmt)
+        self.assertIsInstance(parse_stmt('a(1) = 5'), LetArrayStmt)
+        # '==' is a comparison, never an implicit assignment.
+        self.assertNotIsInstance(parse_stmt('x == 5'), LetStmt)
+
+    def test_implicit_let_runs(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.program = {10: 'x = 5', 20: 's$ = "ok"', 30: 'y = x + 1'}
+        capture(t.cmd_run)
+        self.assertEqual(t.variables['x'], 5.0)
+        self.assertEqual(t.variables['s$'], 'ok')
+        self.assertEqual(t.variables['y'], 6.0)
+
+    def test_meas_bare_form_errors_measure_does_not(self):
+        # MEAS without a target bit raises a helpful error...
+        with self.assertRaises(ValueError):
+            self.t._try_exec_meas('MEAS 0', None, {})
+        # ...while MEASURE is a different statement and is left untouched here.
+        self.assertFalse(self.t._try_exec_meas('MEASURE 0', None, {}))
+
+    def test_reserved_constants_not_assignable(self):
+        for name in ('E', 'e', 'PI', 'pi', 'TAU', 'SQRT2'):
+            with self.assertRaises(ValueError):
+                self.t._assert_assignable(name)
+        self.t._assert_assignable('x')      # ordinary names are fine
+        self.t._assert_assignable('e1')
+
+    def test_status_dict_reports_modes(self):
+        t = QBasicTerminal(); t.num_qubits = 3; t.shots = 128
+        d = t._status_dict()
+        self.assertEqual(d['qubits'], 3)
+        self.assertEqual(d['shots'], 128)
+        self.assertIn('rightmost', d['bit_order'])
+        self.assertFalse(d['noise_active'])
+        self.assertIn('option_base', d)
+
+    def test_bit_order_label_and_result(self):
+        t = QBasicTerminal(); t.num_qubits = 3
+        note = t._bit_order_note([('001', 5)])
+        self.assertIn('q2 q1 q0', note)
+        self.assertIn('rightmost', note)
+        self.assertIn('bit_order', t.result())
+
+    def test_config_command_as_program_line_errors_clearly(self):
+        # A config/REPL command used as a numbered program line explains itself
+        # instead of failing with the misleading "UNKNOWN GATE".
+        for cmd in ('QUBITS 3', 'SHOTS 256', 'METHOD stabilizer', 'LOCC 2 2'):
+            t = QBasicTerminal(); t.num_qubits = 2
+            t.program = {10: cmd, 20: 'H 0', 30: 'MEASURE'}
+            _, out = capture(t.cmd_run)
+            self.assertIn('configuration', out.lower())
+            self.assertNotIn('UNKNOWN GATE', out)
+
+    def test_subroutine_call_not_treated_as_config_command(self):
+        t = QBasicTerminal(); t.num_qubits = 2
+        t.process('DEF BELL = H 0 : CX 0,1', track_undo=False)
+        t.program = {10: 'BELL', 20: 'MEASURE'}
+        capture(t.cmd_run)
+        self.assertIsNotNone(t.last_counts)  # ran; not blocked as a "command"
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')