qubasic 0.7.0__tar.gz → 0.8.0__tar.gz

{qubasic-0.7.0 → qubasic-0.8.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.8.0 (2026-06-19)
+
+### Added
+- Partial measurement: `MEASURE 0, 2` measures a subset of qubits and reports the histogram over just those qubits (the bare `MEASURE` still measures all).
+- Process tomography: `PTOMOGRAPHY` reconstructs the circuit's Pauli Transfer Matrix (the unitary, or the full noisy channel via the superoperator when a noise model is active), and reports the trace-preserving and unital flags plus the average gate fidelity to the identity. Limited to <= 2 qubits.
+- Randomized benchmarking: `RB [max_length] [samples]` runs single-qubit RB over the 24-element Clifford group (each sequence ends with its recovery Clifford), fits the survival decay `p(m) = A f^m + B`, and reports the decay `f` and the error per Clifford `(1 - f)/2`. Reflects the active noise model.
+
 ## 0.7.0 (2026-06-19)
 
 ### Added

{qubasic-0.7.0/qubasic.egg-info → qubasic-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.7.0
+Version: 0.8.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -417,12 +417,21 @@ STATS SHOW               Show mean/stddev/min/max per state
 STATS CLEAR              Reset accumulator
 ```
 
-### State comparison
+### Characterization
 ```
 FIDELITY |BELL>          State fidelity |<target|psi>|^2 vs a named state
 FIDELITY [0.707,0,0,0.707]   ...or an explicit amplitude list
-TOMOGRAPHY               Reconstruct the density matrix from Pauli expectations
+TOMOGRAPHY               State tomography: reconstruct rho from Pauli expectations
 TOMOGRAPHY 2000          Statistical tomography (2000 shots per Pauli basis)
+PTOMOGRAPHY              Process tomography: reconstruct the Pauli Transfer Matrix (<=2 qubits)
+RB                       Single-qubit randomized benchmarking (fits decay -> error/Clifford)
+RB 64 12                 Sequence lengths up to 64, 12 random sequences each
+```
+
+### Partial measurement
+```
+MEASURE                  Measure all qubits (the default)
+MEASURE 0, 2             Measure only qubits 0 and 2; histogram is over that subset
 ```
 
 ## Algorithm primitives

{qubasic-0.7.0 → qubasic-0.8.0}/README.md

@@ -384,12 +384,21 @@ STATS SHOW               Show mean/stddev/min/max per state
 STATS CLEAR              Reset accumulator
 ```
 
-### State comparison
+### Characterization
 ```
 FIDELITY |BELL>          State fidelity |<target|psi>|^2 vs a named state
 FIDELITY [0.707,0,0,0.707]   ...or an explicit amplitude list
-TOMOGRAPHY               Reconstruct the density matrix from Pauli expectations
+TOMOGRAPHY               State tomography: reconstruct rho from Pauli expectations
 TOMOGRAPHY 2000          Statistical tomography (2000 shots per Pauli basis)
+PTOMOGRAPHY              Process tomography: reconstruct the Pauli Transfer Matrix (<=2 qubits)
+RB                       Single-qubit randomized benchmarking (fits decay -> error/Clifford)
+RB 64 12                 Sequence lengths up to 64, 12 random sequences each
+```
+
+### Partial measurement
+```
+MEASURE                  Measure all qubits (the default)
+MEASURE 0, 2             Measure only qubits 0 and 2; histogram is over that subset
 ```
 
 ## Algorithm primitives

{qubasic-0.7.0 → qubasic-0.8.0}/pyproject.toml

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

{qubasic-0.7.0 → qubasic-0.8.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.7.0
+Version: 0.8.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -417,12 +417,21 @@ STATS SHOW               Show mean/stddev/min/max per state
 STATS CLEAR              Reset accumulator
 ```
 
-### State comparison
+### Characterization
 ```
 FIDELITY |BELL>          State fidelity |<target|psi>|^2 vs a named state
 FIDELITY [0.707,0,0,0.707]   ...or an explicit amplitude list
-TOMOGRAPHY               Reconstruct the density matrix from Pauli expectations
+TOMOGRAPHY               State tomography: reconstruct rho from Pauli expectations
 TOMOGRAPHY 2000          Statistical tomography (2000 shots per Pauli basis)
+PTOMOGRAPHY              Process tomography: reconstruct the Pauli Transfer Matrix (<=2 qubits)
+RB                       Single-qubit randomized benchmarking (fits decay -> error/Clifford)
+RB 64 12                 Sequence lengths up to 64, 12 random sequences each
+```
+
+### Partial measurement
+```
+MEASURE                  Measure all qubits (the default)
+MEASURE 0, 2             Measure only qubits 0 and 2; histogram is over that subset
 ```
 
 ## Algorithm primitives

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/__init__.py

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

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/analysis.py

@@ -344,6 +344,164 @@ class AnalysisMixin:
         self.io.writeln(f"  Purity Tr(rho^2) = {purity:.6f}")
         self.io.writeln(f"  Fidelity to the simulated pure state = {fid:.6f}")
 
+    def cmd_ptomography(self, rest: str = '') -> None:
+        """PTOMOGRAPHY — reconstruct the circuit's process as a Pauli Transfer Matrix.
+
+        Builds the channel of the current program (the unitary, or the full
+        noisy channel when a noise model is active) and reports its PTM, where
+        R[i,j] = (1/d) Tr(P_i E(P_j)) over Pauli operators. Trace-preserving and
+        unital flags and the average gate fidelity to the identity are shown.
+        Limited to <= 2 qubits (the process matrix is 4^n x 4^n)."""
+        if not self.program:
+            self.io.writeln("?NOTHING TO CHARACTERIZE — enter a program first")
+            return
+        n = self.num_qubits
+        if n > 2:
+            self.io.writeln(f"?PTOMOGRAPHY limited to 2 qubits (4^n process matrix); have {n}")
+            return
+        import itertools
+        try:
+            qc, _ = self.build_circuit()
+            from qiskit.quantum_info import Operator, SuperOp, PTM
+            if self._noise_model is not None:
+                from qiskit_aer import AerSimulator
+                from qiskit import transpile
+                qc2 = qc.copy()
+                qc2.save_superop()
+                b = AerSimulator(method='superop', noise_model=self._noise_model)
+                res = b.run(transpile(qc2, b, optimization_level=self._transpile_opt_level)).result()
+                ptm = PTM(SuperOp(np.asarray(res.data()['superop'])))
+                src = 'noisy channel'
+            else:
+                ptm = PTM(Operator(qc))
+                src = 'unitary'
+            R = np.real(np.asarray(ptm.data))
+            labels = [''.join(p) for p in itertools.product('IXYZ', repeat=n)]
+            self.io.writeln(f"\n  Pauli Transfer Matrix ({len(R)}x{len(R)}, {src}):")
+            self.io.writeln('         ' + ''.join(f'{lb:>7}' for lb in labels))
+            for i, row in enumerate(R):
+                cells = ''.join(f'{v:+7.3f}' for v in row)
+                self.io.writeln(f"    {labels[i]:>4} {cells}")
+            tp = bool(np.allclose(R[0], [1.0] + [0.0] * (len(R) - 1), atol=1e-6))
+            unital = bool(np.allclose(R[:, 0], [1.0] + [0.0] * (len(R) - 1), atol=1e-6))
+            d = 2 ** n
+            f_avg = (float(np.trace(R)) + d) / (d * d + d)   # avg gate fidelity to identity
+            self.io.writeln(f"  Trace-preserving: {tp}   Unital: {unital}")
+            self.io.writeln(f"  Avg gate fidelity to identity: {f_avg:.6f}")
+        except Exception as e:
+            self.io.writeln(f"?PTOMOGRAPHY ERROR: {e}")
+
+    def _single_qubit_cliffords(self):
+        """Return the 24 single-qubit Cliffords as (gate_word, matrix) pairs.
+
+        Generated by BFS over words in {H, S} (which generate the group up to
+        global phase), cached on the instance. The word, applied in order, gives
+        the stored matrix, so RB sequences run as native h/s gates that the
+        active noise model decorates."""
+        cached = getattr(self, '_rb_cliffords', None)
+        if cached is not None:
+            return cached
+        from collections import deque
+        H = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
+        S = np.array([[1, 0], [0, 1j]], dtype=complex)
+        gens = (('H', H), ('S', S))
+
+        def canon(M):
+            for v in M.ravel():
+                if abs(v) > 1e-9:
+                    M = M / (v / abs(v))   # fix global phase: first nonzero entry real+
+                    break
+            return tuple(np.round(M, 6).ravel())
+
+        ident = np.eye(2, dtype=complex)
+        table = {canon(ident): ([], ident)}
+        queue = deque(table)
+        while queue:
+            word, M = table[queue.popleft()]
+            for gname, G in gens:
+                M2 = G @ M
+                k2 = canon(M2)
+                if k2 not in table:
+                    table[k2] = (word + [gname], M2)
+                    queue.append(k2)
+        self._rb_cliffords = list(table.values())
+        return self._rb_cliffords
+
+    def cmd_rb(self, rest: str = '') -> None:
+        """RB [max_length] [samples] — single-qubit randomized benchmarking.
+
+        Runs random Clifford sequences of growing length, each ending with the
+        recovery Clifford that inverts the sequence (ideal output |0>), measures
+        the survival probability, and fits p(m) = A f^m + B to extract the decay
+        f and the error per Clifford (1 - f)/2. Reflects the active noise model
+        (with no noise, f ~ 1). Defaults: max_length 16, 10 sequences per length."""
+        parts = rest.split()
+        max_len = int(parts[0]) if len(parts) > 0 else 16
+        samples = int(parts[1]) if len(parts) > 1 else 10
+        cliffords = self._single_qubit_cliffords()
+        gate_method = {'H': 'h', 'S': 's'}
+        from qiskit import QuantumCircuit, transpile
+        from qiskit_aer import AerSimulator
+        backend = AerSimulator(noise_model=self._noise_model) if self._noise_model else AerSimulator()
+        shots = max(200, self.shots)
+        if self._seed is not None:
+            np.random.seed(self._seed)
+        lengths = []
+        m = 1
+        while m <= max_len:
+            lengths.append(m)
+            m *= 2
+        self.io.writeln(f"\n  Randomized benchmarking (1 qubit, {samples} sequences/length):")
+        self.io.writeln(f"  {'length':>8}  {'survival':>9}")
+        survival = []
+        for m in lengths:
+            ps = []
+            for _ in range(samples):
+                qc = QuantumCircuit(1, 1)
+                net = np.eye(2, dtype=complex)
+                for idx in np.random.randint(len(cliffords), size=m):
+                    word, mat = cliffords[idx]
+                    for g in word:
+                        getattr(qc, gate_method[g])(0)
+                    net = mat @ net
+                inv = net.conj().T
+                ridx = max(range(len(cliffords)),
+                           key=lambda i: abs(np.trace(cliffords[i][1].conj().T @ inv)))
+                for g in cliffords[ridx][0]:
+                    getattr(qc, gate_method[g])(0)
+                qc.measure(0, 0)
+                kw = {'shots': shots}
+                if self._seed is not None:
+                    kw['seed_simulator'] = self._seed
+                # optimization_level=0: the sequence composes to ~identity, so any
+                # gate cancellation would strip the gates (and their noise) and
+                # flatten the decay. RB needs every gate physically executed.
+                counts = backend.run(
+                    transpile(qc, backend, optimization_level=0), **kw).result().get_counts()
+                ps.append(counts.get('0', 0) / sum(counts.values()))
+            mean = float(np.mean(ps))
+            survival.append(mean)
+            self.io.writeln(f"  {m:>8}  {mean:>9.4f}")
+
+        if max(survival) - min(survival) < 0.02:
+            # Flat survival: no measurable decay, so f is underdetermined. The
+            # physical reading is no error (f = 1), not whatever the fit drifts to.
+            A, f, B = 0.0, 1.0, float(np.mean(survival))
+        else:
+            def obj(v):
+                A, f, B = v
+                f = min(max(f, 0.0), 1.2)
+                return sum((p - (A * f ** mm + B)) ** 2 for mm, p in zip(lengths, survival))
+
+            best, _ = self._nelder_mead(obj, [0.5, 0.99, 0.5], 400, 0.2)
+            A, f, B = best
+            f = min(max(f, 0.0), 1.0)
+        epc = (1.0 - f) / 2.0
+        self.io.writeln(f"  fit p(m) = {A:.3f} * {f:.5f}^m + {B:.3f}")
+        self.io.writeln(f"  Decay f = {f:.5f}   error per Clifford = {epc:.5f}")
+        self.variables['_RB_F'] = f
+        self.variables['_RB_EPC'] = epc
+
     def cmd_ram(self) -> None:
         """RAM — show memory budget, per-instance cost, and parallelism estimates."""
         ram = _get_ram_gb()

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/executor.py

@@ -111,6 +111,8 @@ class ExecutorMixin:
         qc = QuantumCircuit(self.num_qubits)
         # Fresh mid-circuit measurement registry for this build (dynamic IF).
         self._classical_bits = {}
+        # Partial-measurement subset (None = measure all at the end).
+        self._measure_subset = None
         # Apply any qubit state preparation requested via POKE to $0100.
         if getattr(self, '_poke_state_prep', None):
             self._emit_poke_state_prep(qc)
@@ -161,6 +163,10 @@ class ExecutorMixin:
 
             if isinstance(parsed, MeasureStmt):
                 has_measure = True
+                if parsed.qubits:
+                    self._measure_subset = [
+                        self._resolve_qubit(q)
+                        for q in parsed.qubits.replace(',', ' ').split()]
                 if self._on_measure_target is not None and not self._on_measure_fired:
                     self._on_measure_fired = True
                     self._gosub_stack.append(ctx.ip + 1)

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/parser.py

@@ -517,6 +517,11 @@ def parse_stmt(raw: str) -> Stmt:
         return RemStmt(raw=raw)
     if upper == 'MEASURE':
         return MeasureStmt(raw=raw)
+    # MEASURE <qubit list> — partial measurement of a subset (digits/commas only,
+    # so MEASURE_X and similar are not captured here).
+    m_sub = re.match(r'MEASURE\s+([\d,\s]+)$', text, re.IGNORECASE)
+    if m_sub:
+        return MeasureStmt(raw=raw, qubits=m_sub.group(1).strip())
     if upper == 'END':
         return EndStmt(raw=raw)
     if upper == 'END IF':

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/qol.py

@@ -96,7 +96,7 @@ _ALL_COMMANDS = [
     'DIFF', 'PLOT', 'THEME', 'CLIP', 'EXPLAIN',
     'QFT', 'IQFT', 'DIFFUSE', 'MCX', 'MCZ', 'MCP', 'QADD', 'QADDC', 'QPE',
     'MINIMIZE', 'GRADIENT', 'FIDELITY', 'TOMOGRAPHY', 'COUPLING', 'BASIS',
-    'LOADQASM', 'SET_DENSITY', 'SAVEPNG',
+    'LOADQASM', 'SET_DENSITY', 'SAVEPNG', 'PTOMOGRAPHY', 'RB', 'MEASURE',
     # Gates
     'H', 'X', 'Y', 'Z', 'S', 'T', 'SDG', 'TDG', 'SX', 'ID',
     'RX', 'RY', 'RZ', 'P', 'U', 'CX', 'CZ', 'CY', 'CH',

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/statements.py

@@ -19,7 +19,7 @@ class RemStmt(Stmt):
 
 @dataclass(frozen=True, slots=True)
 class MeasureStmt(Stmt):
-    pass
+    qubits: str = ''   # '' = measure all; else a comma/space list of qubit indices
 
 @dataclass(frozen=True, slots=True)
 class EndStmt(Stmt):

{qubasic-0.7.0 → qubasic-0.8.0}/qubasic_core/terminal.py

@@ -487,6 +487,8 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         'PROBE': 'cmd_probe',
         # Classic
         'RESTORE': 'cmd_restore',
+        # Characterization
+        'PTOMOGRAPHY': 'cmd_ptomography',
     }
     _CMD_WITH_ARG = {
         'LIST': 'cmd_list', 'QUBITS': 'cmd_qubits', 'SHOTS': 'cmd_shots',
@@ -519,7 +521,7 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         'IMPORT': 'cmd_import', 'TYPE': 'cmd_type',
         'SAMPLE': 'cmd_sample', 'ESTIMATE': 'cmd_estimate', 'BENCH': 'cmd_bench',
         'MINIMIZE': 'cmd_minimize', 'GRADIENT': 'cmd_gradient',
-        'FIDELITY': 'cmd_fidelity', 'TOMOGRAPHY': 'cmd_tomography',
+        'FIDELITY': 'cmd_fidelity', 'TOMOGRAPHY': 'cmd_tomography', 'RB': 'cmd_rb',
         'COUPLING': 'cmd_coupling', 'BASIS': 'cmd_basis',
         'LOADQASM': 'cmd_loadqasm', 'SAVEPNG': 'cmd_savepng',
         'SET_STATE': 'cmd_set_state', 'SET_DENSITY': 'cmd_set_density',
@@ -1325,7 +1327,16 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         if self.sim_method in ('unitary', 'superop'):
             qc.save_unitary(label='unitary') if self.sim_method == 'unitary' else qc.save_superop(label='superop')
         elif has_measure:
-            qc.measure_all()
+            subset = getattr(self, '_measure_subset', None)
+            if subset:
+                # Partial measurement: report counts over the chosen qubits only.
+                from qiskit.circuit import ClassicalRegister
+                cr = ClassicalRegister(len(subset), 'sub')
+                qc.add_register(cr)
+                for i, q in enumerate(subset):
+                    qc.measure(q, cr[i])
+            else:
+                qc.measure_all()
 
         self.last_circuit = qc
         self._last_transpiled = None

{qubasic-0.7.0 → qubasic-0.8.0}/tests/test_qubasic.py

@@ -1648,6 +1648,47 @@ class TestNewCommands(unittest.TestCase):
         self.assertIsNotNone(t._last_transpiled)
 
 
+class TestCharacterization(unittest.TestCase):
+    """Partial measurement, process tomography, randomized benchmarking."""
+
+    def test_partial_measurement(self):
+        # GHZ measured on a subset gives correlated subset counts.
+        t = QBasicTerminal(); t.num_qubits = 3; t.shots = 1000; t._seed = 1
+        for ln in ['10 H 0', '20 CX 0,1', '30 CX 0,2', '40 MEASURE 0,2']:
+            t.process(ln, track_undo=False)
+        capture(t.cmd_run)
+        self.assertTrue(all(len(k) == 2 for k in t.last_counts))   # two-bit keys
+        self.assertEqual(set(t.last_counts), {'00', '11'})         # correlated
+        # single-qubit subset gives one-bit keys
+        t2 = QBasicTerminal(); t2.num_qubits = 3; t2.shots = 1000; t2._seed = 1
+        for ln in ['10 H 0', '20 CX 0,1', '30 MEASURE 1']:
+            t2.process(ln, track_undo=False)
+        capture(t2.cmd_run)
+        self.assertEqual(set(t2.last_counts), {'0', '1'})
+
+    def test_process_tomography(self):
+        # X gate: PTM = diag(1, 1, -1, -1).
+        t = QBasicTerminal(); t.num_qubits = 1
+        t.process('10 X 0', track_undo=False)
+        _, out = capture(t.cmd_ptomography)
+        self.assertIn('Trace-preserving: True', out)
+        self.assertIn('-1.000', out)            # Y and Z rows flip sign
+        # H gate maps Z -> X, so the X column has a +1 off the diagonal.
+        t2 = QBasicTerminal(); t2.num_qubits = 1
+        t2.process('10 H 0', track_undo=False)
+        _, out2 = capture(t2.cmd_ptomography)
+        self.assertIn('Trace-preserving: True', out2)
+
+    def test_randomized_benchmarking(self):
+        # Noiseless single-qubit RB: perfect recovery, f = 1, error per Clifford = 0.
+        t = QBasicTerminal(); t.num_qubits = 1; t.shots = 400; t._seed = 3
+        capture(t.cmd_rb, '4 3')
+        self.assertAlmostEqual(t.variables['_RB_F'], 1.0, places=6)
+        self.assertAlmostEqual(t.variables['_RB_EPC'], 0.0, places=6)
+        # 24 single-qubit Cliffords are generated.
+        self.assertEqual(len(t._single_qubit_cliffords()), 24)
+
+
 if __name__ == '__main__':
     if hasattr(sys.stdout, 'reconfigure'):
         sys.stdout.reconfigure(encoding='utf-8')