pyqrack-complex128 2.28.2__tar.gz → 2.29.1__tar.gz

{pyqrack_complex128-2.28.2/pyqrack_complex128.egg-info → pyqrack_complex128-2.29.1}/PKG-INFO

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

{pyqrack_complex128-2.28.2 → pyqrack_complex128-2.29.1}/pyqrack/qrack_ace_backend.py

@@ -218,8 +218,8 @@ def _cpauli_lhv(prob, targ, axis, anti, theta=math.pi):
 class QrackAceBackend:
     """A back end for elided quantum error correction
 
-    This back end uses elided repetition code on a nearest-neighbor topology to emulate
-    a utility-scale superconducting chip quantum computer in very little memory.4
+    This back end uses elided repetition code on a nearest-neighbor topology (but fully-connected
+    within "patches") to emulate a utility-scale superconducting chip quantum computer in very little memory.
 
     The backend was originally designed assuming an (orbifolded) 2D qubit grid like 2019 Sycamore.
     However, it quickly became apparent that users can basically design their own connectivity topologies,
@@ -229,6 +229,17 @@ class QrackAceBackend:
     (If you have 3+ patches, maybe your discrete GPU can do multiple patches in the time it takes an Intel HD
     to do one patch worth of work!)
 
+    Raw state-vector qubits can be directly manipulated through "sim" and "qubits" properties (with boundary
+    "tie-breaker" local hidden variables qubits in "lhv"). "sim" entries in the "qubits" map expose the full
+    QrackSimulator gate API.
+
+    For irregularly shaped "cutout geometries," allocate a super set of the geometric layout with this class,
+    and simply do not use unneeded qubits (and strike them from the Qiskit coupling map, for transpilation).
+    Qrack will not allocate space for any qubit that never actually becomes involved in any entangling gate.
+
+    For expected XEB across different 2D nearest-neighbor experiments, see the data set, regression model,
+    and calculator at https://tinyurl.com/qrackacexeb.
+
     Attributes:
         sim(QrackSimulator): Array of simulators corresponding to "patches" between boundary rows.
         long_range_columns(int): How many ideal rows between QEC boundary rows?
@@ -306,7 +317,7 @@ class QrackAceBackend:
         # between "more separable" (rotation toward consensus is real,
         # useful reconciliation) and "more entangled" (rotation only
         # scrambles a real correlation with another logical qubit's
-        # replica -- see _correct). Default is the point where a single
+        # replica -- see correct). Default is the point where a single
         # qubit's linear entropy is half its maximum.
         self._rot_epsilon = (1.0 - 1.0 / math.sqrt(2)) / 2
 
@@ -329,7 +340,7 @@ class QrackAceBackend:
             # rather than surgically suppressing the wrap step further
             # down (which was tried and reverted -- it produced replica
             # counts, e.g. 2, that the rest of the class was never built
-            # to handle, via _get_qb_lhv_indices/_correct, which assume
+            # to handle, via _get_qb_lhv_indices/correct, which assume
             # counts of 1, 3, or 5 only), means every code path that fires
             # for is_torus=False is one that already exists and is already
             # tested for is_torus=True; only WHICH positions take which
@@ -360,17 +371,17 @@ class QrackAceBackend:
         # grows with total boundary-qubit count rather than patch count,
         # so it doesn't scale -- off by default, and worth turning on only
         # for a handful of patches. Every boundary qubit ALSO still gets
-        # its classical LHVQubit proxy (self._lhv, below) regardless, same
+        # its classical LHVQubit proxy (self.lhv, below) regardless, same
         # as when this option is off: with the crossbar on, the proxy
-        # drops to being only the last-resort tie-breaker _correct() falls
+        # drops to being only the last-resort tie-breaker correct() falls
         # back to when even the crossbar replica is itself ambiguous; with
         # it off, the proxy is promoted to cover the crossbar's old
         # tie-breaking role directly.
         boundary_sim_id = sim_count
         boundary_count = 0
 
-        self._qubits = []
-        self._lhv = {}
+        self.qubits = []
+        self.lhv = {}
         sim_counts = [0] * sim_count
         sim_id = 0
         tot_qubits = 0
@@ -388,9 +399,9 @@ class QrackAceBackend:
                         qubit.append((boundary_sim_id, boundary_count))
                         boundary_count += 1
 
-                    if (not to_clone) or (tot_qubits in to_clone._lhv):
-                        self._lhv[tot_qubits] = LHVQubit(
-                            to_clone=(to_clone._lhv[tot_qubits] if to_clone else None)
+                    if (not to_clone) or (tot_qubits in to_clone.lhv):
+                        self.lhv[tot_qubits] = LHVQubit(
+                            to_clone=(to_clone.lhv[tot_qubits] if to_clone else None)
                         )
 
                 if (not c) and (not r):
@@ -405,8 +416,8 @@ class QrackAceBackend:
                 if not c:
                     sim_id = (sim_id + 1) % sim_count
 
-                self._qubits.append(
-                    list(to_clone._qubits[tot_qubits]) if to_clone else qubit
+                self.qubits.append(
+                    list(to_clone.qubits[tot_qubits]) if to_clone else qubit
                 )
                 tot_qubits += 1
 
@@ -430,10 +441,10 @@ class QrackAceBackend:
         # See _apply_coupling for the actual gadget; this block only does
         # the qubit-index bookkeeping, in the same style as every other
         # per-simulator allocation above.
-        self._detect_ancilla = []
+        detect_ancilla = []
         if self.is_error_detection:
             for i in range(len(sim_counts)):
-                self._detect_ancilla.append(sim_counts[i])
+                detect_ancilla.append(sim_counts[i])
                 sim_counts[i] += 1
 
         # Logical-qubit wrapper around each patch's detection ancilla,
@@ -441,25 +452,25 @@ class QrackAceBackend:
         # (self.cx(lq1, anc)), not just raw (sim, idx) tuples. Appended
         # PAST the user-facing qubit range (num_qubits() is computed
         # independently from the grid dimensions, not from len(
-        # self._qubits), so these extra entries are never visible or
+        # self.qubits), so these extra entries are never visible or
         # reachable through the normal API) -- a simple, single-replica
         # (bulk-style) logical qubit per simulator, one entry in
-        # self._qubits pointing at the same physical qubit _detect_
+        # self.qubits pointing at the same physical qubit _detect_
         # ancilla already allocated there. See _apply_coupling for why
         # this needs to be a genuine logical qubit and not just a raw
         # physical capture: capturing lq1's LOGICAL value via a real,
-        # nested cx(lq1, anc) call goes through the full _correct()/
+        # nested cx(lq1, anc) call goes through the full correct()/
         # shadow-coupling machinery robustly, the same way any other
         # logical qubit's value would be determined -- watching one
         # specific physical replica directly (an earlier version of
-        # this) isn't a valid invariant, since _correct() can
+        # this) isn't a valid invariant, since correct() can
         # legitimately need to change any single replica's own value.
-        self._detect_ancilla_lq = []
+        self.detect_ancilla_lq = []
         if self.is_error_detection:
-            for sim_id, phys_idx in enumerate(self._detect_ancilla):
-                lq_idx = len(self._qubits)
-                self._qubits.append([(sim_id, phys_idx)])
-                self._detect_ancilla_lq.append(lq_idx)
+            for sim_id, phys_idx in enumerate(detect_ancilla):
+                lq_idx = len(self.qubits)
+                self.qubits.append([(sim_id, phys_idx)])
+                self.detect_ancilla_lq.append(lq_idx)
         # Boundary repetition code, on-demand design: only the couplers
         # are actually noisy here -- single-qubit gates are already
         # exactly transversal, per-replica, with zero error, so there's
@@ -473,18 +484,18 @@ class QrackAceBackend:
         # See _cpauli for the actual encode/couple/decode/correct cycle
         # built around these; this block is just the qubit-index
         # bookkeeping, in the same style as _detect_ancilla above.
-        self._rep_code_ancilla = []
+        rep_code_ancilla = []
         if self.is_boundary_repetition_code:
             for i in range(len(sim_counts)):
-                self._rep_code_ancilla.append(sim_counts[i])
+                rep_code_ancilla.append(sim_counts[i])
                 sim_counts[i] += 1
 
-        self._rep_code_ancilla_lq = []
+        self.rep_code_ancilla_lq = []
         if self.is_boundary_repetition_code:
-            for sim_id, phys_idx in enumerate(self._rep_code_ancilla):
-                lq_idx = len(self._qubits)
-                self._qubits.append([(sim_id, phys_idx)])
-                self._rep_code_ancilla_lq.append(lq_idx)
+            for sim_id, phys_idx in enumerate(rep_code_ancilla):
+                lq_idx = len(self.qubits)
+                self.qubits.append([(sim_id, phys_idx)])
+                self.rep_code_ancilla_lq.append(lq_idx)
 
         # capture calls (see _apply_coupling): those calls go through
         # the ordinary _cpauli -> _apply_coupling path themselves, which
@@ -772,7 +783,7 @@ class QrackAceBackend:
         self._cx_shadow(c1, c2)
 
     def _unpack(self, lq):
-        return self._qubits[lq]
+        return self.qubits[lq]
 
     @staticmethod
     def _get_qb_lhv_indices(hq):
@@ -783,7 +794,7 @@ class QrackAceBackend:
         # diagonal-patch); with use_crossbars=True, 3 (home + adjacent-
         # patch + shared crossbar) or 5 (home + adjacent-patch + shared
         # crossbar + 2 diagonal-patch). None of them are virtual/LHV-
-        # backed slots -- the classical LHVQubit proxy (self._lhv) is
+        # backed slots -- the classical LHVQubit proxy (self.lhv) is
         # tracked entirely separately from hq, not as one of its indices
         # -- so qb is simply every index, in order, regardless of which
         # of those counts applies. We keep this helper's name and
@@ -866,7 +877,7 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11])
 
-    def _correct(self, lq, phase=False, skip_rotation=False):
+    def correct(self, lq, phase=False, skip_rotation=False):
         hq = self._unpack(lq)
 
         if len(hq) == 1:
@@ -878,8 +889,8 @@ class QrackAceBackend:
             for q in qb:
                 b = hq[q]
                 self.sim[b[0]].h(b[1])
-            if lq in self._lhv:
-                self._lhv[lq].h()
+            if lq in self.lhv:
+                self.lhv[lq].h()
 
         if len(hq) == 4:
             # Corner-boundary qubit: 4 real replicas remain (home,
@@ -894,7 +905,7 @@ class QrackAceBackend:
             p1 = self.sim[hq[1][0]].prob(hq[1][1])
             p2 = self.sim[hq[2][0]].prob(hq[2][1])
             p3 = self.sim[hq[3][0]].prob(hq[3][1])
-            lhv = self._lhv.get(lq)
+            lhv = self.lhv.get(lq)
 
             end_caps = [p0, p1, p2, p3]
             # Classify each end-cap as decisively high / decisively low /
@@ -1010,7 +1021,7 @@ class QrackAceBackend:
             p2 = self.sim[hq[2][0]].prob(hq[2][1])
             p3 = self.sim[hq[3][0]].prob(hq[3][1])
             p4 = self.sim[hq[4][0]].prob(hq[4][1])
-            lhv = self._lhv.get(lq)
+            lhv = self.lhv.get(lq)
 
             end_caps = [p0, p1, p3, p4]
             high_count = sum(1 for x in end_caps if x > (0.5 + self._epsilon))
@@ -1076,7 +1087,7 @@ class QrackAceBackend:
             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])
-            lhv = self._lhv.get(lq)
+            lhv = self.lhv.get(lq)
 
             p1_high = p1 > (0.5 + self._epsilon)
             p1_low = p1 < (0.5 - self._epsilon)
@@ -1159,7 +1170,7 @@ class QrackAceBackend:
             # sit at old-index-2 is gone. The classical LHV proxy takes
             # over the crossbar's old role as "slot2" in the conditional
             # tie-breaking cascade below.
-            lhv = self._lhv.get(lq)
+            lhv = self.lhv.get(lq)
             p0 = self.sim[hq[0][0]].prob(hq[0][1])
             p1 = self.sim[hq[1][0]].prob(hq[1][1])
 
@@ -1292,8 +1303,8 @@ class QrackAceBackend:
             for q in qb:
                 b = hq[q]
                 self.sim[b[0]].h(b[1])
-            if lq in self._lhv:
-                self._lhv[lq].h()
+            if lq in self.lhv:
+                self.lhv[lq].h()
 
     def apply_magnetic_bias(self, q, b):
         if b == 0:
@@ -1322,11 +1333,11 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].u(b[1], th, ph, lm)
 
-        lhv = self._lhv.get(lq)
+        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)
+        # Correction deferred to next 2-qubit gate (_cpauli calls correct)
 
     def r(self, p, th, lq):
         hq = self._unpack(lq)
@@ -1341,7 +1352,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].r(p, th, b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             if p == Pauli.PauliX:
                 lhv.rx(th)
@@ -1350,7 +1361,7 @@ class QrackAceBackend:
             elif p == Pauli.PauliZ:
                 lhv.rz(th)
 
-        # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
+        # Correction deferred to next 2-qubit gate (_cpauli calls correct)
 
     def h(self, lq):
         hq = self._unpack(lq)
@@ -1365,11 +1376,11 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].h(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.h()
 
-        # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
+        # Correction deferred to next 2-qubit gate (_cpauli calls correct)
 
     def s(self, lq):
         hq = self._unpack(lq)
@@ -1384,7 +1395,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].s(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.s()
 
@@ -1401,7 +1412,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].adjs(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.adjs()
 
@@ -1418,7 +1429,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].sx(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.sx()
 
@@ -1435,7 +1446,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].adjsx(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.adjsx()
 
@@ -1452,7 +1463,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].x(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.x()
 
@@ -1469,7 +1480,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].y(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.y()
 
@@ -1486,7 +1497,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].z(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.z()
 
@@ -1503,7 +1514,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].t(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.t()
 
@@ -1520,7 +1531,7 @@ class QrackAceBackend:
             b = hq[q]
             self.sim[b[0]].adjt(b[1])
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.adjt()
 
@@ -1625,7 +1636,7 @@ class QrackAceBackend:
                 if x[0] in t_sims:
                     anc_sim = x[0]
                     break
-            anc = self._detect_ancilla_lq[anc_sim]
+            anc = self.detect_ancilla_lq[anc_sim]
             self._in_gadget_capture = True
             # XOR on target
             self.cx(lq2, anc)
@@ -1636,8 +1647,8 @@ class QrackAceBackend:
             self._in_gadget_capture = False
 
         if not self._in_gadget_capture:
-            self._correct(lq1)
-            self._correct(lq2)
+            self.correct(lq1)
+            self.correct(lq2)
 
         # A target replica (q2) that shares a simulator with ANY control
         # replica in qb1 is going to receive a REAL, exact gate from that
@@ -1651,7 +1662,7 @@ class QrackAceBackend:
         # invert the correlation sign the real CNOT is about to
         # establish. Confirmed directly: for a boundary-to-boundary
         # coupling, measuring the raw physical replica pairs that DO
-        # share a simulator (bypassing all of _correct/m's classical
+        # share a simulator (bypassing all of correct/m's classical
         # reconciliation, and with is_error_detection off) showed near-
         # perfect agreement for the one pair untouched by any earlier
         # shadow write, but only ~50-60% agreement (chance level) for
@@ -1681,7 +1692,7 @@ class QrackAceBackend:
                 # `(len(qb1) == 2) and (b1[1] == (b2[1] & 1))` as a
                 # parity-matched fallback. _get_qb_lhv_indices only ever
                 # returns length 1, 3, or 5 (bulk / edge-boundary /
-                # corner-boundary), matching self._qubits' own replica
+                # corner-boundary), matching self.qubits' own replica
                 # counts by construction -- len(qb1) == 2 is therefore
                 # unreachable, and that branch was permanently dead code
                 # (harmless, but confusing). Removed rather than kept:
@@ -1693,15 +1704,15 @@ class QrackAceBackend:
 
         if not self._in_gadget_capture:
             if pauli != Pauli.PauliZ:
-                self._correct(lq2, False, pauli != Pauli.PauliX)
+                self.correct(lq2, False, pauli != Pauli.PauliX)
             if pauli != Pauli.PauliX:
-                self._correct(lq2, True)
+                self.correct(lq2, True)
 
         if anc is not None:
             self._in_gadget_capture = True
             # XOR check
             self.cx(lq2, anc)
-            anc_sim, anc_idx = self._qubits[anc][0]
+            anc_sim, anc_idx = self.qubits[anc][0]
             p = self.sim[anc_sim].prob(anc_idx)
             p = 1.0 - p
             if self._ps_epsilon >= p:
@@ -1753,7 +1764,7 @@ class QrackAceBackend:
                 if x[0] in t_sims:
                     anc_sim = x[0]
                     break
-            anc = self._rep_code_ancilla_lq[anc_sim]
+            anc = self.rep_code_ancilla_lq[anc_sim]
             self._in_gadget_capture = True
             self.cx(lq2, anc)
             self._in_gadget_capture = False
@@ -1769,9 +1780,9 @@ class QrackAceBackend:
             qb2, _ = QrackAceBackend._get_qb_lhv_indices(h2)
             self._apply_coupling(pauli, anti, qb1, hq1, qb2, h2, lq1_lr, lq1, l2)
 
-        if lq2 in self._lhv:
+        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)
+            _cpauli_lhv(ctrl_prob, self.lhv[lq2], pauli, anti)
 
         if anc is not None:
             # Decode:
@@ -1782,7 +1793,7 @@ class QrackAceBackend:
             # After we corrected any mismatch above, it's unlikely
             # that we can't post-select no-error on this ancilla.
 
-            anc_sim, anc_idx = self._qubits[anc][0]
+            anc_sim, anc_idx = self.qubits[anc][0]
             p = self.sim[anc_sim].prob(anc_idx)
             if self._ps_epsilon >= (1.0 - p):
                 b = self.m(anc)
@@ -2011,10 +2022,10 @@ class QrackAceBackend:
         # decomposition for SDRP to truncate. This is the case the noise
         # model's common-fraction term assumes is error-free.
 
-        # _cpauli normally wraps every coupling gate with _correct() before
+        # _cpauli normally wraps every coupling gate with correct() before
         # and after, to reconcile multi-replica consensus. This method
         # calls the underlying simulators (and _cx_shadow) directly,
-        # bypassing that wrapper entirely -- _correct() is a no-op for
+        # bypassing that wrapper entirely -- correct() is a no-op for
         # single-replica (bulk) qubits, so this is always safe to call, and
         # only actually matters (and was being silently skipped) whenever
         # either side is a multi-replica boundary qubit.
@@ -2048,24 +2059,24 @@ class QrackAceBackend:
 
         if sims1.isdisjoint(sims2):
             # Once fully resolved, the swap itself is nothing but a
-            # reference exchange: self._qubits[lq] is a reference to the
+            # reference exchange: self.qubits[lq] is a reference to the
             # replica-list object, so swapping which index points to
             # which object IS the swap -- no separate content to copy.
-            self._qubits[lq1], self._qubits[lq2] = self._qubits[lq2], self._qubits[lq1]
+            self.qubits[lq1], self.qubits[lq2] = self.qubits[lq2], self.qubits[lq1]
 
-            lhv1 = self._lhv.pop(lq1, None)
-            lhv2 = self._lhv.pop(lq2, None)
+            lhv1 = self.lhv.pop(lq1, None)
+            lhv2 = self.lhv.pop(lq2, None)
             if lhv2 is not None:
-                self._lhv[lq1] = lhv2
+                self.lhv[lq1] = lhv2
             if lhv1 is not None:
-                self._lhv[lq2] = lhv1
+                self.lhv[lq2] = lhv1
 
             # Boundary repetition code needs no bookkeeping here, unlike
-            # self._qubits/self._lhv just above: it's on-demand now, not
+            # self.qubits/self.lhv just above: it's on-demand now, not
             # a permanent, per-logical-index dict of pre-allocated
-            # partners -- eligibility is just len(self._qubits[lq]) > 1,
+            # partners -- eligibility is just len(self.qubits[lq]) > 1,
             # computed fresh on every coupling event, so the reference
-            # swap of self._qubits above already, automatically carries
+            # swap of self.qubits above already, automatically carries
             # the right eligibility with it. Nothing else to move.
             return
 
@@ -2081,8 +2092,8 @@ class QrackAceBackend:
                 self.cx(lq2, lq1)
             return
 
-        self._correct(lq1)
-        self._correct(lq2)
+        self.correct(lq1)
+        self.correct(lq2)
 
         # Partial-match cases: one side is a simple (single-replica) qubit,
         # the other has multiple replicas. For the multi-replica side's
@@ -2109,12 +2120,12 @@ class QrackAceBackend:
             for _hq2 in non_matching:
                 self._cx_shadow(_hq1, _hq2)
             # No correction on lq1 (bulk, single-replica): already a
-            # structural no-op via _correct's own len(hq)==1 guard.
+            # structural no-op via correct's own len(hq)==1 guard.
             # lq2 (boundary) DOES take real error here (X-type, verified),
             # so it keeps a correction -- phase=False, not True, since the
             # error is already Z-basis-population-visible and doesn't need
             # an H-rotation first to become detectable.
-            self._correct(lq2)
+            self.correct(lq2)
         elif len(hq2) == 1 and any(h[0] == hq2[0][0] for h in hq1):
             _hq2 = hq2[0]
             non_matching = [h for h in hq1 if h[0] != _hq2[0]]
@@ -2125,14 +2136,14 @@ class QrackAceBackend:
                 self.sim[_hq2[0]].swap(_hq2[1], _hq1[1])
             for _hq1 in non_matching:
                 self._cx_shadow(_hq2, _hq1)
-            self._correct(lq1)
+            self.correct(lq1)
         else:
             # General case: no shared simulator at all (e.g. two simple
             # qubits on entirely different sims -- nothing to anchor an exact
             # swap on, verified the sandwich branches above give WRONG,
             # deterministic results here: 100/100 failures vs 0/15 for this
             # fallback), or both sides multi-replica and not fully matched:
-            # cx() already wraps itself with _correct() via _cpauli, so no
+            # cx() already wraps itself with correct() via _cpauli, so no
             # extra wrapping needed here.
             self.cx(lq1, lq2)
             self.cx(lq2, lq1)
@@ -2159,65 +2170,6 @@ class QrackAceBackend:
             self.mcx([c1, c2], t)
             return
 
-        # AND-invariant, generalized from _apply_coupling's CX/CZ XOR
-        # check to the Toffoli's actual relationship: t should end up as
-        # t_before XOR (c1 AND c2), not just t_before XOR c1 or XOR c2
-        # individually. mcx is the native AND-conditioned flip, so it
-        # plays the same role here that a plain cx(control, anc) played
-        # in the 2-qubit case: capture t's pre-gate value, then fold in
-        # c1 AND c2 via a genuine nested mcx() (which goes through the
-        # same shadow/_correct machinery as any other logical gate, so
-        # this is exposed to the same class of intrinsic approximation
-        # error the CX/CZ check catches, not a raw single-replica read).
-        # Uses t's own patch ancilla2 array, since t itself is guaranteed
-        # bulk on this path (the len(hqt) > 1 case returns earlier,
-        # above) and nothing else in this method uses that array anymore.
-        anc_and = None
-        if self.is_error_detection and not self._in_gadget_capture and ((len(hqt) > 1) or (len(hq1) > 1) or (len(hq2) > 1)):
-            found = False
-            anc_sim = hq1[0][0]
-            t_sims = {y[0] for y in hqt if y[0] >= 0}
-            for x in hq1:
-                if (x[0] < 0) or (x[0] not in t_sims):
-                    continue
-                anc_sim = x[0]
-                for y in hq2:
-                    if (y[0] < 0) or (y[0] not in t_sims):
-                        continue
-                    if anc_sim == y[0]:
-                        found = True
-                        break
-                if found:
-                    break
-            self._in_gadget_capture = True
-            anc_and = self._detect_ancilla_lq[anc_sim]
-            self.cx(t, anc_and)
-            # self.mcx() only supports a single control at the logical
-            # level (a syntax-convenience wrapper, confirmed directly --
-            # it raises for 2 controls), so it can't do the AND capture
-            # itself. When c1 and c2 both happen to have a physical
-            # replica in t's own home-patch simulator (the same one
-            # anc_and lives in), use a genuine native mcx there directly
-            # -- exact, and a clean, independent reference to compare the
-            # real Toffoli against. Otherwise, fall back to a recursive
-            # ccx(c1, c2, anc_and): safe from infinite recursion here
-            # specifically because _in_gadget_capture is already True, so
-            # the recursive call's own "not self._in_gadget_capture" gate
-            # skips setting up a second anc_and, and just performs the
-            # ordinary native-witness-or-shadow Toffoli computation on
-            # anc_and instead.
-            c1_idx = next((r[1] for r in hq1 if r[0] == anc_sim), None)
-            c2_idx = next((r[1] for r in hq2 if r[0] == anc_sim), None)
-            if (c1_idx is not None) and (c2_idx is not None):
-                _, anc_and_idx = self._qubits[anc_and][0]
-                self.sim[anc_sim].mcx([c1_idx, c2_idx], anc_and_idx)
-            else:
-                self.ccx(c1, c2, anc_and)
-            self._in_gadget_capture = False
-
-        self._correct(c1)
-        self._correct(c2)
-
         qb1, _ = QrackAceBackend._get_qb_lhv_indices(hq1)
         qb2, _ = QrackAceBackend._get_qb_lhv_indices(hq2)
         qbt, _ = QrackAceBackend._get_qb_lhv_indices(hqt)
@@ -2242,28 +2194,6 @@ class QrackAceBackend:
             witnesses.append(witness)
 
         if needs_shadow:
-            # Confirmed directly: whenever even one replica of t lacks a
-            # native witness shared with c1 and c2, the per-replica
-            # fallback to _ccx_shadow craters fidelity specifically when
-            # either control is in genuine superposition -- 0.64-0.68
-            # vs. 0.999+ for every other input tested, stable from 100 to
-            # 2500 shots, so not shot noise. Diverting the WHOLE
-            # operation (not just the unwitnessed replica) to the general
-            # 6-CX decomposition instead: every step here is a genuine
-            # logical cx()/h()/t()/adjt() call, which updates every
-            # replica of t through the same _apply_coupling boundary-
-            # crossing machinery already validated elsewhere in this
-            # file, rather than the lower-level per-replica _cx_shadow
-            # calls _ccx_shadow uses for just the unwitnessed ones.
-            #
-            # Wrapped in _in_gadget_capture, same as established earlier:
-            # without it, each individual cx() here would independently
-            # trigger its own XOR-invariant gadget setup, which corrupts
-            # the precise T/Tdg phase relationships this decomposition
-            # depends on (confirmed directly, the first time this
-            # decomposition was used unconditionally -- corrupted even
-            # c1/c2, which the per-replica path never touched at all).
-            self._in_gadget_capture = True
             self.h(t)
             self.cx(c2, t)
             self.adjt(t)
@@ -2279,29 +2209,14 @@ class QrackAceBackend:
             self.t(c1)
             self.adjt(c2)
             self.cx(c1, c2)
-            self._in_gadget_capture = False
         else:
+            self.correct(c1)
+            self.correct(c2)
+
             for (b1, b2, bt) in witnesses:
                 self.sim[b1[0]].mcx([b1[1], b2[1]], bt[1])
 
-        self._correct(t)
-
-        self._in_gadget_capture = True
-
-        if anc_and is not None:
-            self.cx(t, anc_and)
-            anc_sim, anc_idx = self._qubits[anc_and][0]
-            p = self.sim[anc_sim].prob(anc_idx)
-            p = 1.0 - p
-            if self._ps_epsilon >= p:
-                b = self.m(anc_and)
-            else:
-                b = self.force_m(anc_and, False)
-            if b:
-                self.x(anc_and)
-                self.x(t)
-
-        self._in_gadget_capture = False
+            self.correct(t)
 
     def ccz(self, c1, c2, t):
         self.h(t)
@@ -2319,9 +2234,9 @@ class QrackAceBackend:
             b = hq[0]
             return self.sim[b[0]].prob(b[1])
 
-        self._correct(lq)
+        self.correct(lq)
         # The real replicas are already mutually consistent here (the
-        # _correct() call above already ran the appropriate tie-breaking
+        # correct() call above already ran the appropriate tie-breaking
         # cascade for however many replicas hq has -- 2, 3, 4, or 5,
         # depending on self.use_crossbars and whether this is an edge or
         # corner boundary qubit -- using the LHV proxy and/or the
@@ -2330,7 +2245,7 @@ class QrackAceBackend:
         # correct, already-decided answer, regardless of replica count:
         # re-weighting any particular replica specially here would
         # reintroduce the same center-dragging distortion the cascade in
-        # _correct() was built to avoid.
+        # correct() was built to avoid.
         p = [self.sim[b[0]].prob(b[1]) for b in hq]
         n = len(p)
         prms = math.sqrt(sum(x**2 for x in p) / n)
@@ -2358,7 +2273,7 @@ class QrackAceBackend:
             else:
                 self.sim[b[0]].force_m(b[1], result)
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.reset()
             if result:
@@ -2372,7 +2287,7 @@ class QrackAceBackend:
             b = hq[0]
             return self.sim[b[0]].force_m(b[1], result)
 
-        self._correct(lq)
+        self.correct(lq)
 
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
@@ -2385,7 +2300,7 @@ class QrackAceBackend:
             else:
                 self.sim[b[0]].force_m(b[1], result)
 
-        lhv = self._lhv.get(lq)
+        lhv = self.lhv.get(lq)
         if lhv is not None:
             lhv.reset()
             if result:
@@ -2782,7 +2697,7 @@ class QrackAceBackend:
         # keep patching individual arithmetic mistakes in a function whose
         # intended row/col semantics were genuinely unclear on inspection,
         # this is grounded directly in the one thing that's true by
-        # construction: self._qubits, the actual replica structure built
+        # construction: self.qubits, the actual replica structure built
         # during __init__. Two logical qubits are coupled if and only if
         # they share ANY simulator id among their own replicas -- this
         # cannot disagree with the real adjacency, because it doesn't
@@ -2791,7 +2706,7 @@ class QrackAceBackend:
         n = self.num_qubits()
         sim_to_qubits = {}
         for lq in range(n):
-            for sim_id, _ in self._qubits[lq]:
+            for sim_id, _ in self.qubits[lq]:
                 sim_to_qubits.setdefault(sim_id, []).append(lq)
         for sim_id, qubits_here in sim_to_qubits.items():
             for a in qubits_here:
@@ -2822,7 +2737,7 @@ class QrackAceBackend:
         # are untouched -- a bulk qubit's single simulator membership
         # was never ambiguous.
         def is_boundary(lq):
-            return len(self._qubits[lq]) > 1
+            return len(self.qubits[lq]) > 1
 
         def same_single_side(idx_a, idx_b, long_range_arr, length):
             if idx_a == idx_b:
@@ -3008,8 +2923,8 @@ class QrackAceBackend:
         noise_model = NoiseModel()
 
         def _uncommon_sim_fraction(lq1, lq2):
-            sims1 = {qb[0] for qb in self._qubits[lq1]}
-            sims2 = {qb[0] for qb in self._qubits[lq2]}
+            sims1 = {qb[0] for qb in self.qubits[lq1]}
+            sims2 = {qb[0] for qb in self.qubits[lq2]}
 
             return len(sims1 ^ sims2) / len(sims1.union(sims2))
 
@@ -3022,7 +2937,7 @@ class QrackAceBackend:
         # _cpauli's own convention) to be a multi-replica (boundary)
         # qubit -- see _cpauli: anc1 (the control-invariance capture) is
         # unconditional but structurally trivial for a single-replica
-        # control (_correct() is already a no-op there, nothing for the
+        # control (correct() is already a no-op there, nothing for the
         # gadget to protect against), and anc2 (the target-value
         # verification against the CX/ACX-predicted output) is
         # explicitly gated on len(hq1) > 1. Both halves are gated the
@@ -3039,7 +2954,7 @@ class QrackAceBackend:
         # nested cx(lq1, anc) capture goes through the full logical
         # coupling machinery (shadow or real, whichever applies) and
         # works the same way regardless. So this is checked directly,
-        # per pair, from len(self._qubits[a]) -- no precomputed set
+        # per pair, from len(self.qubits[a]) -- no precomputed set
         # needed.
 
         # This factor is a theory-derived placeholder, not an empirical
@@ -3085,7 +3000,7 @@ class QrackAceBackend:
             # Pauli-string convention is big-endian relative to the qubit
             # list: the LAST qubit corresponds to the LEFTMOST character).
             p_shadow_ccz = 1 - sp * p
-            if self.is_error_detection and len(self._qubits[a]) > 1:
+            if self.is_error_detection and len(self.qubits[a]) > 1:
                 # a is the control for this pair (_cpauli(lq1=a, lq2=b,
                 # ...) is always called with a as the coupling source).
                 # Both gadget halves that protect this pair (anc1 on a,
@@ -3119,13 +3034,13 @@ class QrackAceBackend:
             # Error type re-verified directly against THIS file (the
             # gadget mechanics changed substantially since the type was
             # first derived -- swap()'s own cross-check gadget, the
-            # _correct()-skip-during-capture fix, and the post-selection
+            # correct()-skip-during-capture fix, and the post-selection
             # floor threshold are all new), to make sure none of that
             # changed the underlying picture. It hasn't: _cx_shadow
             # itself is untouched by any of it. Reading the LOGICAL
             # prob(lq) still tells you nothing (0.00000 deviation in
             # both bases on a single isolated swap, gadget on or off --
-            # it calls _correct() internally and reconciles across every
+            # it calls correct() internally and reconciles across every
             # replica, the same masking this file has run into more than
             # once). Reading the RAW, non-matching replica directly
             # (bypassing that reconciliation) gives a clean, deterministic
@@ -3160,12 +3075,12 @@ class QrackAceBackend:
             # error character isn't captured by this specific derivation;
             # that case keeps the previous symmetric depolarizing
             # treatment below as a fallback.
-            len_a = len(self._qubits[a])
-            len_b = len(self._qubits[b])
+            len_a = len(self.qubits[a])
+            len_b = len(self.qubits[b])
             is_a_simple = len_a == 1
             is_b_simple = len_b == 1
-            sims_a = [qb[0] for qb in self._qubits[a]]
-            sims_b = [qb[0] for qb in self._qubits[b]]
+            sims_a = [qb[0] for qb in self.qubits[a]]
+            sims_b = [qb[0] for qb in self.qubits[b]]
             has_match = any(s in sims_b for s in sims_a)
 
             if (is_a_simple != is_b_simple) and has_match:
@@ -3213,7 +3128,7 @@ class QrackAceBackend:
             # 4-term (I,X,Z,Y) channel down to a plain 2-term (I,Z) one.
             if (is_a_simple != is_b_simple) and has_match:
                 p_cz = 1 - sp * p  # same per-call formula as standalone cz
-                if self.is_error_detection and len(self._qubits[a]) > 1:
+                if self.is_error_detection and len(self.qubits[a]) > 1:
                     p_cz *= d
                 p_net_iswap = p_net_swap * (1 - p_cz) + p_cz * (1 - p_net_swap)
                 if is_a_simple:

{pyqrack_complex128-2.28.2 → pyqrack_complex128-2.29.1/pyqrack_complex128.egg-info}/PKG-INFO

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

{pyqrack_complex128-2.28.2 → pyqrack_complex128-2.29.1}/setup.py

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