pyqrack-cpu 2.18.0__tar.gz → 2.18.2__tar.gz

{pyqrack_cpu-2.18.0/pyqrack_cpu.egg-info → pyqrack_cpu-2.18.2}/PKG-INFO

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

{pyqrack_cpu-2.18.0 → pyqrack_cpu-2.18.2}/pyqrack/qrack_ace_backend.py

@@ -631,10 +631,55 @@ class QrackAceBackend:
         else:
             t.adjs()
 
-    def _anti_cz_shadow(self, c, t):
+    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)
+
+    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)
-        self._cz_shadow(c, t)
+        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)
 
     def _cx_shadow(self, c, t):
         self._qec_h(t)
@@ -642,9 +687,7 @@ class QrackAceBackend:
         self._qec_h(t)
 
     def _anti_cx_shadow(self, c, t):
-        self._qec_x(c)
-        self._cx_shadow(c, t)
-        self._qec_x(c)
+        self._anti_shadow_wrap(c, t, self._cx_shadow)
 
     def _cy_shadow(self, c, t):
         self._qec_adjs(t)
@@ -652,9 +695,7 @@ class QrackAceBackend:
         self._qec_s(t)
 
     def _anti_cy_shadow(self, c, t):
-        self._qec_x(c)
-        self._cy_shadow(c, t)
-        self._qec_x(c)
+        self._anti_shadow_wrap(c, t, self._cy_shadow)
 
     def _unpack(self, lq):
         return self._qubits[lq]
@@ -1415,44 +1456,78 @@ class QrackAceBackend:
                 b2 = hq2[q2]
                 if b1[0] == b2[0]:
                     if self.is_error_detection:
-                        # Error-DETECTION gadget (not correction), directly
-                        # post-selected via force_m rather than requiring
-                        # real repeated shots: b1 is always the CONTROL of
-                        # this gate (by construction -- gate_fn is always
-                        # called as gate_fn([b1[1]], b2[1])), and a
-                        # control's Z value is exactly invariant under a
-                        # controlled-Pauli gate in the noiseless case,
-                        # regardless of anti/regular control convention or
-                        # which Pauli. So: XOR b1's value into the patch's
-                        # shared ancilla immediately before the gate, XOR
-                        # it in again immediately after -- if nothing
-                        # disturbed b1 (no injected noise on the gate
-                        # itself or on either sandwiching CNOT), those two
-                        # XORs exactly cancel and the ancilla is back to
-                        # |0>. force_m(ancilla, False) then directly
-                        # projects the whole simulated state onto that
-                        # "no disturbance detected" branch and renormalizes
-                        # -- this is the exact numerical equivalent of what
-                        # a real experiment gets from measure + discard +
-                        # repeat, done in one step because the simulator
-                        # has the full state to project, not just samples
-                        # from it. The same ancilla is reused for every
-                        # gate touching this simulator: each round-trip is
-                        # self-contained and leaves the ancilla at |0>
-                        # again whenever nothing was detected, so there's
-                        # no cross-gate bookkeeping needed.
+                        # 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.
                         #
-                        # Scope: this only covers the mcx/mcy/mcz path
-                        # (_cpauli / _apply_coupling). swap/iswap/pswap/etc.
-                        # exchange both qubits' values rather than leaving
-                        # either invariant, so this specific gadget doesn't
-                        # apply to them directly -- left as a documented
-                        # gap for a later pass, not silently unhandled.
+                        # 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])
@@ -1677,7 +1752,7 @@ class QrackAceBackend:
             for i in range(len(hq1)):
                 sim_id, idx1 = hq1[i]
                 _, idx2 = hq2[i]
-                self.sim[sim_id].swap(idx1, idx2)
+                self._detect_swap(sim_id, idx1, idx2)
             # No post-swap correction: this branch is a native index
             # relabeling applied identically to every matching replica
             # pair, with zero Schmidt-truncation opportunity -- verified
@@ -1706,7 +1781,7 @@ class QrackAceBackend:
             for _hq2 in non_matching:
                 self._cx_shadow(_hq1, _hq2)
             for _hq2 in matching:
-                self.sim[_hq1[0]].swap(_hq1[1], _hq2[1])
+                self._detect_swap(_hq1[0], _hq1[1], _hq2[1])
             for _hq2 in non_matching:
                 self._cx_shadow(_hq1, _hq2)
             # No correction on lq1 (bulk, single-replica): already a
@@ -1725,7 +1800,7 @@ class QrackAceBackend:
             for _hq1 in non_matching:
                 self._cx_shadow(_hq2, _hq1)
             for _hq1 in matching:
-                self.sim[_hq2[0]].swap(_hq2[1], _hq1[1])
+                self._detect_swap(_hq2[0], _hq2[1], _hq1[1])
             for _hq1 in non_matching:
                 self._cx_shadow(_hq2, _hq1)
             self._correct(lq1)
@@ -2334,7 +2409,7 @@ class QrackAceBackend:
         return self._coupling_map
 
     # Designed by Dan, Elara (ChatGPT), and (Anthropic) Claude:
-    def create_noise_model(self, x=0.5):
+    def create_noise_model(self, x=0.5, y=0.5):
         if not _IS_QISKIT_AER_AVAILABLE:
             raise RuntimeError(
                 "Before trying to run_qiskit_circuit() with QrackAceBackend, you must install Qiskit Aer!"
@@ -2354,7 +2429,58 @@ class QrackAceBackend:
 
             return n / (len(sims1) + len(sims2))
 
-        for a, b in self.get_logical_coupling_map():
+        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)
+
+        # This factor is a theory-derived placeholder, not an empirical
+        # fit -- deliberately, per instruction not to chase a regression
+        # right now. It reflects that the gadget's control-invariance
+        # check is a Z-basis check: it exactly catches the X/Y-type
+        # disturbances that would degrade a Z-basis .prob() reading (the
+        # only thing _cz_shadow's decision actually depends on), while a
+        # Z-type disturbance on the control doesn't degrade that reading
+        # in the first place and so was never a threat to the shadow
+        # decision to begin with. That argument alone would suggest
+        # damping close to the full X/Y-type share of the channel -- but
+        # this is a STRUCTURAL possibility (the control CAN be swept
+        # clean somewhere in the map), not a per-execution guarantee that
+        # it WAS, before any specific shadow read in a specific circuit.
+        # 0.5 is a deliberately conservative middle estimate given that
+        # gap, not a derived bound; replace with a fitted value once (or
+        # if) empirical calibration against real XEB data happens.
+        # _ERROR_DETECTION_DAMPING = 0.5
+        # (Use "y" instead.)
+
+        for a, b in coupling_map:
             u = _uncommon_sim_fraction(a, b)
             c = 1 - u
 
@@ -2377,6 +2503,14 @@ 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:
+                # 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.
+                p_shadow_ccz *= y
             noise_model.add_quantum_error(
                 pauli_error([("ZI", p_shadow_ccz), ("II", 1 - p_shadow_ccz)]), "cz", [a, b]
             )
@@ -2429,6 +2563,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:
+                    p_net_swap *= y
                 if is_a_simple:
                     # a is bulk, b is boundary -> error lands on b
                     noise_model.add_quantum_error(
@@ -2460,6 +2610,14 @@ 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
+                    # this cz component).
+                    p_cz *= y
                 p_i = (1 - p_net_swap) * (1 - p_cz)
                 p_x = p_net_swap * (1 - p_cz)
                 p_z = (1 - p_net_swap) * p_cz

{pyqrack_cpu-2.18.0 → pyqrack_cpu-2.18.2/pyqrack_cpu.egg-info}/PKG-INFO

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

{pyqrack_cpu-2.18.0 → pyqrack_cpu-2.18.2}/setup.py

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