pyqrack-cpu-complex128 2.26.0__tar.gz → 2.26.6__tar.gz

{pyqrack_cpu_complex128-2.26.0/pyqrack_cpu_complex128.egg-info → pyqrack_cpu_complex128-2.26.6}/PKG-INFO

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

{pyqrack_cpu_complex128-2.26.0 → pyqrack_cpu_complex128-2.26.6}/pyqrack/qrack_ace_backend.py

@@ -385,20 +385,17 @@ class QrackAceBackend:
                 tot_qubits += 1
 
         # Error-detection gadget (IBM-style detect-and-post-select, not
-        # correction): two shared ancillae per simulator -- one per patch,
+        # correction): one shared ancilla per simulator -- one per patch,
         # "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_ancilla1 = []
-        self._detect_ancilla2 = []
+        self._detect_ancilla = []
         if self.is_error_detection:
             for i in range(len(sim_counts)):
-                self._detect_ancilla1.append(sim_counts[i])
-                sim_counts[i] += 1
-                self._detect_ancilla2.append(sim_counts[i])
+                self._detect_ancilla.append(sim_counts[i])
                 sim_counts[i] += 1
 
         # Logical-qubit wrapper around each patch's detection ancilla,
@@ -419,30 +416,25 @@ class QrackAceBackend:
         # 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 = []
+        self._detect_ancilla_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):
+            for sim_id, phys_idx in enumerate(self._detect_ancilla):
                 lq_idx = len(self._qubits)
                 self._qubits.append([(sim_id, phys_idx)])
-                self._detect_ancilla2_lq.append(lq_idx)
+                self._detect_ancilla_lq.append(lq_idx)
         # Boundary repetition code, on-demand design: only the couplers
         # are actually noisy here -- single-qubit gates are already
         # exactly transversal, per-replica, with zero error, so there's
         # no need to maintain a permanently-synced repetition code across
         # them at all. Instead: TWO dedicated, reusable scratch ancillae
-        # per patch (separate from _detect_ancilla1/2 above, to avoid any
+        # per patch (separate from _detect_ancilla above, to avoid any
         # contention between this mechanism and that one within the same
         # coupling event), allocated ONCE, and reused across every
         # boundary qubit that patch ever protects -- not one allocation
         # per boundary qubit the way the earlier, always-on version did.
         # 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.
+        # bookkeeping, in the same style as _detect_ancilla above.
         self._rep_code_ancilla = []
         if self.is_boundary_repetition_code:
             for i in range(len(sim_counts)):
@@ -1384,6 +1376,14 @@ class QrackAceBackend:
     def _apply_coupling(self, pauli, anti, qb1, hq1, qb2, hq2, lq1_lr, lq1=None, lq2=None):
         shadow_targets = []
 
+        if len(hq1) == len(hq2) and all(hq1[i][0] == hq2[i][0] for i in range(len(hq1))):
+            for i in range(len(hq1)):
+                sim_id, idx1 = hq1[i]
+                gate_fn, shadow_fn = self._get_gate(pauli, anti, sim_id)
+                _, idx2 = hq2[i]
+                gate_fn([idx1], idx2)
+            return
+
         # 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
@@ -1409,24 +1409,28 @@ class QrackAceBackend:
         # 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):
+        anc = None
+        if self.is_error_detection and (not self._in_gadget_capture) and (len(hq2) > 1):
             anc_sim = hq1[0][0]
             t_sims = {y[0] for y in hq2 if y[0] >= 0}
             for x in hq1:
                 if x[0] in t_sims:
                     anc_sim = x[0]
                     break
-            anc2 = self._detect_ancilla2_lq[anc_sim]
+            anc = self._detect_ancilla_lq[anc_sim]
             self._in_gadget_capture = True
             # XOR on target
-            self.cx(lq2, anc2)
+            self.cx(lq2, anc)
             if anti:
-                self.acx(lq1, anc2)
+                self.acx(lq1, anc)
             else:
-                self.cx(lq1, anc2)
+                self.cx(lq1, anc)
             self._in_gadget_capture = False
 
+        if not self._in_gadget_capture:
+            self._correct(lq1)
+            self._correct(lq2)
+
         # A target replica (q2) that shares a simulator with ANY control
         # replica in qb1 is going to receive a REAL, exact gate from that
         # control at some point in the loop below (the `b1[0] == b2[0]`
@@ -1479,19 +1483,25 @@ class QrackAceBackend:
                     shadow_fn(b1, b2)
                     shadow_targets.append(b2)
 
-        if anc2 is not None:
+        if not self._in_gadget_capture:
+            if pauli != Pauli.PauliZ:
+                self._correct(lq2, False, pauli != Pauli.PauliX)
+            if pauli != Pauli.PauliX:
+                self._correct(lq2, True)
+
+        if anc is not None:
             self._in_gadget_capture = True
             # XOR check
-            self.cx(lq2, anc2)
-            anc_sim, anc_idx = self._qubits[anc2][0]
+            self.cx(lq2, anc)
+            anc_sim, anc_idx = self._qubits[anc][0]
             p = self.sim[anc_sim].prob(anc_idx)
             p = 1.0 - p
             if self._ps_epsilon >= p:
-                b = self.m(anc2)
+                b = self.m(anc)
             else:
-                b = self.force_m(anc2, False)
+                b = self.force_m(anc, False)
             if b:
-                self.x(anc2)
+                self.x(anc)
                 self.x(lq2)
             self._in_gadget_capture = False
 
@@ -1525,19 +1535,21 @@ class QrackAceBackend:
         lq1_lr = len(hq1) == 1
         lq2_lr = len(hq2) == 1
 
-        if not self._in_gadget_capture:
-            self._correct(lq1)
-            self._correct(lq2)
-
         t2 = [lq2]
-        anc1 = None
+        anc, anc_sim = None, 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]]
+            anc_sim = hq1[0][0]
+            t_sims = {y[0] for y in hq2 if y[0] >= 0}
+            for x in hq1:
+                if x[0] in t_sims:
+                    anc_sim = x[0]
+                    break
+            anc = self._rep_code_ancilla_lq[anc_sim]
             self._in_gadget_capture = True
-            self.cx(lq2, anc1)
+            self.cx(lq2, anc)
             self._in_gadget_capture = False
-            t2.append(anc1)
+            t2.append(anc)
 
         qb1, _ = QrackAceBackend._get_qb_lhv_indices(hq1)
 
@@ -1553,50 +1565,24 @@ class QrackAceBackend:
             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)
-
+        if anc is not None:
             # Decode:
             self._in_gadget_capture = True
-            self.cx(lq2, anc1)
+            self.cx(lq2, anc)
             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]
+            anc_sim, anc_idx = self._qubits[anc][0]
             p = self.sim[anc_sim].prob(anc_idx)
             if self._ps_epsilon >= (1.0 - p):
-                b = self.m(anc1)
+                b = self.m(anc)
             else:
-                b = self.force_m(anc1, False)
+                b = self.force_m(anc, False)
             if b:
-                self.x(anc1)
-
-        if self._in_gadget_capture:
-            return
-
-        if pauli != Pauli.PauliZ:
-            self._correct(lq2, False, pauli != Pauli.PauliX)
-        if pauli != Pauli.PauliX:
-            self._correct(lq2, True)
+                self.x(anc)
+                self.x(lq2)
 
     def cx(self, lq1, lq2):
         self._cpauli(lq1, lq2, False, Pauli.PauliX)
@@ -1810,42 +1796,6 @@ class QrackAceBackend:
         hq1 = self._unpack(lq1)
         hq2 = self._unpack(lq2)
 
-        sims1 = {r[0] for r in hq1}
-        sims2 = {r[0] for r in hq2}
-
-        if sims1.isdisjoint(sims2):
-            self._correct(lq1)
-            self._correct(lq2)
-
-            # Once fully resolved, the swap itself is nothing but a
-            # reference exchange: self._qubits[lq] is a reference to the
-            # replica-list object, so swapping which index points to
-            # which object IS the swap -- no separate content to copy.
-            self._qubits[lq1], self._qubits[lq2] = self._qubits[lq2], self._qubits[lq1]
-
-            lhv1 = self._lhv.pop(lq1, None)
-            lhv2 = self._lhv.pop(lq2, None)
-            if lhv2 is not None:
-                self._lhv[lq1] = lhv2
-            if lhv1 is not None:
-                self._lhv[lq2] = lhv1
-
-            # Boundary repetition code needs no bookkeeping here, unlike
-            # self._qubits/self._lhv just above: it's on-demand now, not
-            # a permanent, per-logical-index dict of pre-allocated
-            # partners -- eligibility is just len(self._qubits[lq]) > 1,
-            # computed fresh on every coupling event, so the reference
-            # swap of self._qubits above already, automatically carries
-            # the right eligibility with it. Nothing else to move.
-            return
-
-        # Boundary-to-boundary handling
-        if (len(hq1) > 1) and (len(hq2) > 1):
-            self.cx(lq1, lq2)
-            self.cx(lq2, lq1)
-            self.cx(lq1, lq2)
-            return
-
         # Fast/exact path: every replica of lq1 lines up, position-for-
         # position, with the corresponding replica of lq2 on the SAME
         # underlying simulator. A native swap() there is pure index
@@ -1872,8 +1822,6 @@ class QrackAceBackend:
         # 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)
 
         if len(hq1) == len(hq2) and all(hq1[i][0] == hq2[i][0] for i in range(len(hq1))):
             for i in range(len(hq1)):
@@ -1887,20 +1835,46 @@ 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)):
-            t_sims = {y[0] for y in hq2 if y[0] >= 0}
-            anc_sim = hq1[0][0]
-            for x in hq1:
-                if x[0] in t_sims:
-                    anc_sim = x[0]
-                    break
-            anc1 = self._detect_ancilla1_lq[anc_sim]
-            anc2 = self._detect_ancilla2_lq[anc_sim]
-            self._in_gadget_capture = True
-            self.cx(lq1, anc1)
-            self.cx(lq2, anc2)
-            self._in_gadget_capture = False
+        sims1 = {r[0] for r in hq1}
+        sims2 = {r[0] for r in hq2}
+
+        if sims1.isdisjoint(sims2):
+            # Once fully resolved, the swap itself is nothing but a
+            # reference exchange: self._qubits[lq] is a reference to the
+            # replica-list object, so swapping which index points to
+            # which object IS the swap -- no separate content to copy.
+            self._qubits[lq1], self._qubits[lq2] = self._qubits[lq2], self._qubits[lq1]
+
+            lhv1 = self._lhv.pop(lq1, None)
+            lhv2 = self._lhv.pop(lq2, None)
+            if lhv2 is not None:
+                self._lhv[lq1] = lhv2
+            if lhv1 is not None:
+                self._lhv[lq2] = lhv1
+
+            # Boundary repetition code needs no bookkeeping here, unlike
+            # self._qubits/self._lhv just above: it's on-demand now, not
+            # a permanent, per-logical-index dict of pre-allocated
+            # partners -- eligibility is just len(self._qubits[lq]) > 1,
+            # computed fresh on every coupling event, so the reference
+            # swap of self._qubits above already, automatically carries
+            # the right eligibility with it. Nothing else to move.
+            return
+
+        # Boundary-to-boundary handling
+        if self.is_error_detection and ((len(hq1) > 1) or (len(hq2) > 1)):
+            if len(hq1) > 1:
+                self.cx(lq1, lq2)
+                self.cx(lq2, lq1)
+                self.cx(lq1, lq2)
+            else:
+                self.cx(lq2, lq1)
+                self.cx(lq1, lq2)
+                self.cx(lq2, lq1)
+            return
+
+        self._correct(lq1)
+        self._correct(lq2)
 
         # Partial-match cases: one side is a simple (single-replica) qubit,
         # the other has multiple replicas. For the multi-replica side's
@@ -1956,30 +1930,6 @@ class QrackAceBackend:
             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[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(lq1)
-            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(lq2)
-            self._in_gadget_capture = False
-
     def iswap(self, lq1, lq2):
         self.swap(lq1, lq2)
         self.cz(lq1, lq2)
@@ -2001,19 +1951,6 @@ class QrackAceBackend:
             self.mcx([c1, c2], t)
             return
 
-        if not self._in_gadget_capture:
-            self._correct(c1)
-            self._correct(c2)
-
-        # 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
@@ -2028,7 +1965,7 @@ class QrackAceBackend:
         # 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) or (len(hqt) > 1)):
+        if self.is_error_detection and not self._in_gadget_capture and (len(hqt) > 1):
             found = False
             anc_sim = hq1[0][0]
             t_sims = {y[0] for y in hqt if y[0] >= 0}
@@ -2045,7 +1982,7 @@ class QrackAceBackend:
                 if found:
                     break
             self._in_gadget_capture = True
-            anc_and = self._detect_ancilla2_lq[anc_sim]
+            anc_and = self._detect_ancilla_lq[anc_sim]
             self.cx(t, anc_and)
             # self.mcx() only supports a single control at the logical
             # level (a syntax-convenience wrapper, confirmed directly --
@@ -2070,6 +2007,9 @@ class QrackAceBackend:
                 self.ccx(c1, c2, anc_and)
             self._in_gadget_capture = False
 
+        self._correct(c1)
+        self._correct(c2)
+
         qb1, _ = QrackAceBackend._get_qb_lhv_indices(hq1)
         qb2, _ = QrackAceBackend._get_qb_lhv_indices(hq2)
         qbt, _ = QrackAceBackend._get_qb_lhv_indices(hqt)
@@ -2136,6 +2076,8 @@ class QrackAceBackend:
             for (b1, b2, bt) in witnesses:
                 self.sim[b1[0]].mcx([b1[1], b2[1]], bt[1])
 
+        self._correct(t)
+
         self._in_gadget_capture = True
 
         if anc_and is not None:
@@ -2153,9 +2095,6 @@ class QrackAceBackend:
 
         self._in_gadget_capture = False
 
-        if not self._in_gadget_capture:
-            self._correct(t)
-
     def ccz(self, c1, c2, t):
         self.h(t)
         self.ccx(c1, c2, t)
@@ -2868,7 +2807,7 @@ class QrackAceBackend:
         return tgt
 
     # Designed by Dan, Elara (ChatGPT), and (Anthropic) Claude:
-    def create_noise_model(self, x=0.5, y=0.5):
+    def create_noise_model(self, x=0.25, y=0.25):
         if not _IS_QISKIT_AER_AVAILABLE:
             raise RuntimeError(
                 "Before trying to run_qiskit_circuit() with QrackAceBackend, you must install Qiskit Aer!"
@@ -2876,17 +2815,10 @@ class QrackAceBackend:
         noise_model = NoiseModel()
 
         def _uncommon_sim_fraction(lq1, lq2):
-            sims1 = [qb[0] for qb in self._qubits[lq1]]
-            sims2 = [qb[0] for qb in self._qubits[lq2]]
-            n = 0
-            for s in sims1:
-                if s not in sims2:
-                    n += 1
-            for s in sims2:
-                if s not in sims1:
-                    n += 1
-
-            return n / (len(sims1) + len(sims2))
+            sims1 = {qb[0] for qb in self._qubits[lq1]}
+            sims2 = {qb[0] for qb in self._qubits[lq2]}
+
+            return len(sims1 ^ sims2) / len(sims1.union(sims2))
 
         coupling_map = self.get_logical_coupling_map()
 
@@ -2942,6 +2874,7 @@ class QrackAceBackend:
 
             sp = (1 - self._sdrp / 2) ** c
             p = (1 - x) ** u
+            d = 1 - ((1 - y) ** u)
 
             # cx/cy/cz: single-qubit, TARGET-only error, with the gate's
             # own generator as the Pauli type -- derived directly from
@@ -2966,7 +2899,7 @@ class QrackAceBackend:
                 # anc2 verifying b) are structurally live exactly when a
                 # itself is boundary -- see the comment above this loop.
                 # Damp accordingly.
-                p_shadow_ccz *= y
+                p_shadow_ccz *= d
             noise_model.add_quantum_error(
                 pauli_error([("ZI", p_shadow_ccz), ("II", 1 - p_shadow_ccz)]), "cz", [a, b]
             )
@@ -3042,17 +2975,11 @@ class QrackAceBackend:
             sims_b = [qb[0] for qb in self._qubits[b]]
             has_match = any(s in sims_b for s in sims_a)
 
-            # Mirrors swap()'s own guard: the sandwich path (and its
-            # Z-type error model) only applies when a matching replica
-            # actually anchors it. A simple/simple pair with no shared
-            # sim routes through the general 3-CNOT fallback in swap()
-            # itself now (verified: the sandwich path gave 100/100 wrong
-            # deterministic results there), so the noise model needs the
-            # 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)
                 if self.is_error_detection:
-                    p_net_swap *= y
+                    p_net_swap *= d
+                p_net_swap *= p_net_swap
                 if is_a_simple:
                     # a is bulk, b is boundary -> error lands on b
                     noise_model.add_quantum_error(
@@ -3094,16 +3021,7 @@ class QrackAceBackend:
             if (is_a_simple != is_b_simple) and has_match:
                 p_cz = 1 - sp * p  # same per-call formula as standalone cz
                 if self.is_error_detection and len(self._qubits[a]) > 1:
-                    # 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_cz *= d
                 p_net_iswap = p_net_swap * (1 - p_cz) + p_cz * (1 - p_net_swap)
                 if is_a_simple:
                     terms = [("II", 1 - p_net_iswap), ("ZI", p_net_iswap)]
@@ -3117,3 +3035,5 @@ class QrackAceBackend:
                 )
 
         return noise_model
+
+        return noise_model

{pyqrack_cpu_complex128-2.26.0 → pyqrack_cpu_complex128-2.26.6/pyqrack_cpu_complex128.egg-info}/PKG-INFO

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

{pyqrack_cpu_complex128-2.26.0 → pyqrack_cpu_complex128-2.26.6}/setup.py

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