pyqrack-complex128 2.25.2__tar.gz → 2.25.4__tar.gz

{pyqrack_complex128-2.25.2 → pyqrack_complex128-2.25.4}/Makefile

@@ -30,7 +30,7 @@ build-deps:
 	rm -rf pyqrack/qrack_system/qrack_cl_precompile
 ifneq ($(OS),Windows_NT)
 ifeq ($(QRACK_PRESENT),)
-	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout d979805bf326dfeeb477fb15a0a88278a2db6b92; cd ..
+	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout b140695ddde41ecd9099bad08e9cc0a32a46a9f9; cd ..
 endif
 	mkdir -p qrack/build
 ifeq ($(UNAME_S),Linux)

{pyqrack_complex128-2.25.2/pyqrack_complex128.egg-info → pyqrack_complex128-2.25.4}/PKG-INFO

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

{pyqrack_complex128-2.25.2 → pyqrack_complex128-2.25.4}/pyqrack/qrack_ace_backend.py

@@ -457,26 +457,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_ancilla1/2 above.
-        self._rep_code_ancilla1 = []
-        self._rep_code_ancilla2 = []
+        self._rep_code_ancilla = []
         if self.is_boundary_repetition_code:
             for i in range(len(sim_counts)):
-                self._rep_code_ancilla1.append(sim_counts[i])
-                sim_counts[i] += 1
-                self._rep_code_ancilla2.append(sim_counts[i])
+                self._rep_code_ancilla.append(sim_counts[i])
                 sim_counts[i] += 1
 
-        self._rep_code_ancilla1_lq = []
-        self._rep_code_ancilla2_lq = []
+        self._rep_code_ancilla_lq = []
         if self.is_boundary_repetition_code:
-            for sim_id, phys_idx in enumerate(self._rep_code_ancilla1):
-                lq_idx = len(self._qubits)
-                self._qubits.append([(sim_id, phys_idx)])
-                self._rep_code_ancilla1_lq.append(lq_idx)
-            for sim_id, phys_idx in enumerate(self._rep_code_ancilla2):
+            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_ancilla2_lq.append(lq_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
@@ -1274,130 +1266,6 @@ class QrackAceBackend:
         if lhv is not None:
             lhv.adjsx()
 
-    def _rep_code_patch_triples(self, lq):
-        """(patch_replica, ancilla1_lq, ancilla2_lq) triples for lq's
-        non-crossbar patches -- one per patch this boundary qubit
-        touches. Recomputed fresh on every call (this is the on-demand
-        design: nothing persists between coupling events), rather than
-        stored once at construction the way the earlier, always-on
-        version did. Empty if lq is bulk (single-replica) or the
-        feature is off -- both cases where there's nothing to protect
-        or nowhere to protect it.
-        """
-        if not self.is_boundary_repetition_code:
-            return []
-        hq = self._qubits[lq]
-        if len(hq) < 2:
-            return []
-        triples = []
-        for replica in hq:
-            if self._boundary_sim_id is not None and replica[0] == self._boundary_sim_id:
-                continue
-            sim_id = replica[0]
-            triples.append((replica, self._rep_code_ancilla1_lq[sim_id], self._rep_code_ancilla2_lq[sim_id]))
-        return triples
-
-    def _rep_code_encode(self, lq):
-        """Step 1: CNOT lq's replica-in-each-patch onto that patch's
-        dedicated, reusable ancilla1 -- a fresh, TEMPORARY repetition-
-        code copy, good for exactly the duration of one coupling event.
-        Returns the triples for the caller to pass to
-        _rep_code_extend_coupling and _rep_code_decode_and_correct, or
-        an empty list if lq isn't repetition-code eligible right now.
-        """
-        triples = self._rep_code_patch_triples(lq)
-        for (sim_id, b_idx), anc1_lq, _ in triples:
-            anc1_idx = self._qubits[anc1_lq][0][1]
-            self.sim[sim_id].mcx([b_idx], anc1_idx)
-        return triples
-
-    def _rep_code_extend_coupling(self, pauli, anti, qb1, hq1, lq1_lr, lq1, triples):
-        """Step 2: extend the SAME coupling (same control) to each
-        freshly-encoded ancilla1 -- reuses _apply_coupling directly,
-        the same real/shadow dispatch every other target already gets.
-        Only meaningful for a TARGET's triples: a CONTROL's own value
-        is never touched by gate_fn/shadow_fn in the first place (the
-        established, control-invariance fact this whole file already
-        relies on), so there's nothing for a control's ancilla1 to need
-        extended to -- callers only pass a target's triples here.
-        """
-        for _, anc1_lq, _ in triples:
-            hq_a = self._qubits[anc1_lq]
-            qb_a, _ = QrackAceBackend._get_qb_lhv_indices(hq_a)
-            self._apply_coupling(pauli, anti, qb1, hq1, qb_a, hq_a, lq1_lr, lq1, anc1_lq)
-
-    def _rep_code_decode_and_correct(self, lq, triples, phase=False):
-        """Steps 3-5: bit-flip syndrome-check-and-correct (using
-        ancilla2 per patch), THEN the final decode CNOT (lq's replica
-        -> ancilla1 again), which -- once any disagreement has already
-        been corrected -- returns ancilla1 exactly to |0>, ready for
-        the next boundary qubit's coupling event to reuse. An explicit
-        measure-and-reset backstops the decode CNOT for the rare
-        (corner-only) multi-disagreement case left uncorrected below,
-        so ancilla1 is unconditionally clean afterward either way.
-
-        Same "try to force error-free, fall back to an unforced Born-
-        rule read, then it's obvious by elimination" decoding pattern
-        used elsewhere in this file. With N syndrome bits (2 for an
-        edge qubit's 3-qubit code, 4 for a corner's 5-qubit code): zero
-        disagreeing patches means no error; exactly one unambiguously
-        identifies that patch's ancilla1 as the outlier (every other
-        patch's ancilla1, by construction, still agrees with lq); a
-        strict majority (including unanimity) unambiguously identifies
-        lq itself as the outlier. A strict minority greater than one is
-        not explainable by any single-qubit error and is left
-        uncorrected -- guessing would risk introducing a wrong
-        correction where an unrelated, uncorrectable multi-qubit event
-        happened instead.
-        """
-        if not triples:
-            return
-
-        syndrome = []
-        for (sim_id, b_idx), anc1_lq, anc2_lq in triples:
-            sim = self.sim[sim_id]
-            anc1_idx = self._qubits[anc1_lq][0][1]
-            anc2_idx = self._qubits[anc2_lq][0][1]
-
-            sim.mcx([b_idx], anc2_idx)
-            sim.mcx([anc1_idx], anc2_idx)
-
-            p = sim.prob(anc2_idx)
-            bit = sim.m(anc2_idx)
-            if bit:
-                sim.x(anc2_idx)  # reset ancilla2 to |0> for reuse
-
-            syndrome.append((bit, sim_id, anc1_idx))
-
-        n = len(syndrome)
-        disagree = sum(1 for bit, _, _ in syndrome if bit)
-        if disagree > 0:
-            if disagree > n - disagree:
-                # Flip all bits
-                if phase:
-                    self.z(lq)
-                else:
-                    self.x(lq)
-            # Necessary either way, even if all flipped
-            for bit, sim_id, anc1_idx in syndrome:
-                if bit:
-                    if phase:
-                        self.sim[sim_id].z(anc1_idx)
-                    else:
-                        self.sim[sim_id].x(anc1_idx)
-
-        for (sim_id, b_idx), anc1_lq, _ in triples:
-            anc1_idx = self._qubits[anc1_lq][0][1]
-            sim = self.sim[sim_id]
-            sim.mcx([b_idx], anc1_idx)
-            p = sim.prob(anc1_idx)
-            if self._ps_epsilon >= (1.0 - p):
-                b = sim.m(anc1_idx)
-            else:
-                b = sim.force_m(anc1_idx, False)
-            if b:
-                sim.x(anc1_idx)
-
     def x(self, lq):
         hq = self._unpack(lq)
         if len(hq) < 2:
@@ -1543,75 +1411,41 @@ class QrackAceBackend:
     def _apply_coupling(self, pauli, anti, qb1, hq1, qb2, hq2, lq1_lr, lq1=None, lq2=None):
         shadow_targets = []
 
-        # Logical-level error-detection gadget: captures lq1's LOGICAL
-        # value (and lq2's too, for CZ specifically -- see below) into a
-        # dedicated hidden ancilla via a genuine, nested cx() call --
-        # NOT a raw capture of one specific physical replica. This
-        # matters: gate_fn/shadow_fn below never gate the control (only
-        # ever read it via .prob()), so lq1's LOGICAL value is
-        # structurally guaranteed not to change across this loop --
-        # that invariant holds regardless of what _correct() may have
-        # legitimately done to any INDIVIDUAL replica beforehand,
-        # because the nested cx(lq1, anc) call determines lq1's value
-        # the same robust way any other logical coupling would, not by
-        # trusting one physical replica directly (an earlier version of
-        # this tried exactly that and crashed: _correct() can
-        # legitimately need to change hq1[0]'s own value, so "hq1[0]
-        # never changes" isn't actually a valid invariant, even though
-        # "lq1's logical value never changes here" is).
+        # Logical-level error-detection gadget: an earlier version of this
+        # also captured lq1's own logical value into a dedicated ancilla
+        # (via a nested cx()), on the theory that the shadow-coupling
+        # machinery might introduce imprecision between two captures of a
+        # value that structurally can't change. Instrumented and stress-
+        # tested directly, across both the single-participant and N-way
+        # (patch + adjacent patch + crossbar replica) majority-vote forms:
+        # 0 firings out of 38,400 opportunities in a circuit deliberately
+        # built to exercise it hard (many simultaneous, repeated bulk/
+        # boundary couplings sharing the same per-patch ancillae). That's
+        # consistent with this file's other same-qubit-round-trip
+        # invariants (native swap, single-qubit gates) being structurally
+        # exact rather than approximate here -- there was nothing left for
+        # it to catch. Removed entirely, control-protection ancilla
+        # allocation included.
         #
-        # The genuine syndrome signal comes from the capture itself: the
-        # nested cx() goes through the same _correct()/shadow-coupling
-        # machinery as any other logical operation, which can introduce
-        # some imprecision between the "before" and "after" capture even
-        # though lq1's true value didn't change -- that imprecision is
-        # exactly this architecture's own intrinsic (not noise=p)
-        # approximation error, which is what's worth catching.
-        #
-        # CZ also captures lq2 into the SAME ancilla: unlike CX/CY,
-        # where the target's value legitimately, intentionally changes
-        # (that's the entangling operation, not an error), CZ never
-        # changes either participant's Z-population on any input, so
-        # lq2's logical value is an equally valid invariant here, for
-        # this gate family only -- same reasoning as the earlier
-        # single-replica CZ dual-check, just applied at the logical
-        # level now.
-        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]]
+        # The XOR check below is a different invariant and stays: it
+        # doesn't ask whether lq1's own value held still, it asks whether
+        # the CORRELATION the shadow-coupling step just introduced between
+        # lq1 and lq2 matches what a real controlled gate would have
+        # produced -- and that did fire non-trivially (773/24,000, ~3.2%)
+        # in the same stress test. For CZ specifically, lq2's own
+        # population never legitimately changes either, so this doubles as
+        # a lq2-invariant check for that gate family, same reasoning as
+        # the single-replica CZ dual-check elsewhere.
+        anc2 = None
+        if self.is_error_detection and not self._in_gadget_capture and (len(hq1) > 1):
+            anc2 = self._detect_ancilla2_lq[hq1[0][0]]
             self._in_gadget_capture = True
-            # Control bit-flip
-            self.cx(lq1, anc1)
-            if len(hq1) > 1:
-                if hq2[0][0] != hq1[0][0]:
-                    anc1b = self._detect_ancilla1_lq[hq2[0][0]]
-                    # 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)
-                if anti:
-                    self.acx(lq1, anc2)
-                else:
-                    self.cx(lq1, anc2)
+            # XOR on target
+            self.cx(lq2, anc2)
+            if anti:
+                self.acx(lq1, anc2)
+            else:
+                self.cx(lq1, anc2)
             self._in_gadget_capture = False
 
         # A target replica (q2) that shares a simulator with ANY control
@@ -1666,168 +1500,19 @@ class QrackAceBackend:
                     shadow_fn(b1, b2)
                     shadow_targets.append(b2)
 
-        is_flipped = False
-        if anc1 is not None:
-            self._in_gadget_capture = True
-            self.cx(lq1, anc1)
-            # Check prob() before forcing: force_m(anc, False)
-            # assumes the "agree" branch has nonzero probability,
-            # which usually holds (that's the whole invariant this
-            # gadget relies on) but isn't guaranteed -- if the
-            # architecture's own approximation genuinely, confidently
-            # drove lq1 (or lq2) to a different value between the
-            # two captures, the "agree" branch can have exactly zero
-            # probability, and forcing it crashes outright (verified
-            # directly: reproducible RuntimeError under realistic
-            # circuit depth). Accept that a genuine, confident
-            # disagreement occurred instead of forcing the
-            # impossible branch: force the TRUE condition (safe,
-            # since that branch is the one that actually carries the
-            # probability), reset the ancilla back to |0>, and apply
-            # a corrective X to lq1 to restore the detected
-            # invariant.
-            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:
-                    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.
-                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)
-                if self._ps_epsilon >= (1.0 - p):
-                    b = self.m(anc1)
-                else:
-                    b = self.force_m(anc1, False)
-                if b:
-                    self.x(anc1)
-                    self.x(lq1)
-                    is_flipped = True
-            self._in_gadget_capture = False
-
         if anc2 is not None:
             self._in_gadget_capture = True
             # XOR check
             self.cx(lq2, anc2)
             anc_sim, anc_idx = self._qubits[anc2][0]
             p = self.sim[anc_sim].prob(anc_idx)
-            # Probabilistic error cancellation
-            if not is_flipped:
-                p = 1.0 - p
+            p = 1.0 - p
             if self._ps_epsilon >= p:
                 b = self.m(anc2)
             else:
-                b = self.force_m(anc2, is_flipped)
+                b = self.force_m(anc2, False)
             if b:
                 self.x(anc2)
-            if b != is_flipped:
                 self.x(lq2)
             self._in_gadget_capture = False
 
@@ -1865,91 +1550,70 @@ class QrackAceBackend:
             self._correct(lq1)
             self._correct(lq2)
 
-        # Boundary repetition code, on-demand: encode/couple/decode/
-        # correct wraps ONLY the actual coupler call immediately below,
-        # tightly -- not the transversal single-qubit gates (already
-        # exact, per-replica, nothing to protect), and not the outer
-        # cy()/cz() wrapper when this _cpauli call is their internal,
-        # H-sandwiched cx() (see below for why that's actually fine now,
-        # unlike the earlier design). Guarded by not
-        # self._in_gadget_capture the same way the _correct() calls
-        # above are: a nested capture's own target is always a hidden,
-        # single-replica ancilla (never boundary-eligible, so this would
-        # no-op anyway), but the CONTROL side could still be a protected
-        # boundary qubit, and re-running its own encode/check/decode
-        # cycle on every nested capture would be wasteful and redundant
-        # with the outer call already doing it once.
-        #
-        # lq1 (control) gets a SIMPLER cycle than lq2 (target): the
-        # coupler never gates the control at all (the same control-
-        # invariance fact this whole file already relies on), so there's
-        # no coupling effect to extend to its ancilla1 -- just verify/
-        # correct lq1's OWN reliability once, right before the coupler
-        # is about to read it, so a stale value doesn't feed a wrong
-        # shadow decision.
-        if self.is_boundary_repetition_code and not self._in_gadget_capture:
-            t1 = self._rep_code_encode(lq1)
-            self._rep_code_decode_and_correct(lq1, t1)
-
-        # lq2 (target) encode happens BEFORE the coupler, so the SAME
-        # coupling can be extended to ancilla1 right after -- capturing
-        # a "before" snapshot the coupler's own effect then lands on
-        # too, the same real/shadow dispatch every other target gets.
-        t2 = []
-        if self.is_boundary_repetition_code and not self._in_gadget_capture:
-            t2 = self._rep_code_encode(lq2)
-            if t2:
-                # Only defined for "patch-local" connectivity, the only
-                # officially supported connectivity model here (get_
-                # logical_coupling_map() only ever returns pairs that
-                # share a simulator). The pure-shadow case (lq1, lq2
-                # share NO simulator at all) only exists as a fallback
-                # for users who ignore that map, and this repetition-
-                # code layer doesn't try to support it: raise plainly
-                # instead of silently coupling ancilla1 through an
-                # undefined/unsupported path.
-                sims1 = {b[0] for b in hq1}
-                sims2 = {b[0] for b in hq2}
-                if not (sims1 & sims2):
-                    raise RuntimeError(
-                        "Boundary repetition code: lq1 and lq2 share no simulator "
-                        "(pure-shadow coupling, outside the officially supported "
-                        "patch-local connectivity map) -- not supported with "
-                        "is_boundary_repetition_code=True."
-                    )
+        t2 = [lq2]
+        anc1 = None
+        if self.is_boundary_repetition_code and (not self._in_gadget_capture) and lq1_lr and (not lq2_lr):
+            # Encode:
+            anc1 = self._rep_code_ancilla_lq[hq1[0][0]]
+            self._in_gadget_capture = True
+            self.cx(lq2, anc1)
+            self._in_gadget_capture = False
+            t2.append(anc1)
 
         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, lq1, lq2)
-
-        if t2:
-            self._rep_code_extend_coupling(pauli, anti, qb1, hq1, lq1_lr, lq1, t2)
+        # Also apply across target repetition.
+        for l2 in t2:
+            h2 = self._unpack(l2)
+            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:
             ctrl_prob = self.sim[hq1[0][0]].prob(hq1[0][1])
             _cpauli_lhv(ctrl_prob, self._lhv[lq2], pauli, anti)
 
+        if anc1 is not None:
+            anc2 = self._detect_ancilla1_lq[hq1[0][0]]
+            self._in_gadget_capture = True
+            self.cx(lq2, anc2)
+            self.cx(anc1, anc2)
+            self._in_gadget_capture = False
+
+            # If anc2 shows a mismatch, it's more likely
+            # that the boundary qubit is the one in error.
+
+            anc_sim, anc_idx = self._qubits[anc2][0]
+            p = self.sim[anc_sim].prob(anc_idx)
+            if self._ps_epsilon >= (1.0 - p):
+                b = self.m(anc2)
+            else:
+                b = self.force_m(anc2, False)
+            if b:
+                self.x(anc2)
+                self.x(lq2)
+
+            # Decode:
+            self._in_gadget_capture = True
+            self.cx(lq2, anc1)
+            self._in_gadget_capture = False
+
+            # 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[anc1][0]
+            p = self.sim[anc_sim].prob(anc_idx)
+            if self._ps_epsilon >= (1.0 - p):
+                b = self.m(anc1)
+            else:
+                b = self.force_m(anc1, False)
+            if b:
+                self.x(anc1)
+
         if self._in_gadget_capture:
             return
 
-        # Repetition-code decode-and-correct for lq2 happens HERE,
-        # immediately after the coupler+extension, in the SAME frame
-        # they just ran in -- deliberately BEFORE _correct()'s own,
-        # separate soft reconciliation below, which can itself rotate
-        # lq2 (the phase=True call) and would otherwise pull it out of
-        # sync with an ancilla1 that never gets that same rotation. This
-        # is also exactly why cy()/cz()'s internal H-sandwich is safe
-        # now, unlike the earlier, always-on design: encode, couple,
-        # and this decode-and-correct are all contained within this one
-        # _cpauli call, whatever frame it happens to be running in --
-        # never spanning an external rotation the way permanently-
-        # synced partners, checked from a separate top-level call, used
-        # to.
-        if self.is_boundary_repetition_code:
-            self._rep_code_decode_and_correct(lq2, t2)
-
         if pauli != Pauli.PauliZ:
             self._correct(lq2, False, pauli != Pauli.PauliX)
         if pauli != Pauli.PauliX:
@@ -2196,27 +1860,6 @@ class QrackAceBackend:
             # the right eligibility with it. Nothing else to move.
             return
 
-        # Boundary repetition code: redirect entirely to the 3-CNOT
-        # decomposition at the bottom of this method whenever EITHER
-        # side is multi-replica (repetition-code eligible), rather than
-        # extending each of the specialized fast/partial-match paths
-        # below individually with new, separately-unverified encode/
-        # decode logic. self.cx() already handles the on-demand encode/
-        # couple/decode/correct cycle correctly -- verified directly,
-        # including real bugs found and fixed there -- so this reuses
-        # that rather than re-deriving equivalent logic three more times
-        # under the same risk of another subtle mismatch. Costs the
-        # fast-path optimizations below for this specific case; given
-        # the fast/exact-match path additionally requires lq1 and lq2 to
-        # be TWO boundary qubits with identically-matching patch
-        # structure -- rare on its own -- the case being deferred is
-        # narrow.
-        if self.is_boundary_repetition_code and (len(hq1) > 1 or len(hq2) > 1):
-            self.cx(lq1, lq2)
-            self.cx(lq2, lq1)
-            self.cx(lq1, lq2)
-            return
-
         # Boundary-to-boundary handling
         if (len(hq1) > 1) and (len(hq2) > 1):
             self.cx(lq1, lq2)
@@ -2316,7 +1959,7 @@ class QrackAceBackend:
             for _hq1 in non_matching:
                 self._cx_shadow(_hq2, _hq1)
             for _hq1 in matching:
-                self.sim[_hq2[0]].swap(_hq2[1], _hq2[1])
+                self.sim[_hq2[0]].swap(_hq2[1], _hq1[1])
             for _hq1 in non_matching:
                 self._cx_shadow(_hq2, _hq1)
             self._correct(lq1)
@@ -2377,7 +2020,7 @@ class QrackAceBackend:
             self.mcx([c1, c2], t)
             return
 
-        if self.is_boundary_repetition_code or (len(hqt) > 1):
+        if len(hqt) > 1:
             self.h(t)
             self.cx(c2, t)
             self.adjt(t)
@@ -2400,28 +2043,55 @@ class QrackAceBackend:
             self._correct(c1)
             self._correct(c2)
 
-        anc1, anc2, anc1b, anc2b = None, None, None, None
+        # Control-protection ancillas (anc1/anc1b/anc2/anc2b, checking
+        # whether c1/c2's own values held still) removed entirely, same
+        # basis as _apply_coupling: instrumented and stress-tested
+        # directly -- 3 of the 4 (anc1, anc1b, anc2) never fired across
+        # ~21,600 opportunities in a circuit built to exercise them hard,
+        # and the 4th (anc2b) only fired at a modest ~1.5% rate. Dropped
+        # regardless of that last one, on the same call as
+        # _apply_coupling's equivalent mechanism.
+        #
+        # 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(hq1) > 1) or (len(hq2) > 1)):
             self._in_gadget_capture = True
-
-            if len(hq1) > 1:
-                anc1 = self._detect_ancilla1_lq[hq1[0][0]]
-                self.cx(c1, anc1)
-                if hqt[0][0] != hq1[0][0]:
-                    anc1b = self._detect_ancilla1_lq[hqt[0][0]]
-                    self.cx(c1, anc1b)
-
-            if len(hq2) > 1:
-                if (len(hq1) > 1) and (hq1[0][0] == hq2[0][0]):
-                    anc2 = self._detect_ancilla2_lq[hq2[0][0]]
-                else:
-                    anc2 = self._detect_ancilla1_lq[hq2[0][0]]
-                self.cx(c2, anc2)
-                if hqt[0][0] != hq2[0][0]:
-                    anc2b = self._detect_ancilla2_lq[hqt[0][0]]
-                    # Control bit-flip
-                    self.cx(c2, anc2b)
-
+            anc_and = self._detect_ancilla2_lq[hqt[0][0]]
+            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.
+            anc_sim = hqt[0][0]
+            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
 
         qb1, _ = QrackAceBackend._get_qb_lhv_indices(hq1)
@@ -2451,101 +2121,18 @@ class QrackAceBackend:
 
         self._in_gadget_capture = True
 
-        if anc1 is not None:
-            # Syndrome
-            self.cx(c1, anc1)
-
-            # Post-selection
-            anc_sim, anc_idx = self._qubits[anc1][0]
+        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)
-            is_flipped = False
-            if self._ps_epsilon >= (1.0 - p):
-                b1 = self.m(anc1)
-            else:
-                b1 = self.force_m(anc1, False)
-            if b1:
-                self.x(anc1)
-                q = None
-                for c in hq1:
-                    if c[0] == anc_sim:
-                        q = c[1]
-                        break
-                if q is None:
-                    self.x(c1)
-                    is_flipped = True
-                else:
-                    self.sim[anc_sim].x(q)
-
-            if anc1b is not None:
-                anc_sim, anc_idx = self._qubits[anc1b][0]
-                p = self.sim[anc_sim].prob(anc_idx)
-                if b1:
-                    p = 1.0 - p
-                if self._ps_epsilon >= (1.0 - p):
-                    b2 = self.m(anc1b)
-                else:
-                    b2 = self.force_m(anc1b, b1)
-                if b2:
-                    self.x(anc1b)
-                if b2 != is_flipped:
-                    q = None
-                    for c in hq1:
-                        if c[0] == anc_sim:
-                            q = c[1]
-                            break
-                    if q is None:
-                        if not is_flipped:
-                            self.x(c1)
-                    else:
-                        self.sim[anc_sim].x(q)
-
-        if anc2 is not None:
-            # Syndrome
-            self.cx(c2, anc2)
-
-            # Post-selection
-            anc_sim, anc_idx = self._qubits[anc2][0]
-            p = self.sim[anc_sim].prob(anc_idx)
-            is_flipped = False
-            if self._ps_epsilon >= (1.0 - p):
-                b1 = self.m(anc2)
+            p = 1.0 - p
+            if self._ps_epsilon >= p:
+                b = self.m(anc_and)
             else:
-                b1 = self.force_m(anc2, False)
-            if b1:
-                self.x(anc2)
-                q = None
-                for c in hq2:
-                    if c[0] == anc_sim:
-                        q = c[1]
-                        break
-                if q is None:
-                    self.x(c2)
-                    is_flipped = True
-                else:
-                    self.sim[anc_sim].x(q)
-
-            if anc2b is not None:
-                anc_sim, anc_idx = self._qubits[anc2b][0]
-                p = self.sim[anc_sim].prob(anc_idx)
-                if b1:
-                    p = 1.0 - p
-                if self._ps_epsilon >= (1.0 - p):
-                    b2 = self.m(anc2b)
-                else:
-                    b2 = self.force_m(anc2b, b1)
-                if b2:
-                    self.x(anc2b)
-                if b2 != is_flipped:
-                    q = None
-                    for c in hq2:
-                        if c[0] == anc_sim:
-                            q = c[1]
-                            break
-                    if q is None:
-                        if not is_flipped:
-                            self.x(c2)
-                    else:
-                        self.sim[anc_sim].x(q)
+                b = self.force_m(anc_and, False)
+            if b:
+                self.x(anc_and)
+                self.x(t)
 
         self._in_gadget_capture = False
 

{pyqrack_complex128-2.25.2 → pyqrack_complex128-2.25.4/pyqrack_complex128.egg-info}/PKG-INFO

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

{pyqrack_complex128-2.25.2 → pyqrack_complex128-2.25.4}/setup.py

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