pyqrack-complex128 2.22.2__tar.gz → 2.22.4__tar.gz

{pyqrack_complex128-2.22.2/pyqrack_complex128.egg-info → pyqrack_complex128-2.22.4}/PKG-INFO

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

{pyqrack_complex128-2.22.2 → pyqrack_complex128-2.22.4}/pyqrack/qrack_ace_backend.py

@@ -1552,7 +1552,7 @@ class QrackAceBackend:
         # this gate family only -- same reasoning as the earlier
         # single-replica CZ dual-check, just applied at the logical
         # level now.
-        anc1, anc2, anc1b = None, None, None
+        anc1, anc2, anc1b, anc1c = None, None, None, None
         if self.is_error_detection and not self._in_gadget_capture and ((len(hq1) > 1) or (len(hq2) > 1)):
             anc1 = self._detect_ancilla1_lq[hq1[0][0]]
             self._in_gadget_capture = True
@@ -1564,6 +1564,23 @@ class QrackAceBackend:
                     # Control bit-flip
                     self.cx(lq1, anc1b)
 
+                # Third participant: hq1 is a boundary qubit here
+                # (len(hq1) > 1), so it always carries a genuine physical
+                # replica in the shared boundary "crossbar" simulator too
+                # -- index 2 of its replica list, by construction (see
+                # __init__'s qubit-building loop: the crossbar replica is
+                # always appended right after the (up to two) patch
+                # replicas, for every boundary qubit, edge or corner
+                # alike). That replica was never checked by this gadget
+                # before now, even though it's a distinct physical copy
+                # of lq1's value -- give it its own dedicated ancilla,
+                # already allocated in the crossbar sim alongside every
+                # other simulator's pair, and capture lq1 through it the
+                # same nested-cx way as anc1/anc1b, so it can vote
+                # alongside them below instead of going unchecked.
+                anc1c = self._detect_ancilla1_lq[hq1[2][0]]
+                self.cx(lq1, anc1c)
+
                 anc2 = self._detect_ancilla2_lq[hq1[0][0]]
                 # XOR on target
                 self.cx(lq2, anc2)
@@ -1645,38 +1662,120 @@ class QrackAceBackend:
             # probability), reset the ancilla back to |0>, and apply
             # a corrective X to lq1 to restore the detected
             # invariant.
-            if anc1b is not None:
-                self.cx(lq1, anc1b)
-                anc_sim, anc_idx = self._qubits[anc1][0]
-                p1 = self.sim[anc_sim].prob(anc_idx)
-                anc_sim, anc_idx = self._qubits[anc1b][0]
-                p2 = self.sim[anc_sim].prob(anc_idx)
-                if self._ps_epsilon >= (1.0 - p1):
-                    b1 = self.force_m(anc1, True)
-                    if self._ps_epsilon >= p2:
-                        b2 = self.force_m(anc1b, True)
-                    else:
-                        b2 = self.m(anc1b)
-                elif self._ps_epsilon >= (1.0 - p2):
-                    b2 = self.force_m(anc1b, True)
-                    if self._ps_epsilon >= p1:
-                        b1 = self.force_m(anc1, True)
-                    else:
-                        b1 = self.m(anc1)
+            if (anc1b is not None) or (anc1c is not None):
+                # Generalized N-way version (N = 2 or 3, i.e. patch A and
+                # patch B and/or the crossbar's own replica) of the
+                # single-pair steering above: same per-participant rule,
+                # just no longer hand-written per pair. Read every
+                # participant's prob() BEFORE forcing any of them (a
+                # forced measurement can affect correlated others), find
+                # whichever one -- if any -- shows confident (within
+                # ps_epsilon of certain) evidence of an actual flip, force
+                # THAT one first (the branch its own probability actually
+                # supports, never the near-impossible one), then for each
+                # remaining participant either steer it to agree (force
+                # True) if its own signal is too close to the hard-zero
+                # boundary to trust as an honest independent reading, or
+                # let it measure honestly otherwise -- exactly the same
+                # judgment call the original single anc1b case made, now
+                # just applied per-participant in a loop. If nobody shows
+                # confident evidence of a flip, every participant is
+                # forced to the "no error" branch, as before.
+                ancs = [anc1] + ([anc1b] if anc1b is not None else []) + ([anc1c] if anc1c is not None else [])
+                # Complete each participant's before/after XOR capture
+                # (anc1's own second cx() already happened just above,
+                # unconditionally) before reading any prob() below.
+                if anc1b is not None:
+                    self.cx(lq1, anc1b)
+                if anc1c is not None:
+                    self.cx(lq1, anc1c)
+                probs = []
+                for a in ancs:
+                    anc_sim, anc_idx = self._qubits[a][0]
+                    probs.append(self.sim[anc_sim].prob(anc_idx))
+
+                anchor = None
+                for i in range(len(ancs)):
+                    if self._ps_epsilon >= (1.0 - probs[i]):
+                        anchor = i
+                        break
+
+                bits = [None] * len(ancs)
+                if anchor is not None:
+                    bits[anchor] = self.force_m(ancs[anchor], True)
+                    for i in range(len(ancs)):
+                        if i == anchor:
+                            continue
+                        if self._ps_epsilon >= probs[i]:
+                            bits[i] = self.force_m(ancs[i], True)
+                        else:
+                            bits[i] = self.m(ancs[i])
                 else:
-                    b1 = self.force_m(anc1, False)
-                    b2 = self.force_m(anc1b, False)
+                    bits = [self.force_m(a, False) for a in ancs]
+
+                # Map each participant to the SPECIFIC physical replica
+                # of hq1 its own syndrome actually covers -- anc1 is
+                # patch A (hq1[0]), anc1c is always the crossbar
+                # (hq1[2], by construction), and anc1b is whichever of
+                # hq1's replicas lives in hq2's own patch (found by sim
+                # id rather than assumed to be a fixed index, since
+                # corner qubits have patch replicas at indices 1, 3, and
+                # 4). This can legitimately be absent: hq1 and hq2 may
+                # share no common patch at all for an arbitrary (non-
+                # adjacent) logical coupling -- confirmed directly
+                # (hq1=[(2,1),(3,0),(4,2)] coupled to hq2=[(1,1)], no
+                # overlap) -- in which case there is no single physical
+                # replica to target for that participant specifically.
+                replicas = [hq1[0]]
+                if anc1b is not None:
+                    replicas.append(next((r for r in hq1 if r[0] == hq2[0][0]), None))
+                if anc1c is not None:
+                    replicas.append(hq1[2])
+
+                # Majority vote decides whether the LOGICAL value itself
+                # genuinely flipped (updating the LHV shadow, same as the
+                # transversal self.x(lq1) used to do unconditionally);
+                # any minority participant is still individually
+                # corrected below regardless, since ITS replica is wrong
+                # either way -- it just isn't treated as evidence the
+                # logical value moved, the same way a repetition code's
+                # decoded value doesn't change just because one physical
+                # bit needed fixing.
                 is_flipped = False
-                if b1:
-                    self.x(anc1)
-                    if p1 >= p2:
-                        self.x(lq1)
-                        is_flipped = True
-                if b2:
-                    self.x(anc1b)
-                    if (not is_flipped) and (p2 >= p1):
-                        self.x(lq1)
-                        is_flipped = True
+                n_flipped = sum(1 for b in bits if b)
+                if (n_flipped << 1) > len(ancs):
+                    is_flipped = True
+                    lhv = self._lhv.get(lq1)
+                    if lhv is not None:
+                        lhv.x()
+
+                for i, a in enumerate(ancs):
+                    if bits[i]:
+                        self.x(a)
+                        # Targeted, single-replica correction rather than
+                        # a transversal self.x(lq1): these replicas are a
+                        # pseudo-repetition code for lq1, and a
+                        # participant flipping means THAT PHYSICAL COPY
+                        # is the one in error, not the logical value as a
+                        # whole. Flipping every replica transversally is
+                        # only ever correct by coincidence when all
+                        # participants agree -- on a genuine minority
+                        # disagreement it would "fix" the actual error
+                        # while simultaneously breaking the (correct)
+                        # majority replicas that were never wrong. Fixing
+                        # per-replica is correct in the agreeing case too
+                        # (each flipped participant's own replica still
+                        # gets corrected), so this applies unconditionally,
+                        # not just when a disagreement is detected. Falls
+                        # back to the transversal correction only when no
+                        # single hq1 replica corresponds to this
+                        # participant at all (see the no-overlap case
+                        # above).
+                        b = replicas[i]
+                        if b is not None:
+                            self.sim[b[0]].x(b[1])
+                        else:
+                            self.x(lq1)
             else:
                 anc_sim, anc_idx = self._qubits[anc1][0]
                 p = self.sim[anc_sim].prob(anc_idx)

{pyqrack_complex128-2.22.2 → pyqrack_complex128-2.22.4/pyqrack_complex128.egg-info}/PKG-INFO

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

{pyqrack_complex128-2.22.2 → pyqrack_complex128-2.22.4}/setup.py

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