pyqrack-complex128 2.18.2__tar.gz → 2.18.4__tar.gz

{pyqrack_complex128-2.18.2/pyqrack_complex128.egg-info → pyqrack_complex128-2.18.4}/PKG-INFO

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

{pyqrack_complex128-2.18.2 → pyqrack_complex128-2.18.4}/pyqrack/qrack_ace_backend.py

@@ -274,11 +274,11 @@ class QrackAceBackend:
         if "QRACK_FPPOW" in os.environ:
             fppow = int(os.environ.get("QRACK_FPPOW"))
         if fppow < 5:
-            self._epsilon = 2**-9
+            self._epsilon = 2**-8
         elif fppow > 5:
-            self._epsilon = 2**-51
+            self._epsilon = 2**-50
         else:
-            self._epsilon = 2**-22
+            self._epsilon = 2**-21
 
         self._coupling_map = None
 
@@ -406,18 +406,57 @@ class QrackAceBackend:
             sim_counts.append(boundary_count)
 
         # Error-detection gadget (IBM-style detect-and-post-select, not
-        # correction): one shared ancilla per simulator -- every patch AND
+        # correction): two shared ancillae per simulator -- every patch AND
         # the boundary crossbar sim alike, "a single ancilla per patch,
         # overall" -- reused across every real (same-simulator) coupling
         # gate that touches it, never allocated per-gate or per-qubit.
         # 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 = []
+        self._detect_ancilla1 = []
+        self._detect_ancilla2 = []
         if self.is_error_detection:
             for i in range(len(sim_counts)):
-                self._detect_ancilla.append(sim_counts[i])
+                self._detect_ancilla1.append(sim_counts[i])
                 sim_counts[i] += 1
+                self._detect_ancilla2.append(sim_counts[i])
+                sim_counts[i] += 1
+
+        # Logical-qubit wrapper around each patch's detection ancilla,
+        # so it's addressable via the ORDINARY cx()/_cpauli() machinery
+        # (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
+        # 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_
+        # 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()/
+        # 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
+        # legitimately need to change any single replica's own value.
+        self._detect_ancilla1_lq = []
+        self._detect_ancilla2_lq = []
+        if self.is_error_detection:
+            for sim_id, phys_idx in enumerate(self._detect_ancilla1):
+                lq_idx = len(self._qubits)
+                self._qubits.append([(sim_id, phys_idx)])
+                self._detect_ancilla1_lq.append(lq_idx)
+            for sim_id, phys_idx in enumerate(self._detect_ancilla2):
+                lq_idx = len(self._qubits)
+                self._qubits.append([(sim_id, phys_idx)])
+                self._detect_ancilla2_lq.append(lq_idx)
+        # Reentrancy guard for the gadget's own nested cx(lq1, anc)
+        # capture calls (see _apply_coupling): those calls go through
+        # the ordinary _cpauli -> _apply_coupling path themselves, which
+        # would otherwise try to wrap ITSELF in another capture,
+        # recursing without end.
+        self._in_gadget_capture = False
 
         if "QRACK_QUNIT_SEPARABILITY_THRESHOLD" in os.environ:
             self._sdrp = min(1, float(os.environ["QRACK_QUNIT_SEPARABILITY_THRESHOLD"]))
@@ -632,51 +671,12 @@ class QrackAceBackend:
             t.adjs()
 
     def _detect_swap(self, sim_id, idx1, idx2):
-        """Same detect-and-post-select gadget as _apply_coupling's real
-        gate branch, generalized to SWAP's own invariant instead of
-        CNOT's. SWAP exchanges two qubits' values, but their XOR
-        (parity) is exactly conserved in the noiseless case:
-        idx1_before ^ idx2_before == idx1_after ^ idx2_after, regardless
-        of either qubit's individual value -- captured the same way,
-        just with two capture-CNOTs (one per qubit) into the shared
-        per-simulator ancilla instead of one.
-        """
-        sim = self.sim[sim_id]
-        if not self.is_error_detection:
-            sim.swap(idx1, idx2)
-            return
-        anc = self._detect_ancilla[sim_id]
-        sim.mcx([idx1], anc)
-        sim.mcx([idx2], anc)
-        sim.swap(idx1, idx2)
-        sim.mcx([idx1], anc)
-        sim.mcx([idx2], anc)
-        sim.force_m(anc, False)
+        self.sim[sim_id].swap(idx1, idx2)
 
     def _anti_shadow_wrap(self, c, t, middle_fn):
-        """Shared gadget for _anti_c{x,y,z}_shadow: all three bracket
-        their genuinely cross-sim shadow call with two _qec_x(c) calls,
-        and nothing else ever touches c in between -- the shadow call
-        underneath only ever reads c via .prob(), never gates it (same
-        property _apply_coupling's real branch relies on for its own
-        control-invariance check). So X;X on c should net to identity,
-        in the noiseless case, regardless of c's current value or basis
-        -- exactly as protectable as the CNOT-sandwich case, just with
-        X instead of CNOT as the bracketing gate.
-        """
-        if not (self.is_error_detection and isinstance(c, tuple)):
-            self._qec_x(c)
-            middle_fn(c, t)
-            self._qec_x(c)
-            return
-        anc = self._detect_ancilla[c[0]]
-        sim = self.sim[c[0]]
-        sim.mcx([c[1]], anc)
         self._qec_x(c)
         middle_fn(c, t)
         self._qec_x(c)
-        sim.mcx([c[1]], anc)
-        sim.force_m(anc, False)
 
     def _anti_cz_shadow(self, c, t):
         self._anti_shadow_wrap(c, t, self._cz_shadow)
@@ -1179,9 +1179,7 @@ class QrackAceBackend:
             self.sim[b[0]].h(b[1])
             return
 
-        self._correct(lq)
         skip = self._invalidate_for_gate(lq)
-
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
@@ -1444,6 +1442,56 @@ class QrackAceBackend:
                                  # bounded window, no reactive invalidation
                                  # needed for these -- see
                                  # _resolve_witnessed_shadow.
+
+        # 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).
+        #
+        # 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 = 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
+            # Control bit-flip
+            self.cx(lq1, anc1)
+            if len(hq1) > 1:
+                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)
+            self._in_gadget_capture = False
+
         for q1 in qb1:
             b1 = hq1[q1]
             gate_fn, shadow_fn = self._get_gate(pauli, anti, b1[0])
@@ -1455,88 +1503,56 @@ class QrackAceBackend:
             for q2 in qb2:
                 b2 = hq2[q2]
                 if b1[0] == b2[0]:
-                    if self.is_error_detection:
-                        # Single-patch, not multi-patch: force_m's
-                        # post-selection isn't local to the one
-                        # simulator it's physically called on -- the
-                        # projection it performs reflects the "lab
-                        # frame" ground truth for whatever it's checking,
-                        # not an independent per-patch fact. Since every
-                        # replica of a boundary qubit is meant to
-                        # represent the SAME logical value, checking that
-                        # invariant via any one patch that has a real
-                        # gate touching it already captures the full
-                        # syndrome -- separately re-checking lq1's other
-                        # replicas in their own patches doesn't add new
-                        # independent information, it just adds their
-                        # own extra gate exposure for no additional
-                        # benefit. So: XOR b1's value into ITS OWN
-                        # patch's ancilla immediately before the gate,
-                        # XOR it in again immediately after, force_m that
-                        # one ancilla -- b1 only, not every replica of
-                        # lq1.
-                        #
-                        # Also worth being explicit about: what this
-                        # catches is NOT the same thing as the `noise=`
-                        # parameter's injected depolarizing/Pauli channel.
-                        # It's this architecture's own INTRINSIC error --
-                        # the approximation inherent in the elided
-                        # shadow-coupling / replica-consistency scheme,
-                        # present even at noise=0. Testing this gadget
-                        # against `noise=p` instead measures something
-                        # different (and actively penalizes it, since the
-                        # sandwiching CNOTs are then subject to that same
-                        # injected noise too) -- see conversation record.
-                        #
-                        # Scope: still only the mcx/mcy/mcz path
-                        # (_cpauli / _apply_coupling); swap/iswap/etc.
-                        # get their own dedicated gadget (_detect_swap),
-                        # and the anti-controlled shadow variants get
-                        # theirs (_anti_shadow_wrap) -- see those.
-                        #
-                        # CZ specifically also checks b2, not just b1:
-                        # unlike CX/CY, where the target's Z-population
-                        # legitimately, intentionally changes (that IS
-                        # the entangling operation -- not an error), CZ
-                        # is diagonal in the computational basis and
-                        # NEVER changes either qubit's Z-population, only
-                        # a relative phase. So b2 is an equally valid
-                        # invariance check here, for this gate family
-                        # only. Combined as one XOR parity (b1^b2), same
-                        # pattern as the SWAP gadget: catches either
-                        # participant's first-order (O(p)) disturbance,
-                        # only misses the second-order (O(p^2)) case
-                        # where both are disturbed simultaneously in a
-                        # way that cancels in the combined parity.
-                        # (Considered and rejected checking b1 in BOTH
-                        # Z and X bases instead, to catch phase-type
-                        # errors on the control too -- doesn't work: CX/CY
-                        # genuinely, intentionally entangle control with
-                        # target, which legitimately degrades the
-                        # control's own X/Y-basis coherence as correct
-                        # gate behavior, not error. A detector for that
-                        # would flag every successful entangling gate and
-                        # destroy the entanglement the gate was supposed
-                        # to create.)
-                        check_b2_too = pauli == Pauli.PauliZ
-                        anc = self._detect_ancilla[b1[0]]
-                        sim = self.sim[b1[0]]
-                        sim.mcx([b1[1]], anc)
-                        if check_b2_too:
-                            sim.mcx([b2[1]], anc)
-                        gate_fn([b1[1]], b2[1])
-                        sim.mcx([b1[1]], anc)
-                        if check_b2_too:
-                            sim.mcx([b2[1]], anc)
-                        sim.force_m(anc, False)
-                    else:
-                        gate_fn([b1[1]], b2[1])
+                    gate_fn([b1[1]], b2[1])
                 elif lq1_lr or (b1[1] == b2[1]) or ((len(qb1) == 2) and (b1[1] == (b2[1] & 1))):
                     shadow_fn(b1, b2)
                     shadow_targets.append(b2)
                     if witness is not None and witness != b2:
                         witnessed_targets.append((b2, witness))
 
+        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.
+            anc_sim, anc_idx = self._qubits[anc1][0]
+            p = self.sim[anc_sim].prob(anc_idx)
+            if p > 0.5:
+                self.force_m(anc1, True)
+                self.x(anc1)
+                self.x(lq1)
+            else:
+                self.force_m(anc1, False)
+            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)
+            if p > 0.5:
+                self.force_m(anc2, True)
+                self.x(anc2)
+                self.x(lq2)
+            else:
+                self.force_m(anc2, False)
+            self._in_gadget_capture = False
+
         if lq2 is not None and witnessed_targets and self._witness_map is not None:
             wmap = self._witness_map.setdefault(lq2, {})
             for target_replica, witness_replica in witnessed_targets:
@@ -1621,61 +1637,81 @@ class QrackAceBackend:
         self._cpauli(lq1, lq2, False, Pauli.PauliX)
 
     def cy(self, lq1, lq2):
-        self._cpauli(lq1, lq2, False, Pauli.PauliY)
+        if self.is_error_detection and ((len(self._unpack(lq1)) > 1) or (len(self._unpack(lq2)) > 1)):
+            self.adjs(lq2)
+            self.cx(lq1, lq2)
+            self.s(lq2)
+        else:
+            self._cpauli(lq1, lq2, False, Pauli.PauliY)
 
     def cz(self, lq1, lq2):
-        self._cpauli(lq1, lq2, False, Pauli.PauliZ)
+        if self.is_error_detection and ((len(self._unpack(lq1)) > 1) or (len(self._unpack(lq2)) > 1)):
+            self.h(lq2)
+            self.cx(lq1, lq2)
+            self.h(lq2)
+        else:
+            self._cpauli(lq1, lq2, False, Pauli.PauliZ)
 
     def acx(self, lq1, lq2):
         self._cpauli(lq1, lq2, True, Pauli.PauliX)
 
     def acy(self, lq1, lq2):
-        self._cpauli(lq1, lq2, True, Pauli.PauliY)
+        if self.is_error_detection and ((len(self._unpack(lq1)) > 1) or (len(self._unpack(lq2)) > 1)):
+            self.adjs(lq2)
+            self.acx(lq1, lq2)
+            self.s(lq2)
+        else:
+            self._cpauli(lq1, lq2, True, Pauli.PauliY)
 
     def acz(self, lq1, lq2):
-        self._cpauli(lq1, lq2, True, Pauli.PauliZ)
+        if self.is_error_detection and ((len(self._unpack(lq1)) > 1) or (len(self._unpack(lq2)) > 1)):
+            self.h(lq2)
+            self.acx(lq1, lq2)
+            self.h(lq2)
+        else:
+            self._cpauli(lq1, lq2, True, Pauli.PauliZ)
 
     def mcx(self, lq1, lq2):
         if len(lq1) > 1:
             raise RuntimeError(
                 "QrackAceBackend.mcx() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self._cpauli(lq1[0], lq2, False, Pauli.PauliX)
+        self.cx(lq1[0], lq2)
 
     def mcy(self, lq1, lq2):
         if len(lq1) > 1:
             raise RuntimeError(
                 "QrackAceBackend.mcy() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self._cpauli(lq1[0], lq2, False, Pauli.PauliY)
+        self.cy(lq1[0], lq2)
 
     def mcz(self, lq1, lq2):
         if len(lq1) > 1:
             raise RuntimeError(
                 "QrackAceBackend.mcz() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self._cpauli(lq1[0], lq2, False, Pauli.PauliZ)
+        self.cz(lq1[0], lq2)
 
     def macx(self, lq1, lq2):
         if len(lq1) > 1:
             raise RuntimeError(
                 "QrackAceBackend.macx() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self._cpauli(lq1[0], lq2, True, Pauli.PauliX)
+        self.acx(lq1[0], lq2)
 
     def macy(self, lq1, lq2):
         if len(lq1) > 1:
             raise RuntimeError(
                 "QrackAceBackend.macy() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self._cpauli(lq1[0], lq2, True, Pauli.PauliY)
+        self.acy(lq1[0], lq2)
 
     def macz(self, lq1, lq2):
         if len(lq1) > 1:
             raise RuntimeError(
                 "QrackAceBackend.macz() is provided for syntax convenience and only supports 1 control qubit!"
             )
-        self._cpauli(lq1[0], lq2, True, Pauli.PauliZ)
+        self.acz(lq1[0], lq2)
 
     def swap(self, lq1, lq2):
         hq1 = self._unpack(lq1)
@@ -1745,6 +1781,18 @@ class QrackAceBackend:
         # 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.
+        #
+        # Deliberately NOT wrapped with the same logical-level gadget
+        # _cpauli uses below this branch: unlike a controlled-Pauli gate,
+        # where the control is structurally invariant, SWAP genuinely,
+        # intentionally exchanges both sides' values -- an independent
+        # "did home1/home2 change" check would incorrectly flag a
+        # legitimate swap as an error and try to veto it. The correct
+        # invariant here is the COMBINED parity (home1 XOR home2), not
+        # independent per-side checks, and getting that right when the
+        # two sides can land on different simulators (the partial-match
+        # branches below) needs separate, careful treatment -- not
+        # reused as-is from _cpauli's helper.
         self._correct(lq1)
         self._correct(lq2)
 
@@ -1760,6 +1808,19 @@ class QrackAceBackend:
             # with or without this call).
             return
 
+        anc1, anc2 = None, None
+        if self.is_error_detection and not self._in_gadget_capture and ((len(hq1) > 1) or (len(hq2) > 1)):
+            if len(hq2) == 1:
+                anc1 = self._detect_ancilla1_lq[hq1[0][0]]
+                anc2 = self._detect_ancilla2_lq[hq1[0][0]]
+            else:
+                anc1 = self._detect_ancilla1_lq[hq2[0][0]]
+                anc2 = self._detect_ancilla2_lq[hq2[0][0]]
+            self._in_gadget_capture = True
+            self.cx(lq1, anc1)
+            self.cx(lq2, anc2)
+            self._in_gadget_capture = False
+
         # Partial-match cases: one side is a simple (single-replica) qubit,
         # the other has multiple replicas. For the multi-replica side's
         # non-matching replicas, the correct decomposition (verified
@@ -1791,9 +1852,7 @@ class QrackAceBackend:
             # error is already Z-basis-population-visible and doesn't need
             # an H-rotation first to become detectable.
             self._correct(lq2)
-            return
-
-        if len(hq2) == 1 and any(h[0] == hq2[0][0] for h in hq1):
+        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]]
             matching = [h for h in hq1 if h[0] == _hq2[0]]
@@ -1804,18 +1863,39 @@ class QrackAceBackend:
             for _hq1 in non_matching:
                 self._cx_shadow(_hq2, _hq1)
             self._correct(lq1)
-            return
-
-        # 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
-        # extra wrapping needed here.
-        self.cx(lq1, lq2)
-        self.cx(lq2, lq1)
-        self.cx(lq1, lq2)
+        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
+            # extra wrapping needed here.
+            self.cx(lq1, lq2)
+            self.cx(lq2, lq1)
+            self.cx(lq1, lq2)
+
+        if anc1 is not None:
+            self._in_gadget_capture = True
+            self.cx(lq1, anc2)
+            self.cx(lq2, anc1)
+            anc_sim, anc_idx = self._qubits[anc1][0]
+            p = self.sim[anc_sim].prob(anc_idx)
+            if p > 0.5:
+                self.force_m(anc1, True)
+                self.x(anc1)
+                self.x(lq1)
+            else:
+                self.force_m(anc1, False)
+            anc_sim, anc_idx = self._qubits[anc2][0]
+            p = self.sim[anc_sim].prob(anc_idx)
+            if p > 0.5:
+                self.force_m(anc2, True)
+                self.x(anc2)
+                self.x(lq2)
+            else:
+                self.force_m(anc2, False)
+            self._in_gadget_capture = False
 
     def iswap(self, lq1, lq2):
         self.swap(lq1, lq2)
@@ -2431,35 +2511,32 @@ class QrackAceBackend:
 
         coupling_map = self.get_logical_coupling_map()
 
-        # Error-detection damping (cx/cy/cz only -- see below for why not
-        # swap/iswap): a qubit only ever gets the gadget's benefit when it
-        # actually plays CONTROL in some real (u=0) gate somewhere in the
-        # coupling map -- that's what gives its replica a chance to be
-        # swept clean via _apply_coupling's capture-sandwich-force_m
-        # before any shadow decision reads its .prob(). This is a
-        # structural fact about each qubit individually, computed once
-        # here, not a property of the circuit or a global constant --
-        # which is exactly why this can't be reproduced by a user just
-        # passing a smaller x: x scales every pair uniformly, and this
-        # doesn't apply uniformly, either across qubits (only ones with a
-        # real-gate opportunity qualify) or across gate types (see below).
-        #
-        # Both sides of a real (u=0) pair get added, not just the control:
-        # CZ's own gadget check now covers its target too (CZ is diagonal
-        # -- unlike CX/CY, it never changes either qubit's Z-population,
-        # so the target is an equally valid invariance check there, see
-        # _apply_coupling). The coupling map doesn't distinguish which
-        # gate type a future circuit will actually use for a given pair,
-        # so this necessarily overstates the CX/CY case slightly (where
-        # only the control gets swept) -- an approximation on top of an
-        # already-approximate placeholder, not a new source of precision
-        # lost.
-        has_real_partner = set()
-        if self.is_error_detection:
-            for lq1, lq2 in coupling_map:
-                if _uncommon_sim_fraction(lq1, lq2) == 0:
-                    has_real_partner.add(lq1)
-                    has_real_partner.add(lq2)
+        # Error-detection damping (cx/cy/cz; swap/iswap handled
+        # separately below): the current gadget structurally requires
+        # lq1 (== "a" for a given coupling_map entry, since a always
+        # plays the control's role for that entry -- confirmed against
+        # _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
+        # 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
+        # same, simple way: whether a itself is boundary. This replaces
+        # an older version keyed on _uncommon_sim_fraction(lq1,lq2)==0
+        # ("does this pair share a simulator"), which matched an EARLIER
+        # gadget that wrapped gate_fn alone and only ever ran on the
+        # real (same-sim) branch -- that gadget was subsequently proven
+        # a mathematically guaranteed no-op (gate_fn structurally never
+        # touches its control's Z-value regardless of the control's
+        # incoming state, verified directly to floating-point
+        # precision) and replaced with the current mechanism, which
+        # doesn't care whether a and b share a simulator at all: the
+        # 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
+        # needed.
 
         # This factor is a theory-derived placeholder, not an empirical
         # fit -- deliberately, per instruction not to chase a regression
@@ -2503,13 +2580,13 @@ 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 a in has_real_partner:
+            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),
-                # and a has at least one real-gate opportunity elsewhere
-                # in the map -- so its .prob() reading, which THIS
-                # shadow decision partly depends on, has a structural
-                # chance of having been kept clean. Damp accordingly.
+                # ...) is always called with a as the coupling source).
+                # Both gadget halves that protect this pair (anc1 on a,
+                # anc2 verifying b) are structurally live exactly when a
+                # itself is boundary -- see the comment above this loop.
+                # Damp accordingly.
                 p_shadow_ccz *= y
             noise_model.add_quantum_error(
                 pauli_error([("ZI", p_shadow_ccz), ("II", 1 - p_shadow_ccz)]), "cz", [a, b]
@@ -2563,21 +2640,22 @@ class QrackAceBackend:
             # same condition to stay consistent with what the gate does.
             if (is_a_simple != is_b_simple) and has_match:
                 p_net_swap = 2 * p * (1 - p)
-                # swap() now routes its own matching-replica gate through
-                # _detect_swap (a genuine same-simulator, parity-invariant
-                # gadget: idx1^idx2 is exactly conserved across a SWAP,
-                # the same way a CNOT's control is conserved -- see
-                # _detect_swap), so this IS damped now, unlike the stale
-                # "swap/iswap deliberately not damped" note this replaced.
-                # Gate on whichever side bears the error (the boundary
-                # qubit), using the same has_real_partner structural
-                # proxy as the cx/cy/cz case above -- the matching-replica
-                # branch needs the same "shares a simulator with
-                # something else" precondition _uncommon_sim_fraction==0
-                # already captures, so reusing that set here keeps this
-                # consistent rather than re-deriving a parallel condition.
-                boundary_qubit = b if is_a_simple else a
-                if boundary_qubit in has_real_partner:
+                # swap()'s own anc1/anc2 cross-check (verifying lq1's new
+                # value against lq2's old, and vice versa -- see swap())
+                # wraps the ENTIRE call, every branch, not specifically
+                # this matching-replica step -- _detect_swap itself is
+                # just a plain swap(), carrying no gadget of its own
+                # (an earlier per-replica parity gadget living there was
+                # proven a mathematically guaranteed no-op, the same way
+                # the old cx/cy/cz gadget was, and was simplified away).
+                # So this IS damped, unlike the stale "swap/iswap
+                # deliberately not damped" note this replaced -- but
+                # unconditionally so, not gated on any structural
+                # per-qubit condition: swap()'s gadget captures both
+                # sides whenever is_error_detection is on, full stop, no
+                # len(hq)>1-style precondition the way _cpauli's anc2
+                # has.
+                if self.is_error_detection:
                     p_net_swap *= y
                 if is_a_simple:
                     # a is bulk, b is boundary -> error lands on b
@@ -2610,12 +2688,15 @@ class QrackAceBackend:
             # previous formula.
             if (is_a_simple != is_b_simple) and has_match:
                 p_cz = 1 - sp * p  # same per-call formula as standalone cz
-                if boundary_qubit in has_real_partner:
-                    # this cz component is the SAME kind of shadow-driven
-                    # term as the main cx/cy/cz loop above (see that
-                    # comment for the mechanism); p_net_swap was already
-                    # damped above, independently, since it comes from a
-                    # different gate (the now-protected native swap, not
+                if self.is_error_detection and len(self._qubits[a]) > 1:
+                    # this cz component is routed through cx() when
+                    # is_error_detection is on (see cz()'s own wrapper),
+                    # so it's the SAME kind of shadow-driven term, gated
+                    # the SAME way, as the main cx/cy/cz loop above (see
+                    # that comment for the mechanism); p_net_swap was
+                    # already damped above, independently, since it comes
+                    # from a different gate (the now-protected native
+                    # swap, not
                     # this cz component).
                     p_cz *= y
                 p_i = (1 - p_net_swap) * (1 - p_cz)

{pyqrack_complex128-2.18.2 → pyqrack_complex128-2.18.4/pyqrack_complex128.egg-info}/PKG-INFO

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

{pyqrack_complex128-2.18.2 → pyqrack_complex128-2.18.4}/setup.py

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