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

{pyqrack_cuda_complex128-2.2.3 → 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.3/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.3
+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.3 → 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)
@@ -191,7 +224,6 @@ def _cpauli_lhv(prob, targ, axis, anti, theta=math.pi):
     elif axis == Pauli.PauliZ:
         targ.rz(effective_theta)
 
-
 class QrackAceBackend:
     """A back end for elided quantum error correction
 
@@ -212,6 +244,12 @@ class QrackAceBackend:
         is_transpose(bool): Rows are long if False, columns are long if True
     """
 
+    # Sweepable vote weights for the 4-source boundary correction pool:
+    # [slot0, slot1, slot2, lhv]. Must sum to an odd number so the
+    # underlying hard-vote tally (independent of the continuous RMS
+    # formula) is always tie-free.
+    _LHV_VOTE_WEIGHTS = [2, 1, 1, 1]
+
     def __init__(
         self,
         qubit_count=1,
@@ -276,7 +314,24 @@ class QrackAceBackend:
                 self._is_row_long_range[-1] = False
         sim_count = col_patch_count * row_patch_count
 
+        # Boundary qubits no longer carry a private classical LHV proxy.
+        # Instead, every boundary site (row- and/or column-boundary alike)
+        # gets a real qubit in one single, shared "crossbar" QrackSimulator.
+        # That simulator's own greedy elision (set_sdrp) is trusted to
+        # automatically factor apart whatever boundary sites turn out to be
+        # separable (e.g. disjoint rails, rail intersections), exactly the
+        # same way it already factors apart unentangled subspaces within
+        # any other single QrackSimulator instance. We don't need to special
+        # -case "crossbar intersections" by hand; the elision does it for us.
+        boundary_sim_id = sim_count
+        boundary_count = 0
+
         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
@@ -290,8 +345,21 @@ class QrackAceBackend:
                     qubit.append((t_sim_id, sim_counts[t_sim_id]))
                     sim_counts[t_sim_id] += 1
 
-                    qubit.append(
-                        LHVQubit(to_clone=(to_clone._qubits[tot_qubits][2] if to_clone else None))
+                    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)
                     )
 
                 if (not c) and (not r):
@@ -309,8 +377,23 @@ class QrackAceBackend:
                 self._qubits.append(qubit)
                 tot_qubits += 1
 
+        # The crossbar's size is fixed by how many boundary sites exist.
+        # When there are none (e.g. a grid small enough, relative to
+        # long_range_rows/columns, that the whole thing is "fully
+        # connected" with no QEC boundary at all), we must NOT allocate a
+        # 0-qubit QrackSimulator for the crossbar: a 0-qubit QrackSimulator
+        # can be constructed, but calling .clone() on one crashes the
+        # native Qrack core (segfault), and clone() is called routinely by
+        # measure_shots()/clone(). So the boundary sim is only created when
+        # boundary_count > 0, exactly mirroring how the original LHV-based
+        # code never instantiated anything for the boundary case when
+        # there were no boundary sites.
+        has_boundary = boundary_count > 0
+        if has_boundary:
+            sim_counts.append(boundary_count)
+
         self.sim = []
-        for i in range(sim_count):
+        for i in range(sim_count + (1 if has_boundary else 0)):
             self.sim.append(
                 to_clone.sim[i].clone()
                 if to_clone
@@ -326,11 +409,13 @@ 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)
 
+        self._boundary_sim_id = boundary_sim_id if has_boundary else None
+
     def clone(self):
         return QrackAceBackend(to_clone=self)
 
@@ -405,6 +490,24 @@ class QrackAceBackend:
         p1 = self.sim[q1[0]].prob(q1[1]) if isinstance(q1, tuple) else q1.prob()
         p2 = self.sim[q2[0]].prob(q2[1]) if isinstance(q2, tuple) else q2.prob()
 
+        # When p1 and p2 are within floating-point noise of each other
+        # (self._epsilon), they carry no real information about which
+        # qubit is "more likely 1" -- e.g. a fresh target right after
+        # _cx_shadow's H() always reads ~0.5, indistinguishably from a
+        # genuinely-mixed control. This shadow mechanism can only return
+        # ONE definite classical pick per call, so resolving every such
+        # near-tie to a FIXED qubit (as a plain "<" or "<=" comparison
+        # would, once p1/p2 are within epsilon of each other) reintroduces
+        # a systematic bias -- it just moves the bias from "favors q1" to
+        # "always favors q2" instead of removing it. The aggregate
+        # statistics this shadow is meant to approximate (e.g. a real CX
+        # from a maximally-mixed control onto a fresh target makes BOTH
+        # qubits individually read prob=0.5, perfectly correlated) are
+        # only reproduced, across many circuit instances, if a genuine
+        # tie is broken at random rather than by a fixed rule.
+        if abs(p1 - p2) <= self._epsilon:
+            return (p1, q2) if random.random() < 0.5 else (p2, q1)
+
         if p1 < p2:
             return p2, q1
 
@@ -412,7 +515,16 @@ class QrackAceBackend:
 
     def _cz_shadow(self, q1, q2):
         prob_max, t = self._ct_pair_prob(q1, q2)
-        if prob_max > 0.5:
+        # NOTE: this must be ">=", not ">". H() applied to any qubit in a
+        # definite computational-basis state (e.g. a fresh boundary/ancilla
+        # qubit, as in _cx_shadow's H-sandwich) lands at EXACTLY prob=0.5,
+        # deterministically -- this is the ordinary case, not a rare
+        # floating-point tie. A strict "> 0.5" therefore silently no-ops
+        # the shadow gate every time it targets a fresh qubit, which
+        # breaks entanglement transfer for the extremely common case of a
+        # CX/CY/CZ from a maximally-mixed-looking control onto a fresh
+        # target (e.g. H(0); cx(0,1) for a Bell pair).
+        if prob_max >= (0.5 - self._epsilon):
             if isinstance(t, tuple):
                 self.sim[t[0]].z(t[1])
             else:
@@ -472,35 +584,23 @@ class QrackAceBackend:
 
     @staticmethod
     def _get_qb_lhv_indices(hq):
-        qb = []
+        # Historically, index 2 (when present) pointed at a private
+        # classical LHVQubit proxy and had to be special-cased everywhere.
+        # It is now an ordinary (sim_id, idx) tuple into the shared
+        # boundary "crossbar" QrackSimulator, so it is just one more
+        # coupling target like every other index. We keep this helper's
+        # name and signature for minimal call-site churn; "lhv" is now
+        # always -1 (no index needs special-casing any more).
         if len(hq) < 2:
             qb = [0]
-            lhv = -1
         elif len(hq) < 4:
-            qb = [0, 1]
-            lhv = 2
+            qb = [0, 1, 2]
         else:
-            qb = [0, 1, 3, 4]
-            lhv = 2
+            qb = [0, 1, 2, 3, 4]
+        lhv = -1
 
         return qb, lhv
 
-    @staticmethod
-    def _get_lhv_bloch_angles(sim):
-        # Z axis
-        z = sim.bloch[2]
-
-        # X axis
-        x = sim.bloch[0]
-
-        # Y axis
-        y = sim.bloch[1]
-
-        inclination = math.atan2(math.sqrt(x**2 + y**2), z)
-        azimuth = math.atan2(y, x)
-
-        return azimuth, inclination
-
     def _get_bloch_angles(self, hq):
         sim = self.sim[hq[0]].clone()
         q = hq[1]
@@ -543,9 +643,17 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11], q)
 
+    @staticmethod
+    def _get_lhv_bloch_angles(sim):
+        z = sim.bloch[2]
+        x = sim.bloch[0]
+        y = sim.bloch[1]
+        inclination = math.atan2(math.sqrt(x**2 + y**2), z)
+        azimuth = math.atan2(y, x)
+        return azimuth, inclination
+
     @staticmethod
     def _rotate_lhv_to_bloch(sim, delta_azimuth, delta_inclination):
-        # Apply rotation as "Azimuth, Inclination" (AI)
         cosA = math.cos(delta_azimuth)
         sinA = math.sin(delta_azimuth)
         cosI = math.cos(delta_inclination / 2)
@@ -558,27 +666,68 @@ 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)
 
         if len(hq) == 1:
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         if phase:
             for q in qb:
                 b = hq[q]
                 self.sim[b[0]].h(b[1])
-            b = hq[lhv]
-            b.h()
+            if lq in self._lhv:
+                self._lhv[lq].h()
 
         if len(hq) == 5:
             # RMS
             p = [
                 self.sim[hq[0][0]].prob(hq[0][1]),
                 self.sim[hq[1][0]].prob(hq[1][1]),
-                hq[2].prob(),
+                self.sim[hq[2][0]].prob(hq[2][1]),
                 self.sim[hq[3][0]].prob(hq[3][1]),
                 self.sim[hq[4][0]].prob(hq[4][1]),
             ]
@@ -598,7 +747,7 @@ class QrackAceBackend:
             result = (
                 (random.random() < 0.5)
                 if abs(eff_prob - 0.5) <= self._epsilon
-                else (eff_prob > 0.5)
+                else (eff_prob >= 0.5)
             )
             syndrome = (
                 [1 - p[0], 1 - p[1], 1 - p[2], 1 - p[3], 1 - p[4]]
@@ -607,91 +756,121 @@ class QrackAceBackend:
             )
             for q in range(5):
                 if syndrome[q] > (0.5 + self._epsilon):
-                    if q == 2:
-                        hq[q].x()
-                    else:
-                        self.sim[hq[q][0]].x(hq[q][1])
+                    self.sim[hq[q][0]].x(hq[q][1])
 
             if not skip_rotation:
                 a, i = [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]
                 a[0], i[0] = self._get_bloch_angles(hq[0])
                 a[1], i[1] = self._get_bloch_angles(hq[1])
-                a[2], i[2] = QrackAceBackend._get_lhv_bloch_angles(hq[2])
+                a[2], i[2] = self._get_bloch_angles(hq[2])
                 a[3], i[3] = self._get_bloch_angles(hq[3])
                 a[4], i[4] = self._get_bloch_angles(hq[4])
 
-                a_target = 0
-                i_target = 0
+                a_target = sum(a) / 5
+                i_target = sum(i) / 5
                 for x in range(5):
-                    if x == 2:
-                        continue
-                    a_target += a[x]
-                    i_target += i[x]
-
-                a_target /= 5
-                i_target /= 5
-                for x in range(5):
-                    if x == 2:
-                        QrackAceBackend._rotate_lhv_to_bloch(
-                            hq[x], a_target - a[x], i_target - i[x]
-                        )
-                    else:
-                        self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+                    self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
 
         else:
-            # RMS
-            p = [
-                self.sim[hq[0][0]].prob(hq[0][1]),
-                self.sim[hq[1][0]].prob(hq[1][1]),
-                hq[2].prob(),
-            ]
-            # Balancing suggestion from Elara (the custom OpenAI GPT)
-            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)
-            eff_prob = (prms + (1 - qrms)) / 2
-            result = (
-                (random.random() < 0.5)
-                if abs(eff_prob - 0.5) <= self._epsilon
-                else (eff_prob > 0.5)
-            )
-            syndrome = [1 - p[0], 1 - p[1], 1 - p[2]] if result else [p[0], p[1], p[2]]
-            for q in range(3):
-                if syndrome[q] > (0.5 + self._epsilon):
-                    if q == 2:
-                        hq[q].x()
-                    else:
+            lhv = self._lhv.get(lq)
+            if lhv is None:
+                # RMS
+                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]),
+                ]
+                # Balancing suggestion from Elara (the custom OpenAI GPT)
+                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)
+                eff_prob = (prms + (1 - qrms)) / 2
+                result = (
+                    (random.random() < 0.5)
+                    if abs(eff_prob - 0.5) <= self._epsilon
+                    else (eff_prob >= 0.5)
+                )
+                syndrome = [1 - p[0], 1 - p[1], 1 - p[2]] if result else [p[0], p[1], p[2]]
+                for q in range(3):
+                    if syndrome[q] > (0.5 + self._epsilon):
                         self.sim[hq[q][0]].x(hq[q][1])
+            else:
+                # 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(); 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]
                 a[0], i[0] = self._get_bloch_angles(hq[0])
                 a[1], i[1] = self._get_bloch_angles(hq[1])
-                a[2], i[2] = QrackAceBackend._get_lhv_bloch_angles(hq[2])
-
-                a_target = 0
-                i_target = 0
-                for x in range(3):
-                    if x == 2:
-                        continue
-                    a_target += a[x]
-                    i_target += i[x]
+                a[2], i[2] = self._get_bloch_angles(hq[2])
 
-                a_target /= 3
-                i_target /= 3
+                a_target = sum(a) / 3
+                i_target = sum(i) / 3
                 for x in range(3):
-                    if x == 2:
-                        QrackAceBackend._rotate_lhv_to_bloch(
-                            hq[x], a_target - a[x], i_target - i[x]
-                        )
-                    else:
-                        self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+                    self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
 
         if phase:
             for q in qb:
                 b = hq[q]
                 self.sim[b[0]].h(b[1])
-            b = hq[lhv]
-            b.h()
+            if lq in self._lhv:
+                self._lhv[lq].h()
 
     def apply_magnetic_bias(self, q, b):
         if b == 0:
@@ -699,22 +878,13 @@ class QrackAceBackend:
         b = math.exp(b)
         for x in q:
             hq = self._unpack(x)
-            for c in range(len(hq)):
-                h = hq[c]
-                if c == 2:
-                    a, i = QrackAceBackend._get_lhv_bloch_angles(h)
-                    QrackAceBackend._rotate_lhv_to_bloch(
-                        h,
-                        math.atan(math.tan(a) * b) - a,
-                        math.atan(math.tan(i) * b) - i,
-                    )
-                else:
-                    a, i = self._get_bloch_angles(h)
-                    self._rotate_to_bloch(
-                        h,
-                        math.atan(math.tan(a) * b) - a,
-                        math.atan(math.tan(i) * b) - i,
-                    )
+            for h in hq:
+                a, i = self._get_bloch_angles(h)
+                self._rotate_to_bloch(
+                    h,
+                    math.atan(math.tan(a) * b) - a,
+                    math.atan(math.tan(i) * b) - i,
+                )
 
     def u(self, lq, th, ph, lm):
         hq = self._unpack(lq)
@@ -723,37 +893,42 @@ class QrackAceBackend:
             self.sim[b[0]].u(b[1], th, ph, lm)
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].u(b[1], th, ph, lm)
 
-        b = hq[lhv]
-        b.u(th, ph, lm)
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.u(th, ph, lm)
 
         # 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]
             self.sim[b[0]].r(p, th, b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].r(p, th, b[1])
 
-        b = hq[lhv]
-        if p == Pauli.PauliX:
-            b.rx(th)
-        elif p == Pauli.PauliY:
-            b.ry(th)
-        elif p == Pauli.PauliZ:
-            b.rz(th)
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            if p == Pauli.PauliX:
+                lhv.rx(th)
+            elif p == Pauli.PauliY:
+                lhv.ry(th)
+            elif p == Pauli.PauliZ:
+                lhv.rz(th)
 
         # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
@@ -766,14 +941,15 @@ class QrackAceBackend:
 
         self._correct(lq)
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].h(b[1])
 
-        b = hq[lhv]
-        b.h()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.h()
 
         # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
@@ -784,14 +960,15 @@ class QrackAceBackend:
             self.sim[b[0]].s(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].s(b[1])
 
-        b = hq[lhv]
-        b.s()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.s()
 
     def adjs(self, lq):
         hq = self._unpack(lq)
@@ -800,14 +977,15 @@ class QrackAceBackend:
             self.sim[b[0]].adjs(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].adjs(b[1])
 
-        b = hq[lhv]
-        b.adjs()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.adjs()
 
     def x(self, lq):
         hq = self._unpack(lq)
@@ -816,14 +994,15 @@ class QrackAceBackend:
             self.sim[b[0]].x(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].x(b[1])
 
-        b = hq[lhv]
-        b.x()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.x()
 
     def y(self, lq):
         hq = self._unpack(lq)
@@ -832,14 +1011,15 @@ class QrackAceBackend:
             self.sim[b[0]].y(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].y(b[1])
 
-        b = hq[lhv]
-        b.y()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.y()
 
     def z(self, lq):
         hq = self._unpack(lq)
@@ -848,14 +1028,15 @@ class QrackAceBackend:
             self.sim[b[0]].z(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].z(b[1])
 
-        b = hq[lhv]
-        b.z()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.z()
 
     def t(self, lq):
         hq = self._unpack(lq)
@@ -864,14 +1045,15 @@ class QrackAceBackend:
             self.sim[b[0]].t(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].t(b[1])
 
-        b = hq[lhv]
-        b.t()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.t()
 
     def adjt(self, lq):
         hq = self._unpack(lq)
@@ -880,14 +1062,15 @@ class QrackAceBackend:
             self.sim[b[0]].adjt(b[1])
             return
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
             self.sim[b[0]].adjt(b[1])
 
-        b = hq[lhv]
-        b.adjt()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.adjt()
 
     def _get_gate(self, pauli, anti, sim_id):
         gate = None
@@ -927,15 +1110,11 @@ class QrackAceBackend:
 
         return connected, boundary
 
-    def _apply_coupling(self, pauli, anti, qb1, lhv1, hq1, qb2, lhv2, hq2, lq1_lr):
+    def _apply_coupling(self, pauli, anti, qb1, hq1, qb2, hq2, lq1_lr):
         for q1 in qb1:
-            if q1 == lhv1:
-                continue
             b1 = hq1[q1]
             gate_fn, shadow_fn = self._get_gate(pauli, anti, b1[0])
             for q2 in qb2:
-                if q2 == lhv2:
-                    continue
                 b2 = hq2[q2]
                 if b1[0] == b2[0]:
                     gate_fn([b1[1]], b2[1])
@@ -956,18 +1135,36 @@ class QrackAceBackend:
 
         self._correct(lq1)
 
-        qb1, lhv1 = QrackAceBackend._get_qb_lhv_indices(hq1)
-        qb2, lhv2 = QrackAceBackend._get_qb_lhv_indices(hq2)
-        # Apply cross coupling on hardware qubits first
-        self._apply_coupling(pauli, anti, qb1, lhv1, hq1, qb2, lhv2, hq2, lq1_lr)
-        # Apply coupling to the local-hidden-variable target
-        if lhv2 >= 0:
-            _cpauli_lhv(
-                hq1[lhv1].prob() if lhv1 >= 0 else self.sim[hq1[0][0]].prob(hq1[0][1]),
-                hq2[lhv2],
-                pauli,
-                anti,
-            )
+        qb1, _ = QrackAceBackend._get_qb_lhv_indices(hq1)
+        qb2, _ = QrackAceBackend._get_qb_lhv_indices(hq2)
+        # Apply cross coupling on every qubit, including former-LHV boundary
+        # 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)
 
         self._correct(lq1, True)
         if pauli != Pauli.PauliZ:
@@ -1064,7 +1261,7 @@ class QrackAceBackend:
             p = [
                 self.sim[hq[0][0]].prob(hq[0][1]),
                 self.sim[hq[1][0]].prob(hq[1][1]),
-                hq[2].prob(),
+                self.sim[hq[2][0]].prob(hq[2][1]),
                 self.sim[hq[3][0]].prob(hq[3][1]),
                 self.sim[hq[4][0]].prob(hq[4][1]),
             ]
@@ -1081,15 +1278,32 @@ class QrackAceBackend:
                 / 7
             )
         else:
-            # RMS
-            p = [
-                self.sim[hq[0][0]].prob(hq[0][1]),
-                self.sim[hq[1][0]].prob(hq[1][1]),
-                hq[2].prob(),
-            ]
-            # Balancing suggestion from Elara (the custom OpenAI GPT)
-            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)
+            lhv = self._lhv.get(lq)
+            if lhv is None:
+                # RMS
+                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]),
+                ]
+                # Balancing suggestion from Elara (the custom OpenAI GPT)
+                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)
+            else:
+                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]),
+                ]
+                # 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
 
@@ -1100,9 +1314,9 @@ class QrackAceBackend:
             return self.sim[b[0]].m(b[1])
 
         p = self.prob(lq)
-        result = ((p + self._epsilon) >= 1.0) or (random.random() < p)
+        result = ((p + self._epsilon) >= 1) or (random.random() < p)
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -1113,10 +1327,11 @@ class QrackAceBackend:
             else:
                 self.sim[b[0]].force_m(b[1], result)
 
-        b = hq[lhv]
-        b.reset()
-        if result:
-            b.x()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.reset()
+            if result:
+                lhv.x()
 
         return result
 
@@ -1128,7 +1343,7 @@ class QrackAceBackend:
 
         self._correct(lq)
 
-        qb, lhv = QrackAceBackend._get_qb_lhv_indices(hq)
+        qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
@@ -1139,10 +1354,11 @@ class QrackAceBackend:
             else:
                 self.sim[b[0]].force_m(b[1], result)
 
-        b = hq[lhv]
-        b.reset()
-        if result:
-            b.x()
+        lhv = self._lhv.get(lq)
+        if lhv is not None:
+            lhv.reset()
+            if result:
+                lhv.x()
 
         return result
 
@@ -1509,25 +1725,22 @@ class QrackAceBackend:
             return self._coupling_map
 
         coupling_map = set()
-        # self._row_length is the number of qubits per row (the row's span,
-        # i.e. the column count); self._col_length is the number of rows.
-        num_rows, num_cols = self._col_length, self._row_length
+        rows, cols = self._row_length, self._col_length
 
-        # Row-major logical index, strided by the actual row span.
+        # Map each column index to its full list of logical qubit indices
         def logical_index(row, col):
-            return row * num_cols + col
+            return row * cols + col
 
-        for row in range(num_rows):
-            connected_rows, _ = self._get_connected(row, True)
-            for col in range(num_cols):
-                connected_cols, _ = self._get_connected(col, False)
+        for col in range(cols):
+            connected_cols, _ = self._get_connected(col, False)
+            for row in range(rows):
+                connected_rows, _ = self._get_connected(row, False)
                 a = logical_index(row, col)
-                for r in connected_rows:
-                    for c in connected_cols:
+                for c in connected_cols:
+                    for r in connected_rows:
                         b = logical_index(r, c)
                         if a != b:
                             coupling_map.add((a, b))
-                            coupling_map.add((b, a))
 
         self._coupling_map = sorted(coupling_map)
 
@@ -1541,11 +1754,9 @@ class QrackAceBackend:
             )
         noise_model = NoiseModel()
 
+        # Single-qubit depolarizing only on boundary qubits
         boundary_qubits = set()
         for a, b in self.get_logical_coupling_map():
-            if a > b:
-                #Skip duplicates
-                continue
             col_a = a % self._row_length
             col_b = b % self._row_length
             is_long_a = self._is_col_long_range[col_a]
@@ -1556,6 +1767,12 @@ class QrackAceBackend:
                 if not is_long_b:
                     boundary_qubits.add(b)
 
+        for q in boundary_qubits:
+            for gate in ["u", "u1", "u2", "u3", "h", "x", "y", "z",
+                         "s", "sdg", "t", "tdg", "rx", "ry", "rz"]:
+                noise_model.add_quantum_error(
+                    depolarizing_error(x, 1), gate, [q])
+
         # Two-qubit depolarizing on boundary-crossing and boundary-adjacent gates
         for a, b in self.get_logical_coupling_map():
             col_a = a % self._row_length

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.3 → 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.3
+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.3 → 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.3 → 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.3"
+VERSION = "2.3.0"
 
 # Read long description from README.
 README_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'README.md')