qubasic 0.13.0__tar.gz → 0.14.0__tar.gz

{qubasic-0.13.0 → qubasic-0.14.0}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.14.0 (2026-06-19)
+
+Second audit-gap round: a complete agent contract, BASIC truth values, range
+comparisons, louder mid-circuit-bit handling, string-array defaults, and lazy
+density inspection. The quantum engine is unchanged.
+
+### Added
+- `qubasic --spec` now reports the full language surface: a `statements` section (QFT, MEAS, SYNDROME, EVOLVE, QADD, CTRL/INV, the control-flow keywords, ...) alongside commands, each with a `signature` field, plus `true_value: -1`.
+- `DIM s$(n)` declares a string array; unread elements default to `""` instead of `0.0`.
+
+### Changed
+- Comparisons return BASIC truth values: `-1` for true, `0` for false (so `LET t = (a > b)` is `-1`).
+- Comparison chaining is Python-style, so `0 <= x <= 10` reads as `(0 <= x) AND (x <= 10)`.
+- Reading a mid-circuit measurement bit (`MEAS`/`SYNDROME -> var`) in a classical expression now raises a clear error instead of silently using the placeholder 0; `IF <bit>` feedforward is unaffected.
+- `DENSITY` solves the density matrix lazily, on demand, instead of on every measured `SET_DENSITY` run.
+
 ## 0.13.0 (2026-06-19)
 
 Closes the remaining audit gaps in the classic-BASIC layer (conventions,

{qubasic-0.13.0/qubasic.egg-info → qubasic-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.13.0
+Version: 0.14.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -245,7 +245,7 @@ Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
 
 ### Operators
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
-Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
+Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=` (yield -1 for true, 0 for false; chain Python-style, so `0 <= x <= 10` works)
 Logical: `AND`, `OR`, `NOT`, `XOR`
 Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`

{qubasic-0.13.0 → qubasic-0.14.0}/README.md

@@ -212,7 +212,7 @@ Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
 
 ### Operators
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
-Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
+Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=` (yield -1 for true, 0 for false; chain Python-style, so `0 <= x <= 10` works)
 Logical: `AND`, `OR`, `NOT`, `XOR`
 Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`

{qubasic-0.13.0 → qubasic-0.14.0}/pyproject.toml

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

{qubasic-0.13.0 → qubasic-0.14.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.13.0
+Version: 0.14.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -245,7 +245,7 @@ Functions and keywords are case-insensitive (`SQRT` and `sqrt` both work).
 
 ### Operators
 Arithmetic: `+`, `-`, `*`, `/`, `//`, `%`, `**`
-Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=`
+Comparison: `==`, `!=`, `<>`, `<`, `>`, `<=`, `>=` (yield -1 for true, 0 for false; chain Python-style, so `0 <= x <= 10` works)
 Logical: `AND`, `OR`, `NOT`, `XOR`
 Bitwise: `AND`, `OR`, `XOR` on integers (`6 AND 3` = 2); `NOT` is logical
 Hex/binary literals: `&HFF`, `&B10110`

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/__init__.py

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

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/analysis.py

@@ -109,9 +109,12 @@ class AnalysisMixin:
 
     def cmd_density(self, rest: str = '') -> None:
         """Show density matrix (DENSITY [reg]); summarizes for large systems."""
-        # A mixed state set via SET_DENSITY has a stored density matrix and no
-        # statevector; display it directly.
+        # A mixed state set via SET_DENSITY has no statevector; solve its
+        # density matrix on demand (cached) from the captured circuit.
         dm = getattr(self, '_last_density', None)
+        if dm is None and getattr(self, '_last_density_qc', None) is not None:
+            dm = self._density_from_qc(self._last_density_qc)
+            self._last_density = dm
         if dm is not None and not rest.strip():
             rho = np.ascontiguousarray(dm)
             dim = rho.shape[0]

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/cli.py

@@ -26,6 +26,54 @@ if sys.stderr and hasattr(sys.stderr, 'reconfigure'):
 from qubasic_core.terminal import QBasicTerminal
 from qubasic_core.program_mgmt import ProgramMgmtMixin
 
+# Statement-level operations that are parsed inline rather than dispatched as
+# REPL commands or gates, so they are absent from the command tables and the
+# gate table. Listed in --spec (name, signature, description) for agents.
+_SPEC_STATEMENTS = [
+    ('MEAS', 'MEAS <qubit> -> <bit>', 'mid-circuit measurement into a classical bit (drives IF feedforward)'),
+    ('MEASURE', 'MEASURE [qubit list]', 'measure all qubits, or a subset, into the result histogram'),
+    ('MEASURE_X', 'MEASURE_X <qubit>', 'measure in the X basis (result in mx_<q>)'),
+    ('MEASURE_Y', 'MEASURE_Y <qubit>', 'measure in the Y basis (result in my_<q>)'),
+    ('MEASURE_Z', 'MEASURE_Z <qubit>', 'measure in the Z basis (result in mz_<q>)'),
+    ('SYNDROME', 'SYNDROME <paulis> <qubits> -> <var>', 'non-destructive stabilizer measurement via an ancilla'),
+    ('RESET', 'RESET <qubit>', 'reset a qubit to |0>'),
+    ('BARRIER', 'BARRIER', 'optimization barrier'),
+    ('QFT', 'QFT <lo>-<hi>', 'quantum Fourier transform over a qubit range'),
+    ('IQFT', 'IQFT <lo>-<hi>', 'inverse quantum Fourier transform'),
+    ('DIFFUSE', 'DIFFUSE <lo>-<hi>', 'Grover diffusion operator'),
+    ('MCX', 'MCX <ctrl,...>, <target>', 'multi-controlled X'),
+    ('MCZ', 'MCZ <ctrl,...>', 'multi-controlled Z'),
+    ('MCP', 'MCP <theta>, <ctrl,...>, <target>', 'multi-controlled phase'),
+    ('QADD', 'QADD <a-range>, <b-range>', 'in-place register add A += B (mod 2^n)'),
+    ('QADDC', 'QADDC <k>, <range>', 'in-place constant add A += k (mod 2^n)'),
+    ('QPE', 'QPE <range> <target> <UGATE>', 'quantum phase estimation of a unitary'),
+    ('AMPLIFY', 'AMPLIFY <marked>', 'one amplitude-amplification (Grover) step'),
+    ('GRAPHSTATE', 'GRAPHSTATE <a-b, b-c, ...>', 'prepare a graph/cluster state'),
+    ('FEATUREMAP', 'FEATUREMAP <x0> <x1> ...', 'ZZ feature-map data encoding'),
+    ('EVOLVE', 'EVOLVE <H>, <time>, <steps>', 'Trotterized Hamiltonian time evolution'),
+    ('APPLYCHANNEL', 'APPLYCHANNEL <name> <qubit>', 'apply a defined Kraus channel'),
+    ('SAVE_EXPECT', 'SAVE_EXPECT <obs> <qubits> -> <var>', 'record an expectation value into a variable after RUN'),
+    ('SAVE_PROBS', 'SAVE_PROBS <qubits> -> <array>', 'record a probability snapshot into an array after RUN'),
+    ('SAVE_AMPS', 'SAVE_AMPS <lo>,<hi> -> <array>', 'record amplitudes into an array after RUN'),
+    ('CTRL', 'CTRL <gate> <ctrl>, <target>', 'controlled version of any gate'),
+    ('INV', 'INV <gate> <args>', 'inverse/dagger of a gate'),
+    ('UNITARY', 'UNITARY <NAME> = [[...]]', 'define a custom gate from a unitary matrix'),
+    ('GOTO', 'GOTO <line>', 'jump to a line number'),
+    ('GOSUB', 'GOSUB <line>', 'call a line block; RETURN resumes'),
+    ('FOR', 'FOR <v> = <a> TO <b> [STEP <s>]', 'counted loop, closed by NEXT'),
+    ('WHILE', 'WHILE <cond>', 'pre-test loop, closed by WEND'),
+    ('DO', 'DO [WHILE|UNTIL <cond>]', 'loop, closed by LOOP [WHILE|UNTIL]'),
+    ('IF', 'IF <cond> THEN <stmt> [ELSE <stmt>]', 'conditional (single-line, or block ending in END IF)'),
+    ('SELECT', 'SELECT CASE <expr>', 'multi-way branch (CASE / CASE ELSE / END SELECT)'),
+    ('DATA', 'DATA <v1>, <v2>, ...', 'inline data consumed by READ'),
+    ('READ', 'READ <var>, ...', 'read the next DATA values'),
+    ('DEF', 'DEF <NAME>[(p)] = <gates>', 'define a gate-sequence subroutine (also DEF FN, DEF BEGIN)'),
+    ('SUB', 'SUB <name>(<args>)', 'structured subroutine (END SUB; LOCAL/STATIC/SHARED)'),
+    ('FUNCTION', 'FUNCTION <name>(<args>)', 'function returning a value (END FUNCTION)'),
+    ('DIM', 'DIM <name>(<size>[,...])', 'declare an array (name$ for strings; inclusive sizing)'),
+    ('REDIM', 'REDIM [PRESERVE] <name>(<size>)', 'resize an array; PRESERVE keeps existing data'),
+]
+
 
 def run_script(path: str, terminal: 'QBasicTerminal') -> None:
     """Run a .qb script file. Supports multi-line DEF blocks.
@@ -100,20 +148,32 @@ def main():
         from qubasic_core.engine import GATE_TABLE
         from qubasic_core.expression import ExpressionMixin
 
-        def _help1(mname):
+        def _doc_parts(mname):
             doc = (getattr(getattr(QBasicTerminal, mname, None), '__doc__', '') or '').strip()
-            return doc.split('\n')[0].strip()
+            line = doc.split('\n')[0].strip()
+            # Docstrings format the first line as "SIGNATURE — description".
+            for sep in ('—', ' - '):
+                if sep in line:
+                    sig, _, hlp = line.partition(sep)
+                    return sig.strip(), hlp.strip()
+            return '', line
 
         cmds = []
         for tbl, takes in ((QBasicTerminal._CMD_WITH_ARG, True),
                            (QBasicTerminal._CMD_NO_ARG, False)):
             for cname, mname in tbl.items():
-                cmds.append({'name': cname, 'takes_arg': takes, 'help': _help1(mname)})
+                sig, hlp = _doc_parts(mname)
+                cmds.append({'name': cname, 'takes_arg': takes,
+                             'signature': sig or cname, 'help': hlp})
+        statements = [{'name': n, 'signature': s, 'help': h}
+                      for (n, s, h) in _SPEC_STATEMENTS]
         spec = {
             'name': 'qubasic',
             'version': __version__,
             'bit_order': 'little-endian (qubit 0 = rightmost bit)',
+            'true_value': -1,
             'commands': sorted(cmds, key=lambda c: c['name']),
+            'statements': sorted(statements, key=lambda s: s['name']),
             'gates': sorted(GATE_TABLE.keys()),
             'functions': sorted(
                 set(ExpressionMixin._SAFE_FUNCS)

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/control_flow.py

@@ -102,9 +102,10 @@ class ControlFlowMixin:
         if idx < 0:
             raise RuntimeError(f"ARRAY INDEX OUT OF RANGE: {name}({idx + base})")
         dimmed = getattr(self, '_dimmed_arrays', set())
+        fill = '' if name.endswith('$') else 0.0   # string arrays default to ""
         if name not in self.arrays:
             # Implicit array: created (and allowed to grow) on first assignment.
-            self.arrays[name] = [0.0] * (idx + 1)
+            self.arrays[name] = [fill] * (idx + 1)
         elif idx >= len(self.arrays[name]):
             if name in dimmed:
                 # Explicitly DIMmed: writes are bounds-checked like reads,
@@ -113,7 +114,7 @@ class ControlFlowMixin:
                     f"ARRAY INDEX OUT OF RANGE: {name}({idx + base}), "
                     f"size {len(self.arrays[name])}")
             while idx >= len(self.arrays[name]):
-                self.arrays[name].append(0.0)
+                self.arrays[name].append(fill)
         self.arrays[name][idx] = val
         return True, ExecResult.ADVANCE
 

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/engine_state.py

@@ -57,8 +57,10 @@ class Engine:
         # Arrays declared with DIM/REDIM enforce their bounds on write;
         # arrays created implicitly by first assignment keep auto-growing.
         self._dimmed_arrays: set[str] = set()
-        # Density matrix captured by a no-MEASURE run with SET_DENSITY.
+        # Density matrix (and the measure-free circuit to solve it lazily)
+        # for a run with SET_DENSITY, computed on demand by DENSITY.
         self._last_density: Any = None
+        self._last_density_qc: Any = None
 
         # Subroutines and registers
         self.subroutines: dict[str, Any] = {}
@@ -119,6 +121,7 @@ class Engine:
         self._array_dims.clear()
         self._dimmed_arrays.clear()
         self._last_density = None
+        self._last_density_qc = None
         self.last_counts = None
         self.last_sv = None
         self.last_circuit = None

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/executor.py

@@ -113,8 +113,10 @@ class ExecutorMixin:
         self._classical_bits = {}
         # Partial-measurement subset (None = measure all at the end).
         self._measure_subset = None
-        # Density matrix captured by a no-MEASURE run (None unless set).
+        # Density matrix (and circuit) captured by a SET_DENSITY run; the
+        # matrix is solved lazily by DENSITY from the stored circuit.
         self._last_density = None
+        self._last_density_qc = None
         # Apply any qubit state preparation requested via POKE to $0100.
         if getattr(self, '_poke_state_prep', None):
             self._emit_poke_state_prep(qc)

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/expression.py

@@ -190,6 +190,15 @@ class ExpressionMixin:
                 return node.value
             raise ValueError(f"UNSUPPORTED CONSTANT: {node.value!r}")
         if isinstance(node, ast.Name):
+            # A mid-circuit measurement bit has no classical value (it is
+            # resolved per shot); reading it outside an IF feedforward is an
+            # error rather than a silent placeholder 0.
+            cb = getattr(self, '_classical_bits', None)
+            if cb and node.id in cb:
+                raise ValueError(
+                    f"'{node.id}' is a mid-circuit measurement bit; its value is "
+                    f"per-shot, so it can't be read in a classical expression "
+                    f"(use IF {node.id} for feedforward, or LOCC mode for a live value)")
             if node.id in ns:
                 return ns[node.id]
             raise ValueError(f"UNDEFINED: {node.id}")
@@ -215,18 +224,19 @@ class ExpressionMixin:
                 result = op(result, self._ast_eval(val, ns))
             return result
         if isinstance(node, ast.Compare):
-            # A chained comparison (a < b < c) is ambiguous: Python reads it as
-            # (a<b) and (b<c), BASIC as the left-to-right (a<b)<c. Rather than
-            # pick one silently, require it to be written explicitly.
-            if len(node.ops) > 1:
-                raise ValueError(
-                    "AMBIGUOUS CHAINED COMPARISON: write it explicitly, "
-                    "e.g. (a < b) AND (b < c)")
-            op = self._AST_OPS.get(type(node.ops[0]))
-            if op is None:
-                raise ValueError(f"UNSUPPORTED OP: {type(node.ops[0]).__name__}")
-            return op(self._ast_eval(node.left, ns),
-                      self._ast_eval(node.comparators[0], ns))
+            # Python-style chaining (a < b < c means (a<b) and (b<c)) so range
+            # checks like 0 <= x <= 10 work as written; results use BASIC truth
+            # values (-1 for true, 0 for false).
+            left = self._ast_eval(node.left, ns)
+            for op_node, comparator in zip(node.ops, node.comparators):
+                op = self._AST_OPS.get(type(op_node))
+                if op is None:
+                    raise ValueError(f"UNSUPPORTED OP: {type(op_node).__name__}")
+                right = self._ast_eval(comparator, ns)
+                if not op(left, right):
+                    return 0
+                left = right
+            return -1
         if isinstance(node, ast.Call):
             if not isinstance(node.func, ast.Name):
                 raise ValueError("ONLY SIMPLE FUNCTION CALLS ALLOWED")

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/patterns.py

@@ -17,7 +17,7 @@ RE_SHARE = re.compile(r'SHARE\s+([A-Z])\s+(\d+)\s*,?\s*([A-Z])\s+(\d+)', re.IGNO
 RE_MEAS = re.compile(r'MEAS\s+(\S+)\s*->\s*(\w+)', re.IGNORECASE)
 RE_RESET = re.compile(r'RESET\s+(\S+)', re.IGNORECASE)
 RE_UNITARY = re.compile(r'UNITARY\s+(\w+)\s*=\s*(\[.+\])', re.IGNORECASE)
-RE_DIM = re.compile(r'DIM\s+(\w+)\((\d+)\)', re.IGNORECASE)
+RE_DIM = re.compile(r'DIM\s+(\w+\$?)\((\d+)\)', re.IGNORECASE)
 RE_REDIM = re.compile(r'REDIM\s+(PRESERVE\s+)?(\w+)\((\d+)\)', re.IGNORECASE)
 RE_ERASE = re.compile(r'ERASE\s+(\w+)', re.IGNORECASE)
 RE_GET = re.compile(r'GET\s+(\w+\$?)', re.IGNORECASE)
@@ -100,7 +100,7 @@ RE_SCREEN = re.compile(r'SCREEN\s+(\d+)', re.IGNORECASE)
 RE_LPRINT = re.compile(r'LPRINT\s+(.*)', re.IGNORECASE)
 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_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

{qubasic-0.13.0 → qubasic-0.14.0}/qubasic_core/terminal.py

@@ -1244,6 +1244,28 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
     # it skip extraction; STATE/BLOCH then report no state.
     _SV_EXTRACT_MAX_QUBITS = 24
 
+    def _density_from_qc(self, qc_sv):
+        """Solve the density matrix of a measure-free circuit, for DENSITY.
+
+        Computed on demand (not on every run) from the circuit captured when a
+        SET_DENSITY state was prepared.
+        """
+        try:
+            q2 = qc_sv.copy()
+            q2.save_density_matrix()
+            dm_backend = self._make_backend('density_matrix', include_noise=True)
+            _kw = {}
+            if self._seed is not None:
+                _kw['seed_simulator'] = self._seed
+            res = dm_backend.run(
+                transpile(q2, dm_backend, optimization_level=self._transpile_opt_level),
+                **_kw).result()
+            data = res.data(0)
+            dm = data.get('density_matrix') if hasattr(data, 'get') else None
+            return np.array(dm) if dm is not None else None
+        except Exception:
+            return None
+
     def _extract_statevector(self, qc_sv) -> None:
         """Run the measurement-free circuit copy to get last_sv.
 
@@ -1255,25 +1277,13 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         2^n statevector that cannot be displayed anyway.
         """
         if getattr(self, '_pending_set_density', None) is not None:
-            # Mixed state: no pure statevector. Capture the density matrix so
-            # DENSITY works after a measured run, not just a no-MEASURE one.
+            # Mixed state: no pure statevector. Defer the density-matrix solve
+            # to DENSITY (lazy) so a measured run does not pay for it unused;
+            # keep the measure-free circuit to solve from.
             self.last_sv = None
-            if self.num_qubits <= self._SV_EXTRACT_MAX_QUBITS:
-                try:
-                    qc_sv.save_density_matrix()
-                    dm_backend = self._make_backend('density_matrix', include_noise=True)
-                    _kw = {}
-                    if self._seed is not None:
-                        _kw['seed_simulator'] = self._seed
-                    dm_result = dm_backend.run(
-                        transpile(qc_sv, dm_backend,
-                                  optimization_level=self._transpile_opt_level),
-                        **_kw).result()
-                    data = dm_result.data(0)
-                    dm = data.get('density_matrix') if hasattr(data, 'get') else None
-                    self._last_density = np.array(dm) if dm is not None else None
-                except Exception:
-                    self._last_density = None
+            self._last_density = None
+            self._last_density_qc = (qc_sv if self.num_qubits <= self._SV_EXTRACT_MAX_QUBITS
+                                     else None)
             return
         if self.num_qubits > self._SV_EXTRACT_MAX_QUBITS:
             self.last_sv = None
@@ -1318,20 +1328,12 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         """Execute the no-MEASURE path: statevector (or density matrix), no shots."""
         too_large = self.num_qubits > self._SV_EXTRACT_MAX_QUBITS
         if getattr(self, '_pending_set_density', None) is not None and not too_large:
-            # A mixed state has no statevector, so capture the density matrix
-            # for DENSITY instead. Saving a statevector here used to raise an
-            # untranslatable-circuit error from Aer.
+            # A mixed state has no statevector. Defer the density solve to
+            # DENSITY (lazy); keep the measure-free circuit. Saving a statevector
+            # here used to raise an untranslatable-circuit error from Aer.
             self.last_sv = None
-            try:
-                qc_sv.save_density_matrix()
-                dm_backend = self._make_backend('density_matrix', include_noise=True)
-                dm_result = dm_backend.run(
-                    transpile(qc_sv, dm_backend, optimization_level=self._transpile_opt_level)).result()
-                data = dm_result.data(0)
-                dm = data.get('density_matrix') if hasattr(data, 'get') else None
-                self._last_density = np.array(dm) if dm is not None else None
-            except Exception:
-                self._last_density = None
+            self._last_density = None
+            self._last_density_qc = qc_sv
         elif too_large:
             self.last_sv = None
         else:
@@ -1969,7 +1971,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         total = 1
         for s in sizes:
             total *= s
-        self.arrays[name] = [0.0] * total
+        self.arrays[name] = [('' if name.endswith('$') else 0.0)] * total
         if len(sizes) > 1:
             self._array_dims[name] = sizes
         self._dimmed_arrays.add(name)

{qubasic-0.13.0 → qubasic-0.14.0}/tests/test_qubasic.py

@@ -2138,7 +2138,9 @@ class TestDeepFixRegressions(unittest.TestCase):
         t.process('10 ID 0', track_undo=False)
         _, out = capture(t.cmd_run)
         self.assertNotIn('Unable to translate', out)
-        self.assertIsNotNone(getattr(t, '_last_density', None))
+        # Density is solved lazily: the measure-free circuit is captured now,
+        # and DENSITY computes the matrix on demand.
+        self.assertIsNotNone(getattr(t, '_last_density_qc', None))
         _, dout = capture(t.cmd_density, '')
         self.assertIn('Density matrix', dout)
 
@@ -2173,10 +2175,13 @@ class TestConventionFixesV2(unittest.TestCase):
         self.assertEqual(self.t.eval_expr('round(-2.5)'), -3.0)
         self.assertAlmostEqual(self.t.eval_expr('round(2.345, 2)'), 2.35)
 
-    def test_chained_comparison_raises(self):
-        self.assertTrue(bool(self.t._safe_eval('3 < 5')))
-        with self.assertRaises(ValueError):
-            self.t._safe_eval('1 < 2 < 3')
+    def test_comparison_truth_and_chaining(self):
+        # Comparisons yield BASIC truth values: -1 for true, 0 for false.
+        self.assertEqual(self.t._safe_eval('3 < 5'), -1)
+        self.assertEqual(self.t._safe_eval('3 > 5'), 0)
+        # Python-style chaining, so range checks work as written.
+        self.assertEqual(self.t._safe_eval('0 <= 5 <= 10'), -1)
+        self.assertEqual(self.t._safe_eval('0 <= 50 <= 10'), 0)
 
     def test_dim_inclusive_top_index(self):
         t = self._runp(['10 DIM a(5)', '20 LET a(5)=7', '30 LET v=a(5)'])
@@ -2203,6 +2208,24 @@ class TestConventionFixesV2(unittest.TestCase):
         _, dout = capture(t.cmd_density, '')
         self.assertIn('Density matrix', dout)
 
+    def test_meas_bit_classical_use_errors(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        for l in ['10 X 0', '20 MEAS 0 -> m', '30 LET y = m + 1', '40 MEASURE']:
+            t.process(l, track_undo=False)
+        _, out = capture(t.cmd_run)
+        self.assertIn('mid-circuit', out)
+
+    def test_string_array_default_empty(self):
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.process('DIM s$(3)', track_undo=False)
+        self.assertEqual(t._safe_eval('s$(1)'), '')
+
+    def test_spec_statements_present(self):
+        from qubasic_core.cli import _SPEC_STATEMENTS
+        names = {n for (n, _s, _h) in _SPEC_STATEMENTS}
+        for op in ('QFT', 'MEAS', 'SYNDROME', 'EVOLVE', 'QADD'):
+            self.assertIn(op, names)
+
 
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):