qubasic 0.3.1__tar.gz → 0.4.1__tar.gz

qubasic-0.4.1/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+## 0.4.1 (2026-03-30)
+
+- **Fix SEED dispatch**: moved from no-arg to with-arg dispatch table so `SEED 42` works from the REPL
+- **Fix GPU probe**: `cmd_method` GPU probe used undefined `_pqc` variable; now uses `_pqc_m`
+- **Fix LOCC non-numeric args**: `LOCC 4 banana` no longer crashes with unguarded ValueError
+- **Coverage threshold**: raised CI coverage floor from 60% to 75%
+- **Property-based tests**: 4 new hypothesis tests (arithmetic identity, parser fuzzing, process fuzzing, FOR loop count)
+- **CLI integration tests**: 8 new tests covering dispatch, SEED, LOCC error handling, METHOD probe, --seed flag, --help
+- **Parser imports**: import regexes from patterns.py directly instead of double-indirection through engine.py
+- **Expression simplification**: `_replace_dollar_outside_strings` reduced from two passes to one
+- **Jump table**: pre-compute WHILE/WEND and DO/LOOP ip mappings in `_scan_subs`; `_find_matching_wend` and `_find_matching_loop` use O(1) lookup when available
+- **Scope cleanup**: removed dual-write hack in `Scope.__setitem__`; writes go to `_runtime` only, `_persistent` is read-through fallback
+- **STATS output**: redirect stdout during stats runs to suppress rich console output in non-TTY mode
+- **Copyright year**: LICENSE updated from 2025 to 2026
+- **CLI --seed flag**: `qubasic --seed N script.qb` sets deterministic seed before execution
+- **Type annotations**: added return type annotations to 14 unannotated mixin methods across locc_commands, locc_display, locc_execution, demos
+
+## 0.4.0 (2026-03-29)
+
+- **Noise correctness**: transpile with optimization_level=0 when noisy so gates survive for noise attachment
+- **Noisy statevector**: STATE/BLOCH/DENSITY now reflect the noisy executed state, not the ideal state
+- **LOCC noise**: Monte Carlo depolarizing noise in the numpy LOCC engine with per-shot execution
+- **GPU**: _make_backend centralizes device flag to all execution paths; graceful probe and fallback
+- **cmd_run decomposition**: extracted _run_no_measure, _run_with_fallback, _extract_statevector, _finalize_run, _select_method, _build_backend_opts, _run_kwargs
+- **State consistency**: _active_sv/_active_nqubits unify LOCC and standard paths for all state commands
+- **SPLIT mode**: EXPECT/DENSITY correctly report that per-register commands are needed
+- **Non-depolarizing noise warning**: entering LOCC mode with unsupported noise types warns explicitly
+- SEED command for deterministic reproducible results
+- VERSION command with build ID, simulator versions, and feature flags
+- PROBE command: one-shot exercise of CPU, noise, LOCC, conditional, and combined paths
+- CONSISTENCY command: cross-check SV norm, purity, Bloch vectors, EXPECT, and histogram
+- METHOD capability map: real probing of each method and GPU availability
+- HELP STATUS: tags all 93 commands as native/experimental/partial
+- CATALOG shows backend behind each SYS routine
+- RUN prints method, device, noise params in summary line
+- Demo self-verification: Bell, GHZ, Grover, Deutsch, BV, Superdense auto-check with pass/fail thresholds
+- Teleportation fidelity output with X-basis verification
+- LOCCINFO: entanglement creation, correction log, branch statistics, noise status
+- Method-device pre-check blocks incompatible combinations before execution
+- Runtime errors identify failing subsystem (GPU/noise/stabilizer/MPS)
+- Run manifest captures all execution parameters for replay
+- Correction log in LOCC engine tracks SEND outcomes
+- NOISE INFO prints exact channels, operations, qubits
+- 25 new tests covering noise, LOCC noise, SEED, VERSION, PROBE, CONSISTENCY, demos, state-after-LOCC, manifest, and method-device pre-check (196 total, up from 171)
+- real_sim pytest marker for tests requiring actual Qiskit Aer simulation
+
+## 0.3.1 (2026-03-29)
+
+- Fix f-string backslash escapes that broke import on Python 3.10/3.11
+
+## 0.3.0 (2026-03-28)
+
+- FUNCTION return value fix, APPLY_CIRCUIT in programs, stabilizer fallback
+- Bump to 0.3.0
+
+## 0.2.0 (2026-03-28)
+
+- Rename qbasic -> qubasic everywhere (PyPI name conflict)
+
+## 0.1.0 (2026-03-28)
+
+Initial PyPI release.
+
+- BASIC REPL with line-numbered program editing
+- 30+ quantum gates (H, X, Y, Z, CX, CCX, RX, RY, RZ, CP, SWAP, etc.)
+- LOCC mode: 2-26 party distributed quantum simulation (SPLIT and JOINT)
+- Full BASIC language: FOR/NEXT, WHILE/WEND, DO/LOOP, SELECT CASE, SUB/FUNCTION, IF/THEN/ELSE
+- AST-based expression evaluator (no eval)
+- Noise models: depolarizing, amplitude damping, phase flip, thermal, readout, combined, Pauli, reset
+- Debugging: STEP, TRON/TROFF, breakpoints, watch, time-travel (REWIND/FORWARD), PROFILE
+- Memory map: PEEK/POKE/SYS/DUMP/MAP/MONITOR
+- Analysis: EXPECT, ENTROPY, DENSITY, SWEEP, BENCH, RAM
+- File I/O: SAVE/LOAD/INCLUDE/IMPORT, OPEN/CLOSE/PRINT#/INPUT#, CSV, OpenQASM 3.0 export
+- 12 built-in demos: Bell, GHZ, Grover, QFT, Deutsch-Jozsa, Bernstein-Vazirani, Superdense, Teleport, LOCC
+- JSON output mode for agent/pipeline integration
+- String variable resolution in PRINT (LEFT$, RIGHT$, CHR$, concatenation)
+- DEF FN and parameterized DEF subroutine invocation
+- Trusted publisher CI/CD to PyPI

{qubasic-0.3.1 → qubasic-0.4.1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Charles C. Norton
+Copyright (c) 2026 Charles C. Norton
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{qubasic-0.3.1/qubasic.egg-info → qubasic-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.3.1
+Version: 0.4.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT

{qubasic-0.3.1 → qubasic-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.3.1"
+version = "0.4.1"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -53,6 +53,9 @@ packages = ["qubasic_core"]
 [tool.setuptools.data-files]
 "share/qubasic/examples" = ["examples/*.qb"]
 
+[tool.pytest.ini_options]
+markers = ["real_sim: test requires real Qiskit Aer simulation (no mock)"]
+
 [tool.coverage.run]
 source = ["qubasic_core"]
 omit = ["*/test_*"]

{qubasic-0.3.1 → qubasic-0.4.1/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.3.1
+Version: 0.4.1
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic.py

@@ -53,10 +53,22 @@ def main():
     args = sys.argv[1:]
     quiet = '--quiet' in args or '-q' in args
     json_mode = '--json' in args
+    seed_val = None
     if quiet:
         args = [a for a in args if a not in ('--quiet', '-q')]
     if json_mode:
         args = [a for a in args if a != '--json']
+    # Parse --seed N
+    filtered = []
+    i = 0
+    while i < len(args):
+        if args[i] == '--seed' and i + 1 < len(args):
+            seed_val = int(args[i + 1])
+            i += 2
+        else:
+            filtered.append(args[i])
+            i += 1
+    args = filtered
 
     if any(a in ('-h', '--help') for a in args):
         from qubasic_core import __version__
@@ -67,12 +79,17 @@ def main():
         print("  qubasic script.qb        Run a script file")
         print("  qubasic --quiet script    Suppress banner and progress")
         print("  qubasic --json script     Output results as JSON")
+        print("  qubasic --seed N script   Set random seed for reproducibility")
         print("  qubasic --help            Show this help")
         print()
         print("Type HELP inside the REPL for full command reference.")
         sys.exit(0)
 
     term = QBasicTerminal()
+    if seed_val is not None:
+        import numpy as _np
+        term._seed = seed_val
+        _np.random.seed(seed_val)
 
     if args:
         path = args[0]

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/__init__.py

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

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/analysis.py

@@ -25,8 +25,12 @@ class AnalysisMixin:
     def cmd_expect(self, rest: str) -> None:
         """EXPECT <pauli> [qubits] — compute expectation value.
         Examples: EXPECT Z 0, EXPECT ZZ 0 1, EXPECT X 0"""
-        if self.last_sv is None:
-            self.io.writeln("?NO STATE — RUN first")
+        sv = self._active_sv
+        if sv is None:
+            if self.locc_mode and self.locc and not self.locc.joint:
+                self.io.writeln("?SPLIT mode: use STATE A / STATE B for per-register inspection")
+            else:
+                self.io.writeln("?NO STATE — RUN first")
             return
         parts = rest.split()
         if not parts:
@@ -35,16 +39,16 @@ class AnalysisMixin:
         pauli_str = parts[0].upper()
         qubits = [int(q) for q in parts[1:]] if len(parts) > 1 else list(range(len(pauli_str)))
 
+        n = self._active_nqubits
         try:
             from qiskit.quantum_info import Statevector, SparsePauliOp
-            sv = Statevector(np.ascontiguousarray(self.last_sv).ravel())
-            # Build Pauli string for full system
-            full_pauli = ['I'] * self.num_qubits
+            sv_q = Statevector(np.ascontiguousarray(sv).ravel())
+            full_pauli = ['I'] * n
             for i, p in enumerate(pauli_str):
                 if i < len(qubits):
-                    full_pauli[self.num_qubits - 1 - qubits[i]] = p
+                    full_pauli[n - 1 - qubits[i]] = p
             op = SparsePauliOp(''.join(full_pauli))
-            val = sv.expectation_value(op)
+            val = sv_q.expectation_value(op)
             self.io.writeln(f"  <{pauli_str}> on qubits {qubits} = {val.real:.6f}")
         except Exception as e:
             self.io.writeln(f"?EXPECT ERROR: {e}")
@@ -52,17 +56,18 @@ class AnalysisMixin:
     def cmd_entropy(self, rest: str = '') -> None:
         """ENTROPY [qubits] — entanglement entropy of specified qubits vs rest.
         Examples: ENTROPY 0  |  ENTROPY 0 1  |  ENTROPY (defaults to qubit 0)"""
-        if self.last_sv is None:
+        sv = self._active_sv
+        if sv is None:
             self.io.writeln("?NO STATE — RUN first")
             return
         if rest.strip():
             partition_a = [int(q) for q in rest.replace(',', ' ').split() if q.strip()]
         else:
             partition_a = [0]
-        n = self.num_qubits
+        n = self._active_nqubits
         try:
             from qiskit.quantum_info import Statevector, entropy, partial_trace
-            sv_obj = Statevector(np.ascontiguousarray(self.last_sv).ravel())
+            sv_obj = Statevector(np.ascontiguousarray(sv).ravel())
             keep = partition_a
             rho_a = partial_trace(sv_obj, [q for q in range(n) if q not in keep])
             ent = entropy(rho_a, base=2)
@@ -78,12 +83,13 @@ class AnalysisMixin:
 
     def cmd_density(self) -> None:
         """Show density matrix (or partial trace for small systems)."""
-        if self.last_sv is None:
+        sv = self._active_sv
+        if sv is None:
             self.io.writeln("?NO STATE — RUN first")
             return
-        sv = np.ascontiguousarray(self.last_sv).ravel()
+        sv = np.ascontiguousarray(sv).ravel()
         rho = np.outer(sv, sv.conj())
-        n = self.num_qubits
+        n = self._active_nqubits
         dim = 2**n
         if dim > 16:
             self.io.writeln(f"  Density matrix: {dim}x{dim} (too large to display)")
@@ -140,6 +146,82 @@ class AnalysisMixin:
                 self.io.writeln(f"  {n:>8}  {method:>20}  FAILED: {e}")
         self.io.writeln('')
 
+    def cmd_consistency(self, rest: str = '') -> None:
+        """CONSISTENCY — cross-check histogram, SV, density, Bloch, and EXPECT."""
+        sv = self._active_sv
+        if sv is None:
+            self.io.writeln("?NO STATE — RUN first")
+            return
+        n = self._active_nqubits
+        sv = np.ascontiguousarray(sv).ravel()
+        checks = []
+
+        # 1. SV normalization
+        norm = float(np.sum(np.abs(sv)**2))
+        ok = abs(norm - 1.0) < 1e-6
+        checks.append(('SV norm == 1', ok, f"{norm:.8f}"))
+
+        # 2. Density matrix purity
+        rho = np.outer(sv, sv.conj())
+        purity = float(np.real(np.trace(rho @ rho)))
+        ok2 = purity <= 1.0 + 1e-6
+        checks.append(('Purity <= 1', ok2, f"{purity:.8f}"))
+
+        # 3. Bloch vector length <= 1 for each qubit
+        bloch_ok = True
+        for q in range(min(n, 8)):
+            x, y, z = self._bloch_vector(sv, q, n)
+            r = (x**2 + y**2 + z**2) ** 0.5
+            if r > 1.0 + 1e-4:
+                bloch_ok = False
+                break
+        checks.append(('Bloch |r| <= 1', bloch_ok, ''))
+
+        # 4. EXPECT Z on qubit 0 matches P(0) - P(1)
+        try:
+            from qiskit.quantum_info import Statevector, SparsePauliOp
+            sv_q = Statevector(sv)
+            pauli_z = ['I'] * n
+            pauli_z[n - 1] = 'Z'
+            op = SparsePauliOp(''.join(pauli_z))
+            ez = float(sv_q.expectation_value(op).real)
+            # Compare with direct calculation
+            sv_t = sv.reshape([2] * n)
+            ax = n - 1
+            t0 = np.moveaxis(sv_t, ax, 0)[0].flatten()
+            t1 = np.moveaxis(sv_t, ax, 0)[1].flatten()
+            p0 = float(np.sum(np.abs(t0)**2))
+            p1 = float(np.sum(np.abs(t1)**2))
+            ez_direct = p0 - p1
+            ok4 = abs(ez - ez_direct) < 1e-6
+            checks.append(('<Z> consistent', ok4, f"qiskit={ez:.6f} direct={ez_direct:.6f}"))
+        except Exception as _e:
+            checks.append(('<Z> consistent', None, f"skip: {_e}"))
+
+        # 5. Histogram vs SV (if counts available)
+        if self.last_counts:
+            total = sum(self.last_counts.values())
+            hist_p0 = self.last_counts.get('0' * n, 0) / total
+            sv_p0 = float(np.abs(sv[0])**2)
+            # Loose check: histogram is statistical, allow 10% deviation
+            ok5 = abs(hist_p0 - sv_p0) < 0.15 or total < 50
+            checks.append(('Hist~SV P(|0>)', ok5,
+                          f"hist={hist_p0:.3f} sv={sv_p0:.3f}"))
+
+        self.io.writeln(f"\n  Consistency checks ({n} qubits):")
+        all_pass = True
+        for name, ok, detail in checks:
+            if ok is None:
+                status = 'SKIP'
+            elif ok:
+                status = 'PASS'
+            else:
+                status = 'FAIL'
+                all_pass = False
+            extra = f"  {detail}" if detail else ""
+            self.io.writeln(f"    {name:25s} {status}{extra}")
+        self.io.writeln(f"\n  {'ALL CONSISTENT' if all_pass else 'INCONSISTENCY DETECTED'}")
+
     def cmd_ram(self) -> None:
         """RAM — show memory budget, per-instance cost, and parallelism estimates."""
         ram = _get_ram_gb()

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/classic.py

@@ -217,6 +217,9 @@ class ClassicMixin:
     # ── DO / LOOP ─────────────────────────────────────────────────────
 
     def _find_matching_loop(self, sorted_lines: list[int], ip: int) -> int:
+        jt = getattr(self, '_jump_table', None)
+        if jt and ip in jt:
+            return jt[ip]
         depth = 1
         scan = ip + 1
         while scan < len(sorted_lines):

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/control_flow.py

@@ -166,10 +166,12 @@ class ControlFlowMixin:
     def _find_matching_wend(self, sorted_lines: list[int], ip: int) -> int:
         """Find the ip after the WEND matching the WHILE at ip.
 
-        Scans forward with proper nesting depth tracking. Returns the ip
-        index past the matching WEND. Raises with the WHILE line number
-        for clear diagnostics.
+        Uses pre-computed jump table when available (O(1)), falls back
+        to linear scan with nesting depth tracking.
         """
+        jt = getattr(self, '_jump_table', None)
+        if jt and ip in jt:
+            return jt[ip] + 1
         depth = 1
         scan = ip + 1
         while scan < len(sorted_lines):

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/demos.py

@@ -1,4 +1,4 @@
-"""QUBASIC built-in demo circuits."""
+"""QUBASIC built-in demo circuits with self-verification."""
 
 
 class DemoMixin:
@@ -8,7 +8,7 @@ class DemoMixin:
     self.shots, self.cmd_new(), self.cmd_run(), self.cmd_list(), self.cmd_locc().
     """
 
-    def cmd_demo(self, name):
+    def cmd_demo(self, name: str) -> None:
         demos = {
             'BELL':        self._demo_bell,
             'GHZ':         self._demo_ghz,
@@ -36,6 +36,29 @@ class DemoMixin:
             return
         demos[name]()
 
+    def _verify_demo(self, expected_states: list[str], min_frac: float = 0.85,
+                     label: str = '') -> bool:
+        """Check that expected states dominate the output.
+
+        expected_states: list of bitstrings that should capture >= min_frac of shots.
+        Returns True if verification passes.
+        """
+        if not self.last_counts:
+            self.io.writeln(f"  VERIFY: no results")
+            return False
+        total = sum(self.last_counts.values())
+        hit = sum(self.last_counts.get(s, 0) for s in expected_states)
+        frac = hit / total if total > 0 else 0
+        tag = f" ({label})" if label else ""
+        if frac >= min_frac:
+            self.io.writeln(f"  VERIFY PASS{tag}: {frac:.1%} in expected states "
+                           f"(threshold {min_frac:.0%})")
+            return True
+        else:
+            self.io.writeln(f"  VERIFY FAIL{tag}: {frac:.1%} in expected states "
+                           f"(threshold {min_frac:.0%})")
+            return False
+
     def _demo_bell(self):
         self.cmd_new()
         self.num_qubits = 2
@@ -49,6 +72,7 @@ class DemoMixin:
         self.io.writeln("LOADED: Bell State (2 qubits)")
         self.cmd_list()
         self.cmd_run()
+        self._verify_demo(['00', '11'], 0.95, 'Bell: only |00> and |11>')
 
     def _demo_ghz(self):
         self.cmd_new()
@@ -69,6 +93,7 @@ class DemoMixin:
         self.io.writeln(f"LOADED: GHZ State ({n} qubits)")
         self.cmd_list()
         self.cmd_run()
+        self._verify_demo(['0' * n, '1' * n], 0.95, f'GHZ: only |{"0"*n}> and |{"1"*n}>')
 
     def _demo_teleport(self):
         self.cmd_new()
@@ -138,6 +163,7 @@ class DemoMixin:
         self.io.writeln("LOADED: Grover's Search (3 qubits, target=|101>)")
         self.cmd_list()
         self.cmd_run()
+        self._verify_demo(['101'], 0.85, 'Grover: target |101>')
 
     def _demo_qft(self):
         self.cmd_new()
@@ -193,6 +219,8 @@ class DemoMixin:
         self.io.writeln("  Expect: qubit 0 = 1 (balanced)")
         self.cmd_list()
         self.cmd_run()
+        # q0=1 means bit pattern x1 (states 01 or 11)
+        self._verify_demo(['01', '11'], 0.95, 'Deutsch: q0=1 (balanced)')
 
     def _demo_bernstein(self):
         self.cmd_new()
@@ -218,6 +246,8 @@ class DemoMixin:
         self.io.writeln("  Expect: measurement shows ...1011 (q3q2q1q0)")
         self.cmd_list()
         self.cmd_run()
+        # Ancilla (q4) is random; data qubits should read 1011
+        self._verify_demo(['01011', '11011'], 0.95, 'BV: secret=1011')
 
     def _demo_superdense(self):
         self.cmd_new()
@@ -243,6 +273,7 @@ class DemoMixin:
         self.io.writeln("  Expect: |11> with high probability")
         self.cmd_list()
         self.cmd_run()
+        self._verify_demo(['11'], 0.95, 'Superdense: message=11')
 
     def _demo_random(self):
         self.cmd_new()
@@ -322,6 +353,38 @@ class DemoMixin:
         self.io.writeln("  Alice sends |+> to Bob. Expect Bob's qubit ~ 50/50.")
         self.cmd_list()
         self.cmd_run()
+        # Fidelity: |+> teleported to Bob B[0]
+        # Z-basis: should be 50/50 (|+> has equal P(0) and P(1))
+        # X-basis: should be ~100% |0> (|+> is eigenstate of X with eigenvalue +1)
+        if self.last_counts:
+            total = sum(self.last_counts.values())
+            b0_counts = {'0': 0, '1': 0}
+            for state, count in self.last_counts.items():
+                parts = state.split('|')
+                if len(parts) >= 2:
+                    bob_bit = parts[-1][-1]
+                    b0_counts[bob_bit] = b0_counts.get(bob_bit, 0) + count
+            b_total = sum(b0_counts.values())
+            if b_total > 0:
+                p0 = b0_counts['0'] / b_total
+                z_fidelity = 1.0 - abs(p0 - 0.5) * 2
+                self.io.writeln(f"  Z-basis fidelity: {z_fidelity:.3f} "
+                               f"(Bob B[0]: P(0)={p0:.3f}, P(1)={1-p0:.3f})")
+        # X-basis verification via LOCC statevector
+        if self.locc and self.locc.joint:
+            import numpy as np
+            sv = np.ascontiguousarray(self.locc.sv).ravel()
+            n = self.locc.n_total
+            # Bob qubit 0 is at global index = offset_B + 0
+            bob_q = self.locc.offsets[1]
+            sv_t = sv.reshape([2] * n)
+            ax = n - 1 - bob_q
+            t0 = np.moveaxis(sv_t, ax, 0)[0].flatten()
+            t1 = np.moveaxis(sv_t, ax, 0)[1].flatten()
+            rho_01 = np.sum(np.conj(t0) * t1)
+            expect_x = float(2 * rho_01.real)
+            self.io.writeln(f"  X-basis verification: <X> on Bob B[0] = {expect_x:.3f} "
+                           f"(ideal |+> = 1.000)")
 
     def _demo_locc_coord(self):
         """Classical coordination between independent registers (SPLIT mode)."""

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/engine_state.py

@@ -39,6 +39,8 @@ class Engine:
         self.sim_method: str = 'automatic'
         self.sim_device: str = 'CPU'
         self._noise_model: Any = None
+        self._noise_depol_p: float = 0.0
+        self._seed: int | None = None
         self._max_iterations: int = MAX_LOOP_ITERATIONS
         self._include_depth: int = 0
 

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/executor.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 from qiskit import QuantumCircuit, transpile
-from qiskit_aer import AerSimulator
 
 from qubasic_core.engine import (
     GATE_TABLE, GATE_ALIASES,
@@ -624,7 +623,7 @@ class ExecutorMixin:
                               run_vars=dict(self.variables), qc=qc)
         self._exec_line(line, ctx=imm_ctx)
         qc.save_statevector()
-        backend = AerSimulator(method='statevector')
+        backend = self._make_backend('statevector')
         result = backend.run(transpile(qc, backend)).result()
         sv = np.array(result.get_statevector())
         self.last_sv = sv

{qubasic-0.3.1 → qubasic-0.4.1}/qubasic_core/expression.py

@@ -12,44 +12,28 @@ from typing import Any
 
 
 def _replace_dollar_outside_strings(expr_str: str) -> str:
-    """Apply $->_S_ replacement only outside quoted string literals."""
-    result: list[str] = []
+    """Apply $->_S_ replacement only outside quoted string literals.
+
+    Single pass: splits on quote boundaries, substitutes only in
+    unquoted segments.
+    """
+    parts: list[str] = []
     i = 0
     n = len(expr_str)
     while i < n:
         ch = expr_str[i]
         if ch in ('"', "'"):
-            # Copy the entire quoted region verbatim
             quote = ch
             j = i + 1
             while j < n and expr_str[j] != quote:
                 j += 1
-            # Include closing quote (or end of string if missing)
-            result.append(expr_str[i:j + 1])
-            i = j + 1
-        else:
-            result.append(ch)
-            i += 1
-    text = ''.join(result)
-    # Now apply the substitution only to non-quoted segments
-    parts: list[str] = []
-    i = 0
-    n = len(text)
-    while i < n:
-        ch = text[i]
-        if ch in ('"', "'"):
-            quote = ch
-            j = i + 1
-            while j < n and text[j] != quote:
-                j += 1
-            parts.append(text[i:j + 1])
+            parts.append(expr_str[i:j + 1])
             i = j + 1
         else:
-            # Accumulate non-quoted text
             j = i
-            while j < n and text[j] not in ('"', "'"):
+            while j < n and expr_str[j] not in ('"', "'"):
                 j += 1
-            segment = text[i:j]
+            segment = expr_str[i:j]
             parts.append(re.sub(r'(\w+)\$', r'\1_S_', segment))
             i = j
     return ''.join(parts)