qubasic 0.3.1__tar.gz → 0.4.0__tar.gz

qubasic-0.4.0/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+## 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.egg-info → qubasic-0.4.0}/PKG-INFO

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.3.1"
+version = "0.4.0"
 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.0/qubasic.egg-info}/PKG-INFO

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

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

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

{qubasic-0.3.1 → qubasic-0.4.0}/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.0}/qubasic_core/demos.py

@@ -1,4 +1,4 @@
-"""QUBASIC built-in demo circuits."""
+"""QUBASIC built-in demo circuits with self-verification."""
 
 
 class DemoMixin:
@@ -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.0}/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.0}/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.0}/qubasic_core/locc_commands.py

@@ -17,6 +17,13 @@ class LOCCCommandsMixin:
     self.variables, self.eval_expr(), self.io.
     """
 
+    def _locc_noise_param(self) -> float:
+        """Return the scalar depolarizing probability for LOCC noise.
+
+        Stored by cmd_noise when a depolarizing model is set.
+        """
+        return getattr(self, '_noise_depol_p', 0.0)
+
     def cmd_locc(self, rest):
         args = rest.upper().split()
         if not args:
@@ -90,7 +97,8 @@ class LOCCCommandsMixin:
 
         # Pre-check RAM before allocating
         mode = "JOINT" if joint else "SPLIT"
-        temp_eng = LOCCEngine(sizes, joint=joint)
+        noise_p = self._locc_noise_param()
+        temp_eng = LOCCEngine(sizes, joint=joint, noise_param=noise_p)
         tot, peak = temp_eng.mem_gb()
         ram = _get_ram_gb()
         if ram and tot > ram[1]:
@@ -118,6 +126,9 @@ class LOCCCommandsMixin:
             self.io.writeln(f"  Joint statevector — use SHARE for pre-shared entanglement")
         if peak > 30:
             self.io.writeln(f"  WARNING: large registers. Keep SHOTS low for SEND-based protocols.")
+        if self._noise_model and noise_p == 0:
+            self.io.writeln(f"  WARNING: non-depolarizing noise model active but not supported "
+                           f"in LOCC numpy path. Only NOISE depolarizing propagates to LOCC.")
 
     def cmd_send(self, rest):
         if not self.locc_mode:
@@ -172,15 +183,52 @@ class LOCCCommandsMixin:
         reg_desc = '  '.join(f"{n}={s}q" for n, s in
                              zip(self.locc.names, self.locc.sizes))
         self.io.writeln(f"  Registers: {reg_desc}  ({self.locc.n_regs} parties)")
+
+        # Entanglement creation
+        n_shares = sum(1 for l in self.program.values()
+                       if re.search(r'\bSHARE\b', l, re.IGNORECASE))
+        if n_shares:
+            self.io.writeln(f"  Entanglement: {n_shares} SHARE operation(s)")
+
+        # Classical communication
         n_classical = len(self.locc.classical)
         self.io.writeln(f"  Classical bits exchanged: {n_classical}")
         if self.locc.classical:
             for k, v in self.locc.classical.items():
                 self.io.writeln(f"    {k} = {v}")
+
+        # Measurement outcomes and correction paths
         n_sends = sum(1 for l in self.program.values()
                       if re.search(r'\bSEND\b', l, re.IGNORECASE))
+        n_ifs = sum(1 for l in self.program.values()
+                    if re.search(r'\bIF\b.*\bTHEN\b.*@', l, re.IGNORECASE))
         self.io.writeln(f"  SEND operations: {n_sends}")
+        self.io.writeln(f"  Conditional corrections: {n_ifs}")
         self.io.writeln(f"  Communication rounds: ~{n_sends}")
+
+        # Branch statistics from classical bits
+        if n_sends > 0 and self.locc.classical:
+            bits = [v for v in self.locc.classical.values() if isinstance(v, (int, float))]
+            if bits:
+                n0 = sum(1 for b in bits if b == 0)
+                n1 = sum(1 for b in bits if b == 1)
+                self.io.writeln(f"  Branch stats: {n0} zeros, {n1} ones "
+                               f"(last run)")
+
+        # Correction log (from last run)
+        log = getattr(self.locc, 'correction_log', [])
+        if log:
+            self.io.writeln(f"  Correction log ({len(log)} entries, last run):")
+            for entry in log[-20:]:  # cap display
+                self.io.writeln(f"    {entry}")
+            if len(log) > 20:
+                self.io.writeln(f"    ... ({len(log) - 20} more)")
+
+        # Noise
+        noise_p = getattr(self.locc, 'noise_param', 0.0)
+        if noise_p > 0:
+            self.io.writeln(f"  Noise: depolarizing p={noise_p}")
+
         tot, peak = self.locc.mem_gb()
         self.io.writeln(f"  Memory: {tot:.1f} GB")
         self.io.writeln('')

{qubasic-0.3.1 → qubasic-0.4.0}/qubasic_core/locc_engine.py

@@ -26,12 +26,19 @@ class LOCCEngine:
     JOINT mode: one statevector, LOCC constraints enforced.
     """
 
-    def __init__(self, sizes: list[int], joint: bool = False):
-        """Initialize LOCC engine with given register sizes."""
+    def __init__(self, sizes: list[int], joint: bool = False,
+                 noise_param: float = 0.0):
+        """Initialize LOCC engine with given register sizes.
+
+        noise_param: depolarizing probability per gate (0 = noiseless).
+        When > 0, after each gate application a random Pauli (X, Y, or Z)
+        is applied to each target qubit with probability noise_param/3.
+        """
         self.sizes = list(sizes)
         self.n_regs = len(self.sizes)
         self.names = [chr(ord('A') + i) for i in range(self.n_regs)]
         self.joint = joint
+        self.noise_param = noise_param
         self.classical = {}
         # Precompute offsets for JOINT mode
         self.offsets = []
@@ -58,6 +65,7 @@ class LOCCEngine:
     def reset(self) -> None:
         """Reset all registers to |0> and clear classical state."""
         self.classical.clear()
+        self.correction_log: list[str] = []
         if self.joint:
             self.sv = np.zeros(2**self.n_total, dtype=complex)
             self.sv[0] = 1.0
@@ -93,8 +101,36 @@ class LOCCEngine:
                     f"Qubit {q} out of range for register {reg} (size {size})"
                 )
 
+    def _apply_depolarizing(self, reg: str, qubits: list[int]) -> None:
+        """Apply single-qubit depolarizing noise to each target qubit.
+
+        For depolarizing parameter p, each qubit independently gets a random
+        Pauli (X, Y, or Z) with probability p/3 each, or identity with
+        probability 1-p. This is the Monte Carlo implementation of the
+        depolarizing channel.
+        """
+        if self.noise_param <= 0:
+            return
+        _paulis = [
+            _np_gate_matrix('X', ()),
+            _np_gate_matrix('Y', ()),
+            _np_gate_matrix('Z', ()),
+        ]
+        for q in qubits:
+            r = np.random.random()
+            if r < self.noise_param:
+                # Pick a random Pauli
+                pauli = _paulis[np.random.randint(3)]
+                if self.joint:
+                    idx = self._idx(reg)
+                    actual_q = q + self.offsets[idx]
+                    self.sv = _apply_gate_np(self.sv, pauli, [actual_q], self.n_total)
+                else:
+                    size = self.sizes[self._idx(reg)]
+                    self.svs[reg] = _apply_gate_np(self.svs[reg], pauli, [q], size)
+
     def apply(self, reg: str, gate_name: str, params: tuple[float, ...], qubits: list[int]) -> None:
-        """Apply a gate to a specific register."""
+        """Apply a gate to a specific register, then apply noise if configured."""
         self._check_qubits(reg, qubits)
         matrix = _np_gate_matrix(gate_name, tuple(params))
         if self.joint:
@@ -104,6 +140,7 @@ class LOCCEngine:
         else:
             size = self.sizes[self._idx(reg)]
             self.svs[reg] = _apply_gate_np(self.svs[reg], matrix, qubits, size)
+        self._apply_depolarizing(reg, qubits)
 
     def share(self, reg1: str, q1: int, reg2: str, q2: int) -> None:
         """Create Bell pair |Phi+> between reg1[q1] and reg2[q2]. JOINT only."""
@@ -116,7 +153,10 @@ class LOCCEngine:
         actual1 = q1 + self.offsets[self._idx(reg1)]
         actual2 = q2 + self.offsets[self._idx(reg2)]
         self.sv = _apply_gate_np(self.sv, h, [actual1], self.n_total)
+        self._apply_depolarizing(reg1, [q1])
         self.sv = _apply_gate_np(self.sv, cx, [actual1, actual2], self.n_total)
+        self._apply_depolarizing(reg1, [q1])
+        self._apply_depolarizing(reg2, [q2])
 
     def send(self, reg: str, qubit: int) -> int:
         """Measure a qubit (Born rule) and return the classical outcome."""
@@ -184,6 +224,7 @@ class LOCCEngine:
         else:
             size = self.sizes[self._idx(reg)]
             self.svs[reg] = _apply_gate_np(self.svs[reg], matrix, qubits, size)
+        self._apply_depolarizing(reg, qubits)
 
     def mem_gb(self) -> tuple[float, float]:  # (total_gb, peak_gb)
         """Return (total_gb, peak_gb) realistic memory estimates including overhead."""

{qubasic-0.3.1 → qubasic-0.4.0}/qubasic_core/locc_execution.py

@@ -41,6 +41,8 @@ class LOCCExecutionMixin:
             self._locc_run_with_send(sorted_lines, has_measure)
         else:
             self._locc_run_vectorized(sorted_lines, has_measure)
+        # Sync last_sv from LOCC engine so EXPECT/DENSITY/BLOCH work
+        self.last_sv = self._active_sv
 
     def _locc_run_with_send(self, sorted_lines, has_measure):
         """LOCC execution with SEND — prefix/suffix split optimization.
@@ -147,11 +149,51 @@ class LOCCExecutionMixin:
             self.last_counts = counts_joint
 
     def _locc_run_vectorized(self, sorted_lines, has_measure):
-        """LOCC execution without SEND — single execution, vectorized sampling."""
+        """LOCC execution without SEND — single execution, vectorized sampling.
+
+        When noise is active, re-executes per shot so that Monte Carlo noise
+        fires independently each time (matching the SEND path behavior).
+        """
         sizes_str = '+'.join(str(s) for s in self.locc.sizes)
         mode = "JOINT" if self.locc.joint else "SPLIT"
         t0 = time.time()
 
+        noisy = getattr(self.locc, 'noise_param', 0.0) > 0
+
+        if noisy and has_measure:
+            # Per-shot execution so noise fires independently each time
+            per_reg = {name: {} for name in self.locc.names}
+            counts_joint = {}
+            for _shot in range(self.shots):
+                self.locc.reset()
+                try:
+                    self._locc_execute_program(sorted_lines)
+                except (RuntimeError, ValueError) as e:
+                    self.io.writeln(f"?RUNTIME ERROR: {e}")
+                    return
+                if self.locc.joint:
+                    out = _sample_one_np(self.locc.sv, self.locc.n_total)
+                    parts = []
+                    pos = len(out)
+                    for i in range(self.locc.n_regs):
+                        size = self.locc.sizes[i]
+                        parts.append(out[pos - size:pos])
+                        pos -= size
+                else:
+                    parts = [_sample_one_np(self.locc.svs[name],
+                             self.locc.get_size(name))
+                             for name in self.locc.names]
+                for name, bits in zip(self.locc.names, parts):
+                    per_reg[name][bits] = per_reg[name].get(bits, 0) + 1
+                jkey = '|'.join(parts)
+                counts_joint[jkey] = counts_joint.get(jkey, 0) + 1
+            dt = time.time() - t0
+            self.io.writeln(f"\nRAN {len(self.program)} lines, LOCC {mode} "
+                            f"{sizes_str}q, {self.shots} shots in {dt:.2f}s")
+            self._locc_display_results(per_reg, counts_joint)
+            self.last_counts = counts_joint if counts_joint else per_reg.get('A', {})
+            return
+
         self.locc.reset()
         try:
             self._locc_execute_program(sorted_lines)
@@ -245,6 +287,8 @@ class LOCCExecutionMixin:
             run_vars[parsed.var] = outcome
             self.variables[parsed.var] = outcome
             self.locc.classical[parsed.var] = outcome
+            self.locc.correction_log.append(
+                f"SEND {parsed.reg}[{qubit}] -> {parsed.var}={outcome}")
             return ExecResult.ADVANCE
         if isinstance(parsed, ShareStmt):
             self.locc.share(parsed.reg1, parsed.q1, parsed.reg2, parsed.q2)