qubasic 0.16.0__tar.gz → 0.18.0__tar.gz

{qubasic-0.16.0 → qubasic-0.18.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.18.0 (2026-07-03)
+
+### Added
+- `OPTION ENDIAN BIG|LITTLE` — bitstring display order, the BASIC-flavored sibling of `OPTION BASE`. BIG shows qubit 0 leftmost (the textbook order) across every displayed bitstring: histograms and their bit-order header, STATE, PROBS, STEP's live statevector, SWEEP lines, STATS, LOCC register and joint histograms (per-register, keeping the A|B|C order), CSV, and the JSON `counts` (whose `bit_order` field records the active convention, as does STATUS). Bitstring-shaped input follows the display, so the `AMPLIFY` target you type is the histogram line you read. Internal counts keys and statevector indexing keep the qiskit little-endian order, so programs that string-match keys are unaffected.
+
+### Changed
+- `SAVE` persists `OPTION BASE` and `OPTION ENDIAN`, so a LOADed program restores its conventions.
+
+## 0.17.0 (2026-07-02)
+
+Hardening from an SMT-verifier triage (touchstone-prover over all 651
+functions: 153 proved trap-free, 3 refutations traced, none reachable from
+the language surface).
+
+### Changed
+- `_pmul` raises a clear ValueError on a non-Pauli character and `_emit_mcz` on an empty qubit list, instead of a raw KeyError/IndexError — both are internal preconditions (every caller feeds alphabet-constrained values), now self-documenting.
+- `_eval_with_vars` declares the ParameterExpression passthrough in its return annotation instead of claiming `-> float`.
+
 ## 0.16.0 (2026-07-02)
 
 Research-grade error correction, per-method scale, parametric variational

{qubasic-0.16.0/qubasic.egg-info → qubasic-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.16.0
+Version: 0.18.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -284,6 +284,8 @@ ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
+(`OPTION ENDIAN BIG|LITTLE`, the other OPTION toggle, lives under Display.)
+
 `DIM a(n)` is inclusive: it spans indices base..n, so the declared top index is valid. A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
 
 ## Control flow
@@ -396,6 +398,17 @@ DENSITY                  Density matrix
 
 Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
 
+```
+OPTION ENDIAN BIG        Display bitstrings big-endian (qubit 0 leftmost, the textbook order)
+OPTION ENDIAN LITTLE     Back to the default (qubit 0 rightmost, the qiskit order)
+```
+
+The toggle covers every displayed bitstring (histograms, STATE, PROBS, STEP,
+SWEEP, STATS, LOCC registers, CSV, and the JSON `counts` — whose `bit_order`
+field records the active convention) and the bitstring-shaped inputs that
+mirror the display (`AMPLIFY`). Internal counts keys and statevector indexing
+keep the qiskit order, so programs that string-match keys are unaffected.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

{qubasic-0.16.0 → qubasic-0.18.0}/README.md

@@ -243,6 +243,8 @@ ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
+(`OPTION ENDIAN BIG|LITTLE`, the other OPTION toggle, lives under Display.)
+
 `DIM a(n)` is inclusive: it spans indices base..n, so the declared top index is valid. A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
 
 ## Control flow
@@ -355,6 +357,17 @@ DENSITY                  Density matrix
 
 Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
 
+```
+OPTION ENDIAN BIG        Display bitstrings big-endian (qubit 0 leftmost, the textbook order)
+OPTION ENDIAN LITTLE     Back to the default (qubit 0 rightmost, the qiskit order)
+```
+
+The toggle covers every displayed bitstring (histograms, STATE, PROBS, STEP,
+SWEEP, STATS, LOCC registers, CSV, and the JSON `counts` — whose `bit_order`
+field records the active convention) and the bitstring-shaped inputs that
+mirror the display (`AMPLIFY`). Internal counts keys and statevector indexing
+keep the qiskit order, so programs that string-match keys are unaffected.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

{qubasic-0.16.0 → qubasic-0.18.0}/pyproject.toml

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

{qubasic-0.16.0 → qubasic-0.18.0/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.16.0
+Version: 0.18.0
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -284,6 +284,8 @@ ERASE data              Delete array
 OPTION BASE 1           Set array index base
 ```
 
+(`OPTION ENDIAN BIG|LITTLE`, the other OPTION toggle, lives under Display.)
+
 `DIM a(n)` is inclusive: it spans indices base..n, so the declared top index is valid. A `DIM`med array enforces its declared bounds on write; an undimensioned array grows on first assignment.
 
 ## Control flow
@@ -396,6 +398,17 @@ DENSITY                  Density matrix
 
 Bitstrings are little-endian: qubit 0 is the rightmost character. Histograms print a `q(n-1) ... q1 q0` header so the mapping is explicit.
 
+```
+OPTION ENDIAN BIG        Display bitstrings big-endian (qubit 0 leftmost, the textbook order)
+OPTION ENDIAN LITTLE     Back to the default (qubit 0 rightmost, the qiskit order)
+```
+
+The toggle covers every displayed bitstring (histograms, STATE, PROBS, STEP,
+SWEEP, STATS, LOCC registers, CSV, and the JSON `counts` — whose `bit_order`
+field records the active convention) and the bitstring-shaped inputs that
+mirror the display (`AMPLIFY`). Internal counts keys and statevector indexing
+keep the qiskit order, so programs that string-match keys are unaffected.
+
 ### Screen modes
 ```
 SCREEN 0                 Text (default)

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/__init__.py

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

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/algorithms.py

@@ -119,6 +119,8 @@ class AlgorithmsMixin:
 
     def _emit_mcz(self, qc, qs: list[int]) -> None:
         """Multi-controlled Z over qs (phase flip of the all-ones state)."""
+        if not qs:
+            raise ValueError("MCZ needs at least one qubit")
         if len(qs) == 1:
             qc.z(qs[0])
         elif len(qs) == 2:

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/algos2.py

@@ -160,6 +160,10 @@ class Algorithms2Mixin:
         n = self.num_qubits
         if len(target) != n:
             raise ValueError(f"AMPLIFY target must be {n} bits, got {len(target)}")
+        # The target reads in the active display convention, so what you see in
+        # the histogram is what you type here; internally it stays q_{n-1}..q0.
+        if getattr(self, '_endian_big', False):
+            target = target[::-1]
         # Oracle: phase-flip |target> by X-conjugating the all-ones MCZ.
         flip = [i for i, b in enumerate(target) if b == '0']  # bitstring is q_{n-1}..q0
         qubits = list(range(n))

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/classic.py

@@ -421,3 +421,17 @@ class ClassicMixin:
                 return None
             self._option_base = int(m.group(1))
         return True, ExecResult.ADVANCE
+
+    def _cf_option_endian(self, stmt: str, *, parsed=None) -> tuple[bool, ExecOutcome] | None:
+        """OPTION ENDIAN BIG|LITTLE — bitstring display order (default LITTLE,
+        the qiskit convention: qubit 0 rightmost). Display-side only: internal
+        counts keys and statevector indexing keep the qiskit order."""
+        if parsed is not None:
+            self._endian_big = parsed.big
+        else:
+            from qubasic_core.patterns import RE_OPTION_ENDIAN
+            m = RE_OPTION_ENDIAN.match(stmt)
+            if not m:
+                return None
+            self._endian_big = m.group(1).upper() == 'BIG'
+        return True, ExecResult.ADVANCE

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/cli.py

@@ -80,6 +80,8 @@ _SPEC_STATEMENTS = [
     ('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'),
+    ('OPTION', 'OPTION BASE 0|1 | OPTION ENDIAN BIG|LITTLE',
+     'array index base; bitstring display order (default LITTLE, qubit 0 rightmost)'),
 ]
 
 

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/control_flow.py

@@ -17,7 +17,7 @@ from qubasic_core.statements import (
     DataStmt, ReadStmt, OnGotoStmt, OnGosubStmt,
     SelectCaseStmt, CaseStmt, EndSelectStmt, ElseStmt, EndIfStmt,
     DoStmt, LoopStmt, ExitStmt,
-    SwapStmt, DefFnStmt, OptionBaseStmt,
+    SwapStmt, DefFnStmt, OptionBaseStmt, OptionEndianStmt,
     SubStmt, EndSubStmt, FunctionStmt, EndFunctionStmt, CallStmt,
     LocalStmt, StaticStmt, SharedStmt,
     OnErrorStmt, ResumeStmt, ErrorStmt, AssertStmt, StopStmt,
@@ -463,6 +463,7 @@ class ControlFlowMixin:
         SwapStmt:        lambda s, st, p, ls, sl, ip, rv, ef: s._cf_swap(st, rv, parsed=p),
         DefFnStmt:       lambda s, st, p, ls, sl, ip, rv, ef: s._cf_def_fn(st, rv, parsed=p),
         OptionBaseStmt:  lambda s, st, p, ls, sl, ip, rv, ef: s._cf_option_base(st, parsed=p),
+        OptionEndianStmt: lambda s, st, p, ls, sl, ip, rv, ef: s._cf_option_endian(st, parsed=p),
         # Handlers defined in subs.py (parsed is keyword-only)
         SubStmt:         lambda s, st, p, ls, sl, ip, rv, ef: s._cf_sub(st, sl, ip, parsed=p),
         EndSubStmt:      lambda s, st, p, ls, sl, ip, rv, ef: s._cf_end_sub(st, parsed=p),

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/display.py

@@ -40,22 +40,38 @@ class DisplayMixin:
         Console(file=buf, highlight=False, force_terminal=force).print(*renderables)
         self.io.write(buf.getvalue())
 
+    def _bits(self, s: str) -> str:
+        """A bitstring in the active display convention.
+
+        Little-endian (qubit 0 rightmost, the qiskit order) unless
+        OPTION ENDIAN BIG reversed it. LOCC joint keys ('0|01|1') reverse
+        per register segment, keeping the A|B|C register order.
+        """
+        if not getattr(self, '_endian_big', False):
+            return s
+        if '|' in s:
+            return '|'.join(seg[::-1] for seg in s.split('|'))
+        return s[::-1]
+
     def _bit_order_note(self, display: list) -> str | None:
         """Human-facing reminder of which bit is which qubit.
 
         Bitstrings are little-endian (qubit 0 is the rightmost character), the
-        most common source of off-by-reverse mistakes when reading a histogram.
-        When the result covers the whole register the positions are labelled
-        q(n-1) ... q1 q0; for a measured subset only the convention is shown.
+        most common source of off-by-reverse mistakes when reading a histogram,
+        unless OPTION ENDIAN BIG flipped the display order. When the result
+        covers the whole register the positions are labelled per qubit; for a
+        measured subset only the convention is shown.
         """
         if not display:
             return None
+        big = getattr(self, '_endian_big', False)
         nbits = len(display[0][0])
         nq = getattr(self, 'num_qubits', nbits)
         if nbits == nq and nbits <= 16:
-            labels = ' '.join(f'q{i}' for i in range(nbits - 1, -1, -1))
-            return f"  bit order  {labels}   (qubit 0 = rightmost)"
-        return "  bit order  qubit 0 = rightmost bit"
+            order = range(nbits) if big else range(nbits - 1, -1, -1)
+            labels = ' '.join(f'q{i}' for i in order)
+            return f"  bit order  {labels}   (qubit 0 = {'leftmost' if big else 'rightmost'})"
+        return f"  bit order  qubit 0 = {'leftmost' if big else 'rightmost'} bit"
 
     def print_histogram(self, counts: dict[str, int]) -> None:
         """Measurement histogram with optional rich-table formatting."""
@@ -96,7 +112,7 @@ class DisplayMixin:
             bar = '\u2588' * bar_len
             color = "green" if pct > 40 else "yellow" if pct > 10 else "dim"
             table.add_row(
-                f"|{state}\u27E9",
+                f"|{self._bits(state)}\u27E9",
                 str(count),
                 f"{pct:5.1f}%",
                 f"[{color}]{bar}[/{color}]")
@@ -129,7 +145,7 @@ class DisplayMixin:
             pct = 100 * count / total
             bar_len = int(HISTOGRAM_BAR_WIDTH * count / max_count)
             bar = '\u2588' * bar_len
-            ket = f"|{state}\u27E9"
+            ket = f"|{self._bits(state)}\u27E9"
             # Colorize bar by probability
             if _theme and sys.stdout.isatty():
                 rst = _theme.get('reset', '')
@@ -162,7 +178,7 @@ class DisplayMixin:
             count = 0
             for i, amp in enumerate(sv):
                 if abs(amp) > AMPLITUDE_THRESHOLD:
-                    state = format(i, f'0{n}b')
+                    state = self._bits(format(i, f'0{n}b'))
                     prob = abs(amp)**2
                     table.add_row(
                         f"|{state}\u27E9",
@@ -186,7 +202,7 @@ class DisplayMixin:
         count = 0
         for i, amp in enumerate(sv):
             if abs(amp) > AMPLITUDE_THRESHOLD:
-                state = format(i, f'0{n}b')
+                state = self._bits(format(i, f'0{n}b'))
                 prob = abs(amp)**2
                 self.io.writeln(f"  |{state}\u27E9  {amp.real:+.4f}{amp.imag:+.4f}j  "
                                f"(P={prob:.4f})")
@@ -204,7 +220,7 @@ class DisplayMixin:
         parts = []
         for i, amp in enumerate(sv):
             if abs(amp) > AMPLITUDE_THRESHOLD:
-                state = format(i, f'0{n}b')
+                state = self._bits(format(i, f'0{n}b'))
                 if abs(amp.imag) < AMPLITUDE_THRESHOLD:
                     parts.append(f"{amp.real:+.3f}|{state}\u27E9")
                 else:
@@ -221,7 +237,7 @@ class DisplayMixin:
         for i, amp in enumerate(sv):
             p = abs(amp)**2
             if p > AMPLITUDE_THRESHOLD:
-                state = format(i, f'0{n}b')
+                state = self._bits(format(i, f'0{n}b'))
                 probs.append((state, p))
 
         probs.sort(key=lambda x: -x[1])

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/expression.py

@@ -420,12 +420,12 @@ class ExpressionMixin:
             else self._safe_eval(expr)
         return int(val)
 
-    def _eval_with_vars(self, expr: str, run_vars: dict[str, Any]) -> float:
+    def _eval_with_vars(self, expr: str, run_vars: dict[str, Any]) -> float | Any:
         """Evaluate expression with runtime variables.
 
-        A qiskit ParameterExpression (present only during a parametric
-        MINIMIZE/GRADIENT/SWEEP build) passes through unfloated so it lands
-        in the circuit as a bindable parameter.
+        Returns a float, except that a qiskit ParameterExpression (present
+        only during a parametric MINIMIZE/GRADIENT/SWEEP build) passes
+        through unfloated so it lands in the circuit as a bindable parameter.
         """
         val = self._safe_eval(expr, extra_ns=run_vars)
         try:

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/file_io.py

@@ -54,6 +54,10 @@ class FileIOMixin:
                     f.write(f"METHOD {self.sim_device}\n")
                 if getattr(self, '_screen_mode', 0):
                     f.write(f"SCREEN {self._screen_mode}\n")
+                if getattr(self, '_option_base', 0):
+                    f.write(f"OPTION BASE {self._option_base}\n")
+                if getattr(self, '_endian_big', False):
+                    f.write("OPTION ENDIAN BIG\n")
                 if getattr(self, '_seed', None) is not None:
                     f.write(f"SEED {self._seed}\n")
                 if getattr(self, '_noise_spec', None):
@@ -489,7 +493,7 @@ class FileIOMixin:
             total = sum(self.last_counts.values())
             lines.append("state,count,probability")
             for state, count in sorted(self.last_counts.items(), key=lambda x: -x[1]):
-                lines.append(f"{state},{count},{count/total:.6f}")
+                lines.append(f"{self._bits(state)},{count},{count/total:.6f}")
         if self.last_sv is not None:
             lines.append("")
             lines.append("state,amplitude_re,amplitude_im,probability")

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/parser.py

@@ -33,7 +33,7 @@ from qubasic_core.statements import (
     OnGotoStmt, OnGosubStmt, SelectCaseStmt, CaseStmt,
     CallStmt, SubStmt, FunctionStmt,
     OnErrorStmt, ResumeStmt, ErrorStmt, AssertStmt,
-    SwapStmt, DefFnStmt, OptionBaseStmt,
+    SwapStmt, DefFnStmt, OptionBaseStmt, OptionEndianStmt,
     OnMeasureStmt, OnTimerStmt, DataStmt, ReadStmt,
     LocalStmt, StaticStmt, SharedStmt,
     LetStmt, LetArrayStmt, LetStrStmt, PrintStmt, PrintUsingStmt,
@@ -223,6 +223,10 @@ def _handle_option(text, raw):
     m = RE_OPTION_BASE.match(text)
     if m:
         return OptionBaseStmt(raw=raw, base=int(m.group(1)))
+    from qubasic_core.patterns import RE_OPTION_ENDIAN
+    m = RE_OPTION_ENDIAN.match(text)
+    if m:
+        return OptionEndianStmt(raw=raw, big=m.group(1).upper() == 'BIG')
     return None
 
 def _handle_data(text, raw):

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/patterns.py

@@ -79,6 +79,7 @@ RE_INPUT_FILE = re.compile(r'INPUT\s+#(\d+)\s*,\s*(\w+\$?)', re.IGNORECASE)
 RE_LINE_INPUT = re.compile(
     r'LINE\s+INPUT\s+(?:"([^"]*)"\s*,\s*)?(\w+\$?)', re.IGNORECASE)
 RE_OPTION_BASE = re.compile(r'OPTION\s+BASE\s+([01])', re.IGNORECASE)
+RE_OPTION_ENDIAN = re.compile(r'OPTION\s+ENDIAN\s+(BIG|LITTLE)', re.IGNORECASE)
 RE_IMPORT = re.compile(r'IMPORT\s+"?([^"]+)"?', re.IGNORECASE)
 RE_SAVE_EXPECT = re.compile(r'SAVE_EXPECT\s+(\w+)((?:[\s,]+\d+)*)\s*->\s*(\w+)', re.IGNORECASE)
 RE_SAVE_PROBS = re.compile(r'SAVE_PROBS\s+([\d\s,]+)\s*->\s*(\w+)', re.IGNORECASE)
@@ -169,6 +170,7 @@ __all__ = [
     "RE_INPUT_FILE",
     "RE_LINE_INPUT",
     "RE_OPTION_BASE",
+    "RE_OPTION_ENDIAN",
     "RE_IMPORT",
     "RE_SAVE_EXPECT",
     "RE_SAVE_PROBS",

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/profiler.py

@@ -186,7 +186,7 @@ class ProfilerMixin:
             variance = sum((v - mean) ** 2 for v in vals) / len(vals)
             std = math.sqrt(variance)
             prob = mean / avg_shots if avg_shots > 0 else 0
-            self.io.writeln(f"  |{state}\u27E9  {mean:>8.1f}  {std:>8.2f}  {min(vals):>6}  {max(vals):>6}  {prob:>7.4f}")
+            self.io.writeln(f"  |{self._bits(state)}\u27E9  {mean:>8.1f}  {std:>8.2f}  {min(vals):>6}  {max(vals):>6}  {prob:>7.4f}")
         self.io.writeln('')
 
     def _stats_export_csv(self, path: str) -> None:

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/qec.py

@@ -38,7 +38,12 @@ def _anticommute(a: str, b: str) -> int:
 
 
 def _pmul(a: str, b: str) -> str:
-    return ''.join(_PMUL[(pa, pb)] for pa, pb in zip(a, b))
+    # Precondition: both strings over the IXYZ alphabet. The try keeps the
+    # per-trial hot path free of per-character validation.
+    try:
+        return ''.join(_PMUL[(pa, pb)] for pa, pb in zip(a, b))
+    except KeyError as e:
+        raise ValueError(f"Pauli strings must be over IXYZ (got {e.args[0]})") from None
 
 
 def _weight(p: str) -> int:

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/statements.py

@@ -175,6 +175,10 @@ class DefFnStmt(Stmt):
 class OptionBaseStmt(Stmt):
     base: int
 
+@dataclass(frozen=True, slots=True)
+class OptionEndianStmt(Stmt):
+    big: bool
+
 @dataclass(frozen=True, slots=True)
 class OnMeasureStmt(Stmt):
     target: int

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/sweep.py

@@ -95,10 +95,10 @@ class SweepMixin:
                     ranked = sorted(counts.items(), key=lambda x: -x[1])
                     top = ranked[0]
                     bar_len = int(30 * top[1] / self.shots)
-                    top2 = f" |{ranked[1][0]}\u27E9={ranked[1][1]}" if len(ranked) > 1 else ""
+                    top2 = f" |{self._bits(ranked[1][0])}\u27E9={ranked[1][1]}" if len(ranked) > 1 else ""
                     n_unique = len(ranked)
                     bar = '\u2588' * bar_len
-                    self.io.writeln(f"  {var}={val:8.4f}  |{top[0]}\u27E9 {top[1]:>5}/{self.shots} "
+                    self.io.writeln(f"  {var}={val:8.4f}  |{self._bits(top[0])}\u27E9 {top[1]:>5}/{self.shots} "
                                    f"{bar}{top2}  ({n_unique} states)")
                     sweep_xs.append(val)
                     sweep_ys.append(top[1] / self.shots)

{qubasic-0.16.0 → qubasic-0.18.0}/qubasic_core/terminal.py

@@ -1165,7 +1165,9 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
             'method': self.sim_method,
             'device': self.sim_device,
             'seed': getattr(self, '_seed', None),
-            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
+            'bit_order': ('big-endian (qubit 0 = leftmost bit)'
+                          if getattr(self, '_endian_big', False)
+                          else 'little-endian (qubit 0 = rightmost bit)'),
             'option_base': getattr(self, '_option_base', 0),
             'locc_mode': bool(getattr(self, 'locc_mode', False)),
             'locc_registers': (list(self.locc.names)
@@ -1677,12 +1679,18 @@ class QBasicTerminal(Engine, ExecutorMixin, ExpressionMixin, DisplayMixin, DemoM
         JSON-serializable: counts, qubit/shot config, user variables, the
         statevector (when small enough), and key run-manifest fields.
         """
+        _big = getattr(self, '_endian_big', False)
+        _counts = self.last_counts or {}
+        if _big and _counts:
+            _counts = {k[::-1]: v for k, v in _counts.items()}
         out: dict = {
-            'counts': self.last_counts or {},
+            'counts': _counts,
             'num_qubits': self.num_qubits,
+            # Bitstring keys follow the active OPTION ENDIAN convention; the
+            # bit_order field is the self-describing record of which one.
             'shots': self.shots,
-            # Bitstrings are little-endian: the rightmost character is qubit 0.
-            'bit_order': 'little-endian (qubit 0 = rightmost bit)',
+            'bit_order': ('big-endian (qubit 0 = leftmost bit)' if _big
+                          else 'little-endian (qubit 0 = rightmost bit)'),
         }
         uvars = {k: v for k, v in self.variables.items()
                  if not k.startswith('_') and isinstance(v, (int, float, str, bool))}

{qubasic-0.16.0 → qubasic-0.18.0}/tests/test_golden.py

@@ -204,6 +204,56 @@ class TestAuditRegressions(unittest.TestCase):
         _, out = run_script(['METHOD statevector', 'QUBITS 100'])
         self.assertIn('RANGE', out)
 
+    def test_option_endian_big_display(self):
+        t, out = run_script([
+            'QUBITS 3',
+            'SHOTS 128',
+            'OPTION ENDIAN BIG',
+            '10 X 0',
+            '20 MEASURE',
+            'RUN',
+            'STATE',
+        ])
+        self.assertIn('qubit 0 = leftmost', out)
+        self.assertIn('|100', out)                       # displayed big-endian
+        self.assertEqual(dict(t.last_counts), {'001': 128})   # internal keys unchanged
+        self.assertEqual(t.result()['counts'], {'100': 128})  # JSON follows the toggle
+        self.assertIn('big-endian', t.result()['bit_order'])
+
+    def test_option_endian_amplify_matches_display(self):
+        # Under BIG, the AMPLIFY target reads as displayed: '100' marks the
+        # state whose histogram line says |100> (internally |001>).
+        t, _ = run_script([
+            'QUBITS 3',
+            'SHOTS 512',
+            'OPTION ENDIAN BIG',
+            '10 H 0 : H 1 : H 2',
+            '20 AMPLIFY 100',
+            '30 AMPLIFY 100',
+            '40 MEASURE',
+            'RUN',
+        ])
+        top = max(t.last_counts, key=t.last_counts.get)
+        self.assertEqual(top, '001')
+
+    def test_option_endian_save_roundtrip(self):
+        import os
+        import tempfile
+        with tempfile.TemporaryDirectory() as td:
+            old_cwd = os.getcwd()
+            os.chdir(td)
+            try:
+                run_script([
+                    'OPTION ENDIAN BIG',
+                    '10 H 0',
+                    '20 MEASURE',
+                    'SAVE endian.qb',
+                ])
+                t2, _ = run_script(['LOAD endian.qb'])
+                self.assertTrue(getattr(t2, '_endian_big', False))
+            finally:
+                os.chdir(old_cwd)
+
 
 class TestResearchQEC(unittest.TestCase):
     def test_bb_code_parameters(self):