pyqrack-cuda-complex128 2.2.4__tar.gz → 2.3.0__tar.gz

{pyqrack_cuda_complex128-2.2.4 → pyqrack_cuda_complex128-2.3.0}/MANIFEST.in

@@ -1,3 +1,4 @@
 include pyqrack/qrack_system/qrack_lib/*
 include pyqrack/qrack_system/qrack_cl_precompile/*
+include pyqrack/scripts/*
 include Makefile

{pyqrack_cuda_complex128-2.2.4/pyqrack_cuda_complex128.egg-info → pyqrack_cuda_complex128-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrack-cuda-complex128
-Version: 2.2.4
+Version: 2.3.0
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano

{pyqrack_cuda_complex128-2.2.4 → pyqrack_cuda_complex128-2.3.0}/pyqrack/qrack_ace_backend.py

@@ -28,6 +28,39 @@ try:
 except ImportError:
     _IS_QISKIT_AER_AVAILABLE = False
 
+_IS_TORCH_AVAILABLE = True
+try:
+    import torch
+    import torch.nn as nn
+except ImportError:
+    _IS_TORCH_AVAILABLE = False
+
+_BSEQ_CORRECTOR_MODEL = None
+_BSEQ_CORRECTOR_LOAD_ATTEMPTED = False
+
+
+def _get_bseq_corrector():
+    """Lazily load the trained BSEQ (Bell/CHSH) boundary corrector model.
+
+    Returns None if torch isn't available or the model file isn't found,
+    in which case callers fall back to the existing non-learned cascade.
+    Memoized at module scope: loaded at most once per process.
+    """
+    global _BSEQ_CORRECTOR_MODEL, _BSEQ_CORRECTOR_LOAD_ATTEMPTED
+    if _BSEQ_CORRECTOR_LOAD_ATTEMPTED:
+        return _BSEQ_CORRECTOR_MODEL
+    _BSEQ_CORRECTOR_LOAD_ATTEMPTED = True
+    if not _IS_TORCH_AVAILABLE:
+        return None
+    model_path = os.path.join(os.path.dirname(__file__), "bseq_corrector.jit.pt")
+    try:
+        model = torch.jit.load(model_path)
+        model.eval()
+        _BSEQ_CORRECTOR_MODEL = model
+    except Exception:
+        _BSEQ_CORRECTOR_MODEL = None
+    return _BSEQ_CORRECTOR_MODEL
+
 
 # Initial stub and concept produced through conversation with Elara
 # (the custom OpenAI GPT)
@@ -295,6 +328,10 @@ class QrackAceBackend:
 
         self._qubits = []
         self._lhv = {}
+        self._ancilla = {}
+        self._ancilla_paired = set(to_clone._ancilla_paired) if to_clone else set()
+        self._bell_partner = dict(to_clone._bell_partner) if to_clone else {}
+        self._last_y_rotation = dict(to_clone._last_y_rotation) if to_clone else {}
         sim_counts = [0] * sim_count
         sim_id = 0
         tot_qubits = 0
@@ -311,6 +348,16 @@ class QrackAceBackend:
                     qubit.append((boundary_sim_id, boundary_count))
                     boundary_count += 1
 
+                    # Reserve a second boundary-sim qubit as the ancilla,
+                    # right alongside slot2. It starts fresh (|0>) and is
+                    # Bell-paired with slot2 lazily, the first time slot2
+                    # is actually touched by a real coupling gate (see
+                    # _apply_coupling), so it taps slot2's true evolving
+                    # state rather than a disconnected pair prepared at
+                    # construction time.
+                    self._ancilla[tot_qubits] = (boundary_sim_id, boundary_count)
+                    boundary_count += 1
+
                     self._lhv[tot_qubits] = LHVQubit(
                         to_clone=(to_clone._lhv[tot_qubits] if to_clone else None)
                     )
@@ -362,7 +409,7 @@ class QrackAceBackend:
                 )
             )
 
-            # You can still call "set_sdrp," after the constructor.
+            # You can still "set_sdrp" later, after the constructor.
             # if "QRACK_QUNIT_SEPARABILITY_THRESHOLD" not in os.environ:
             #     # (1 - 1 / sqrt(2)) / 4 (but empirically tuned)
             #     self.sim[i].set_sdrp(0.073223304703363119)
@@ -372,6 +419,10 @@ class QrackAceBackend:
     def clone(self):
         return QrackAceBackend(to_clone=self)
 
+    def set_sdrp(self, sdrp):
+        for sim in self.sim:
+            sim.set_sdrp(sdrp)
+
     def measure_shots_consensus(self, q, s, n_instances=3, threshold=0.1):
         # Consensus measurement across n_instances independent clones.
         #
@@ -615,6 +666,47 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11])
 
+    # Trainable BSEQ correction: a genuine controlled-U(theta,phi,lambda)
+    # gate (QrackSimulator.mcu), with the ancilla as control and the
+    # boundary qubit (slot2) as target -- both live in the same boundary
+    # simulator, so this is a real, coherent two-qubit unitary, not a
+    # classical shadow approximation. Applied directly to the quantum
+    # state with no probability read or collapsed first, so it composes
+    # correctly even while the Bell-pair partner is still genuinely
+    # superposed. These 3 angles are the only trainable parameters;
+    # fit them empirically against the measured BSEQ S statistic (see
+    # the companion training/optimization script), not hand-derived.
+    _BSEQ_THETA = 0.5524356880065896
+    _BSEQ_PHI = 0.5611771084538236
+    _BSEQ_LAMBDA = -0.3706652126771467
+
+    def _apply_bseq_correction(self, lq):
+        """Apply the trained controlled-U BSEQ correction, if applicable.
+
+        Fires every time this boundary qubit's state is about to be read
+        out (prob()/_correct()/m()/force_m() all funnel through here, so
+        this covers every simulator-API readout for the qubit). A no-op
+        whenever there's no ancilla for this site, or it hasn't been
+        Bell-paired with slot2 yet (nothing to condition on).
+        """
+        anc = self._ancilla.get(lq)
+        if anc is None or lq not in self._ancilla_paired:
+            return
+        hq = self._unpack(lq)
+        if len(hq) < 3:
+            return
+        anc_sim, anc_idx = anc
+        slot2_sim, slot2_idx = hq[2]
+        if anc_sim != slot2_sim:
+            return
+        self.sim[anc_sim].mcu(
+            [anc_idx],
+            slot2_idx,
+            QrackAceBackend._BSEQ_THETA,
+            QrackAceBackend._BSEQ_PHI,
+            QrackAceBackend._BSEQ_LAMBDA,
+        )
+
     def _correct(self, lq, phase=False, skip_rotation=False):
         hq = self._unpack(lq)
 
@@ -702,35 +794,65 @@ class QrackAceBackend:
                     if syndrome[q] > (0.5 + self._epsilon):
                         self.sim[hq[q][0]].x(hq[q][1])
             else:
-                # Weighted 4-source vote: slot0, slot1, slot2 (real qubits)
-                # plus lhv (continuous, non-collapsing proxy). Weights sum
-                # to an odd total (QrackAceBackend._LHV_VOTE_WEIGHTS), so
-                # the underlying hard-vote tally is always tie-free, while
-                # the RMS formula itself generalizes the existing unweighted
-                # one (and reduces to it exactly when all weights are equal).
-                p = [
-                    self.sim[hq[0][0]].prob(hq[0][1]),
-                    self.sim[hq[1][0]].prob(hq[1][1]),
-                    self.sim[hq[2][0]].prob(hq[2][1]),
-                    lhv.prob(),
-                ]
-                w = QrackAceBackend._LHV_VOTE_WEIGHTS
-                sw = sum(w)
-                prms = math.sqrt(sum(wi * pi**2 for wi, pi in zip(w, p)) / sw)
-                qrms = math.sqrt(sum(wi * (1 - pi) ** 2 for wi, pi in zip(w, p)) / sw)
-                eff_prob = (prms + (1 - qrms)) / 2
-                result = (
-                    (random.random() < 0.5)
-                    if abs(eff_prob - 0.5) <= self._epsilon
-                    else (eff_prob >= 0.5)
-                )
+                # Conditional tie-breaking cascade, NOT a fixed-weight pool.
+                # A fixed weight on slot0/lhv pulls every decision toward
+                # 0.5 even when slot1 and slot2 already agree confidently,
+                # because slot0 and lhv are legitimately, permanently near
+                # 0.5 for genuinely-entangled topologies (e.g. when slot0
+                # shares a simulator with the control) -- a "vote" stuck at
+                # 0.5 is not neutral in an RMS pool, it actively drags the
+                # result toward the center. The actual intent ("LHV serves
+                # only to act as a tie-breaker") is a conditional, not a
+                # weight: trust slot1/slot2 alone whenever they agree, and
+                # only consult slot0, then lhv, when they genuinely don't.
+                #
+                # The BSEQ correction (a real, coherent controlled-U gate
+                # on slot2, conditioned on its ancilla) is applied FIRST,
+                # directly to the quantum state -- before any probability
+                # is read. This composes correctly even while this qubit's
+                # Bell-pair partner is still genuinely superposed, unlike
+                # every classical-decision approach that was tried and
+                # rejected here (all of them were provably forced into an
+                # uninformative coin flip in exactly that case).
+                self._apply_bseq_correction(lq)
+
+                p0 = self.sim[hq[0][0]].prob(hq[0][1])
+                p1 = self.sim[hq[1][0]].prob(hq[1][1])
+                p2 = self.sim[hq[2][0]].prob(hq[2][1])
+                p_lhv = lhv.prob()
+
+                if (p1 >= 0.5) == (p2 >= 0.5):
+                    prms = math.sqrt((p1**2 + p2**2) / 2)
+                    qrms = math.sqrt(((1 - p1) ** 2 + (1 - p2) ** 2) / 2)
+                    eff_prob = (prms + (1 - qrms)) / 2
+                    result = (
+                        (random.random() < 0.5)
+                        if abs(eff_prob - 0.5) <= self._epsilon
+                        else (eff_prob >= 0.5)
+                    )
+                elif abs(p0 - 0.5) > self._epsilon:
+                    # Genuine deadlock between slot1/slot2; slot0 (a real,
+                    # exactly-entangled qubit in this common topology) has
+                    # a real opinion, so it breaks the tie.
+                    result = p0 >= 0.5
+                else:
+                    # slot0 is itself ambiguous; only now does the LHV's
+                    # continuous, non-collapsing proxy actually decide.
+                    result = (
+                        (random.random() < 0.5)
+                        if abs(p_lhv - 0.5) <= self._epsilon
+                        else (p_lhv >= 0.5)
+                    )
+
+                p = [p0, p1, p2]
                 syndrome = [1 - x for x in p] if result else list(p)
                 for q in range(3):
                     if syndrome[q] > (0.5 + self._epsilon):
                         self.sim[hq[q][0]].x(hq[q][1])
-                # The LHV proxy is never hard-collapsed via x(); only ever
-                # updated by continuous rotation, preserving the property
-                # that makes it useful as a non-collapsing stabilizing term.
+                # The LHV proxy is never hard-collapsed via x(); it is only
+                # ever updated by its own transversal gate evolution and
+                # _cpauli_lhv, preserving the property that makes it usable
+                # as a non-collapsing tie-breaker of last resort.
 
             if not skip_rotation:
                 a, i = [0, 0, 0], [0, 0, 0]
@@ -784,6 +906,9 @@ class QrackAceBackend:
         # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
     def r(self, p, th, lq):
+        if p == Pauli.PauliY:
+            self._last_y_rotation[lq] = self._last_y_rotation.get(lq, 0.0) + th
+
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
@@ -1016,6 +1141,27 @@ class QrackAceBackend:
         # qubits, which now live as real qubits in the shared boundary sim.
         self._apply_coupling(pauli, anti, qb1, hq1, qb2, hq2, lq1_lr)
 
+        if lq2 in self._ancilla and lq2 not in self._ancilla_paired and len(hq2) >= 3:
+            anc_sim, anc_idx = self._ancilla[lq2]
+            slot2_sim, slot2_idx = hq2[2]
+            if anc_sim == slot2_sim:
+                # slot2 as CONTROL, ancilla as target: a CX never modifies
+                # its control qubit's own marginal state, so this taps
+                # slot2's real, evolving state non-invasively -- the
+                # ancilla becomes perfectly correlated with slot2 without
+                # disturbing it (unlike the reverse direction, which would
+                # mix/dephase slot2 itself every time pairing occurred).
+                self.sim[anc_sim].mcx([slot2_idx], anc_idx)
+            else:
+                # Different simulators (shouldn't normally happen, since
+                # ancilla and slot2 are allocated in the same boundary sim,
+                # but guard defensively): fall back to a direct two-qubit
+                # gate is unavailable cross-sim here, so this path is not
+                # expected to be exercised in practice.
+                pass
+            self._ancilla_paired.add(lq2)
+            self._bell_partner[lq2] = lq1
+
         if lq2 in self._lhv:
             ctrl_prob = self.sim[hq1[0][0]].prob(hq1[0][1])
             _cpauli_lhv(ctrl_prob, self._lhv[lq2], pauli, anti)
@@ -1148,12 +1294,16 @@ class QrackAceBackend:
                     self.sim[hq[0][0]].prob(hq[0][1]),
                     self.sim[hq[1][0]].prob(hq[1][1]),
                     self.sim[hq[2][0]].prob(hq[2][1]),
-                    lhv.prob(),
                 ]
-                w = QrackAceBackend._LHV_VOTE_WEIGHTS
-                sw = sum(w)
-                prms = math.sqrt(sum(wi * pi**2 for wi, pi in zip(w, p)) / sw)
-                qrms = math.sqrt(sum(wi * (1 - pi) ** 2 for wi, pi in zip(w, p)) / sw)
+                # The three real replicas are already mutually consistent
+                # here (the _correct() call above already ran the
+                # conditional tie-breaking cascade and forced agreement via
+                # x()). Re-weighting in the LHV here would reintroduce the
+                # same center-dragging distortion the cascade was built to
+                # avoid -- a plain RMS over the now-settled replicas is the
+                # correct, already-decided answer.
+                prms = math.sqrt((p[0] ** 2 + p[1] ** 2 + p[2] ** 2) / 3)
+                qrms = math.sqrt(((1 - p[0]) ** 2 + (1 - p[1]) ** 2 + (1 - p[2]) ** 2) / 3)
 
         return (prms + (1 - qrms)) / 2
 

pyqrack_cuda_complex128-2.3.0/pyqrack/scripts/optimize_bseq_correction.py

@@ -0,0 +1,207 @@
+# Empirical optimizer for QrackAceBackend's BSEQ (Bell/CHSH) ancilla
+# correction gate.
+#
+# The correction is a single, genuine controlled-U(theta, phi, lambda)
+# gate (QrackSimulator.mcu), with each boundary qubit's ancilla as
+# control and the boundary qubit itself as target. It is applied
+# directly to the live quantum state -- before any probability is read
+# -- every time the boundary qubit's state is corrected (prob() / m() /
+# force_m() all funnel through this), so it composes correctly even
+# while the qubit's Bell-pair partner is still genuinely superposed.
+#
+# The 3 angles (QrackAceBackend._BSEQ_THETA/_PHI/_LAMBDA) are the only
+# trainable parameters. They are fit here by direct, gradient-free
+# search against the empirically measured CHSH S statistic (or its 4
+# components individually), averaged over repeated Bell-pair trials to
+# average down the substantial per-construction measurement variance
+# inherent to this architecture (each circuit construction makes its
+# own one-time classical collapse choice early in the elision pipeline;
+# averaging over MANY independent constructions is what makes the mean
+# S a meaningful, optimizable target -- a single fixed gate cannot
+# reduce per-shot variance, since that variance is set by an earlier,
+# already-classical decision the gate cannot retroactively undo).
+#
+# Usage:
+#   python3 optimize_bseq_correction.py [--iterations N] [--time-budget SECONDS]
+#
+# Writes the found angles directly into pyqrack's installed
+# qrack_ace_backend.py (QrackAceBackend._BSEQ_THETA/_PHI/_LAMBDA), so
+# every subsequently-constructed QrackAceBackend in the running
+# process (and, if you choose to persist the file, future processes)
+# uses the fitted correction automatically -- no separate model file,
+# no extra inference dependency. The correction is 3 floats; baking
+# them in as class attributes is already the most efficient possible
+# packaging, and needs no JIT/torch artifact at inference time.
+
+import argparse
+import math
+import random
+import statistics
+import time
+
+from pyqrack import QrackAceBackend, Pauli
+import pyqrack.qrack_ace_backend as _ace_mod
+
+PI = math.pi
+
+# Standard CHSH angle set.
+THETA_A, THETA_AP = 0.0, PI / 2
+THETA_B, THETA_BP = PI / 4, -PI / 4
+
+
+def _apply_measurement_basis(sim, q, theta):
+    sim.r(Pauli.PauliY, theta, q)
+
+
+def _measure_expectation(sim, shots):
+    results = sim.measure_shots([0, 1], shots)
+    total = 0
+    for res in results:
+        a = (res >> 0) & 1
+        b = (res >> 1) & 1
+        total += 1 if a == b else -1
+    return total / shots
+
+
+def _expectation(theta1, theta2, shots, width=16, long_range_columns=1):
+    """One fresh Bell-pair-with-ancilla construction, measured at a given
+    basis-angle pair. This is exactly the bseq.py pattern: h(0), cx(0,1),
+    then a PauliY rotation on each half before measuring."""
+    s = QrackAceBackend(width, long_range_columns=long_range_columns)
+    s.h(0)
+    s.mcx([0], 1)
+    _apply_measurement_basis(s, 0, theta1)
+    _apply_measurement_basis(s, 1, theta2)
+    return _measure_expectation(s, shots)
+
+
+def compute_chsh_components(shots, **kwargs):
+    """Return the 4 CHSH correlator terms (E(a,b), E(a,b'), E(a',b), E(a',b'))."""
+    return (
+        _expectation(THETA_A, THETA_B, shots, **kwargs),
+        _expectation(THETA_A, THETA_BP, shots, **kwargs),
+        _expectation(THETA_AP, THETA_B, shots, **kwargs),
+        _expectation(THETA_AP, THETA_BP, shots, **kwargs),
+    )
+
+
+def compute_S(shots, **kwargs):
+    e_ab, e_abp, e_apb, e_apbp = compute_chsh_components(shots, **kwargs)
+    return e_ab + e_abp + e_apb - e_apbp
+
+
+def set_correction(theta, phi, lam):
+    _ace_mod.QrackAceBackend._BSEQ_THETA = theta
+    _ace_mod.QrackAceBackend._BSEQ_PHI = phi
+    _ace_mod.QrackAceBackend._BSEQ_LAMBDA = lam
+
+
+def mean_reward(theta, phi, lam, n_repeats, shots, **kwargs):
+    """The actual optimization target: mean S across many independent
+    Bell-pair-with-ancilla constructions ("an RCS data set for Bell-pair
+    perturbations of the ancillae"), not a single noisy reading."""
+    set_correction(theta, phi, lam)
+    vals = [compute_S(shots, **kwargs) for _ in range(n_repeats)]
+    return statistics.mean(vals)
+
+
+def optimize(
+    n_repeats=4,
+    shots=64,
+    time_budget=200.0,
+    max_iterations=None,
+    seed=None,
+    initial_step=PI / 4,
+    step_decay=0.8,
+    decay_every=10,
+):
+    """Gradient-free random-walk search over (theta, phi, lambda),
+    maximizing mean_reward. Measurement sampling is not differentiable,
+    so this uses repeated empirical evaluation rather than backprop --
+    appropriate given the actual cost here is 3 scalars, not a network.
+    """
+    if seed is not None:
+        random.seed(seed)
+
+    best_params = (0.0, 0.0, 0.0)
+    best_score = mean_reward(*best_params, n_repeats, shots)
+    print(f"start: mean_S={best_score:.4f}")
+
+    t_start = time.time()
+    step = initial_step
+    iteration = 0
+    while True:
+        if max_iterations is not None and iteration >= max_iterations:
+            break
+        if time_budget is not None and (time.time() - t_start) >= time_budget:
+            break
+
+        candidate = tuple(p + random.uniform(-step, step) for p in best_params)
+        score = mean_reward(*candidate, n_repeats, shots)
+        if score > best_score:
+            best_score = score
+            best_params = candidate
+            print(
+                f"iter {iteration}: improved -> "
+                f"params={[round(p, 4) for p in candidate]} mean_S={score:.4f}"
+            )
+
+        iteration += 1
+        if iteration % decay_every == 0:
+            step *= step_decay
+
+    print()
+    print(f"FINAL params: {[round(p, 6) for p in best_params]}")
+    print(f"FINAL mean_S: {best_score:.4f}  (classical bound: 2.0, Tsirelson: {2*math.sqrt(2):.4f})")
+    print(f"total iterations: {iteration}")
+    return best_params, best_score
+
+
+def write_params_to_backend_file(theta, phi, lam):
+    """Patch the installed pyqrack/qrack_ace_backend.py in place, so the
+    fitted correction persists for future processes too, without
+    requiring a separate model-loading step at import time."""
+    import os
+    import re
+
+    path = os.path.join(os.path.dirname(_ace_mod.__file__), "qrack_ace_backend.py")
+    with open(path, "r") as f:
+        src = f.read()
+
+    src = re.sub(r"_BSEQ_THETA\s*=\s*[-0-9.eE]+", f"_BSEQ_THETA = {theta!r}", src)
+    src = re.sub(r"_BSEQ_PHI\s*=\s*[-0-9.eE]+", f"_BSEQ_PHI = {phi!r}", src)
+    src = re.sub(r"_BSEQ_LAMBDA\s*=\s*[-0-9.eE]+", f"_BSEQ_LAMBDA = {lam!r}", src)
+
+    with open(path, "w") as f:
+        f.write(src)
+    print(f"Wrote fitted angles into {path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--iterations", type=int, default=None)
+    parser.add_argument("--time-budget", type=float, default=200.0)
+    parser.add_argument("--repeats", type=int, default=4)
+    parser.add_argument("--shots", type=int, default=64)
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument(
+        "--persist",
+        action="store_true",
+        help="Write the fitted angles into the installed backend file.",
+    )
+    args = parser.parse_args()
+
+    params, score = optimize(
+        n_repeats=args.repeats,
+        shots=args.shots,
+        time_budget=args.time_budget,
+        max_iterations=args.iterations,
+        seed=args.seed,
+    )
+
+    if args.persist:
+        write_params_to_backend_file(*params)
+
+
+if __name__ == "__main__":
+    main()

{pyqrack_cuda_complex128-2.2.4 → pyqrack_cuda_complex128-2.3.0/pyqrack_cuda_complex128.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrack-cuda-complex128
-Version: 2.2.4
+Version: 2.3.0
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano

{pyqrack_cuda_complex128-2.2.4 → pyqrack_cuda_complex128-2.3.0}/pyqrack_cuda_complex128.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ pyqrack/qrack_stabilizer.py
 pyqrack/quimb_circuit_type.py
 pyqrack/qrack_system/__init__.py
 pyqrack/qrack_system/qrack_system.py
+pyqrack/scripts/optimize_bseq_correction.py
 pyqrack/stats/__init__.py
 pyqrack/stats/load_quantized_data.py
 pyqrack/stats/quantize_by_range.py

{pyqrack_cuda_complex128-2.2.4 → pyqrack_cuda_complex128-2.3.0}/setup.py

@@ -7,7 +7,7 @@ from setuptools import setup
 from setuptools.command.build_py import build_py
 
 
-VERSION = "2.2.4"
+VERSION = "2.3.0"
 
 # Read long description from README.
 README_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'README.md')