pyqrack-cpu-complex128 2.21.2__tar.gz → 2.22.0__tar.gz

{pyqrack_cpu_complex128-2.21.2/pyqrack_cpu_complex128.egg-info → pyqrack_cpu_complex128-2.22.0}/PKG-INFO

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

{pyqrack_cpu_complex128-2.21.2 → pyqrack_cpu_complex128-2.22.0}/pyqrack/qrack_ace_backend.py

@@ -7,7 +7,6 @@
 import math
 import os
 import random
-from collections import deque
 
 from .qrack_system import Qrack
 from .qrack_simulator import QrackSimulator
@@ -238,7 +237,6 @@ class QrackAceBackend:
         is_host_pointer=(True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False),
         is_near_clifford_tableau_writer=False,
         noise=0,
-        history_window=0,
         is_torus=True,
         is_1d_chain=False,
         is_error_detection=True,
@@ -250,7 +248,6 @@ class QrackAceBackend:
             long_range_columns = to_clone.long_range_columns
             long_range_rows = to_clone.long_range_rows
             is_transpose = to_clone.is_transpose
-            history_window = to_clone.history_window
             is_torus = to_clone.is_torus
             is_1d_chain = to_clone.is_1d_chain
             is_error_detection = to_clone.is_error_detection
@@ -259,15 +256,12 @@ class QrackAceBackend:
             qubit_count = 0
         if long_range_columns < 0:
             long_range_columns = 0
-        if history_window < 0:
-            history_window = 0
 
         self.is_1d_chain = is_1d_chain
         self._factor_width(qubit_count, is_transpose)
         self.long_range_columns = long_range_columns
         self.long_range_rows = long_range_rows
         self.is_transpose = is_transpose
-        self.history_window = history_window
         self.is_torus = is_torus
         self.is_error_detection = is_error_detection
         self.is_boundary_repetition_code = is_boundary_repetition_code
@@ -343,28 +337,6 @@ class QrackAceBackend:
 
         self._qubits = []
         self._lhv = {}
-        if self.history_window > 0:
-            if to_clone and to_clone._coupling_history is not None:
-                self._coupling_history = {
-                    k: deque(v, maxlen=self.history_window)
-                    for k, v in to_clone._coupling_history.items()
-                }
-                self._coupling_history_rev = dict(to_clone._coupling_history_rev)
-                self._pending_skip = {k: set(v) for k, v in to_clone._pending_skip.items()}
-                self._stale_replicas = {k: set(v) for k, v in to_clone._stale_replicas.items()}
-                self._witness_map = {k: dict(v) for k, v in to_clone._witness_map.items()}
-            else:
-                self._coupling_history = {}
-                self._coupling_history_rev = {}
-                self._pending_skip = {}
-                self._stale_replicas = {}
-                self._witness_map = {}
-        else:
-            self._coupling_history = None
-            self._coupling_history_rev = None
-            self._pending_skip = None
-            self._stale_replicas = None
-            self._witness_map = None
         sim_counts = [0] * sim_count
         sim_id = 0
         tot_qubits = 0
@@ -891,10 +863,8 @@ class QrackAceBackend:
             end_caps = [p0, p1, p3, p4]
             # Classify each end-cap as decisively high / decisively low /
             # undecided (within epsilon of 0.5), rather than a bare >=0.5
-            # check -- a replica reading EXACTLY 0.5 (e.g. one just
-            # H-reverted by _revert_shadow_commitment, genuinely carrying
-            # zero information) was previously always counted as "high"
-            # via this boundary convention alone.
+            # check -- a replica reading EXACTLY 0.5  was previously always
+            # counted as "high" via this boundary convention alone.
             high_count = sum(1 for x in end_caps if x > (0.5 + self._epsilon))
             low_count = sum(1 for x in end_caps if x < (0.5 - self._epsilon))
             undecided_count = len(end_caps) - high_count - low_count
@@ -1154,17 +1124,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].u(b[1], th, ph, lm)
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].u(b[1], th, ph, lm)
+            self.sim[b[0]].u(b[1], th, ph, lm)
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1172,87 +1139,18 @@ class QrackAceBackend:
 
         # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
-    def _revert_shadow_commitment(self, lq1):
-        """Revert shadow-committed replicas recorded under lq1. H-reverts
-        each committed shadow replica (undoing the stale Z-basis commitment),
-        stores the reverted tuples in _pending_skip[lq2] so the NEXT gate on
-        that boundary qubit skips those replicas entirely (rotating an H-reverted
-        shadow replica from the wrong starting state gives a wrong result; the
-        right behavior is to skip it and let the next coupling gate re-derive
-        from scratch), and returns the reverted set for the immediate caller to
-        skip as well (for case A, where the control's own rotation should also
-        skip its own shadow replicas that were just un-committed)."""
-        if self._coupling_history is None:
-            return set()
-        hist = self._coupling_history.pop(lq1, None)
-        if hist is None:
-            return set()
-        reverted_all = set()
-        for lq2, targets in hist:
-            reverted = set()
-            for t_sim, t_idx in targets:
-                self.sim[t_sim].h(t_idx)
-                reverted.add((t_sim, t_idx))
-            # Store as pending skip for the NEXT gate on lq2 (case B):
-            # when the boundary qubit's own gate runs, it should skip
-            # these replicas rather than applying its gate to the freshly-
-            # H-reverted, uncommitted state.
-            if reverted:
-                existing = self._pending_skip.get(lq2, set())
-                self._pending_skip[lq2] = existing | reverted
-                existing_stale = self._stale_replicas.get(lq2, set())
-                self._stale_replicas[lq2] = existing_stale | reverted
-            self._coupling_history_rev.pop(lq2, None)
-            reverted_all |= reverted
-        return reverted_all
-
-    def _invalidate_for_gate(self, lq):
-        """Called by every single-qubit gate dispatcher. Returns the set of
-        (sim_id, idx) shadow replicas that should be SKIPPED in the calling
-        gate's own application loop.
-        - Case A: lq is the coherent-partner (lq1) in a live history entry.
-          A gate on the control side invalidates the shadow commitment: reverts
-          the shadow targets via H (returning them to uncommitted 0.5), stores
-          them in pending_skip[lq2] for the NEXT gate on the boundary qubit,
-          and returns them for the immediate caller to skip as well (since the
-          control's own replica at slot0 may also be in the reverted set).
-        - Case B: lq is the boundary recipient (lq2) of a commitment that a
-          prior case-A revert already H-reverted. Consumes the pending_skip
-          set so the boundary gate doesn't apply itself to the freshly-
-          uncommitted replicas (which would give the wrong result from the
-          wrong starting state). Case B NEVER triggers a fresh revert --
-          only case A does, because only a gate on the control side actually
-          invalidates the commitment; a gate on the boundary side just needs
-          to avoid corrupting the already-reverted starting state."""
-        if self._coupling_history is None:
-            return set()
-        skip = set()
-        # Case A: lq is the coherent control side -- fire the revert.
-        if lq in self._coupling_history:
-            skip |= self._revert_shadow_commitment(lq)
-        # Case B: lq is the boundary side -- ONLY consume pending_skip,
-        # never trigger a fresh revert (that would incorrectly revert
-        # a still-valid commitment that no control-side gate has touched).
-        pending = self._pending_skip.pop(lq, None)
-        if pending:
-            skip |= pending
-        return skip
-
     def r(self, p, th, lq):
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].r(p, th, b[1])
             return
 
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
-        skip = self._invalidate_for_gate(lq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].r(p, th, b[1])
+            self.sim[b[0]].r(p, th, b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1269,17 +1167,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].h(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].h(b[1])
+            self.sim[b[0]].h(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1291,17 +1186,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].s(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].s(b[1])
+            self.sim[b[0]].s(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1311,17 +1203,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].adjs(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].adjs(b[1])
+            self.sim[b[0]].adjs(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1331,17 +1220,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].sx(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].sx(b[1])
+            self.sim[b[0]].sx(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1351,17 +1237,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].adjsx(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].adjsx(b[1])
+            self.sim[b[0]].adjsx(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1495,17 +1378,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].x(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].x(b[1])
+            self.sim[b[0]].x(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1515,17 +1395,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].y(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].y(b[1])
+            self.sim[b[0]].y(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1535,17 +1412,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].z(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].z(b[1])
+            self.sim[b[0]].z(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1555,17 +1429,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].t(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].t(b[1])
+            self.sim[b[0]].t(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1575,17 +1446,14 @@ class QrackAceBackend:
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
-            self._invalidate_for_gate(lq)
             self.sim[b[0]].adjt(b[1])
             return
 
-        skip = self._invalidate_for_gate(lq)
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            if (b[0], b[1]) not in skip:
-                self.sim[b[0]].adjt(b[1])
+            self.sim[b[0]].adjt(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1650,16 +1518,6 @@ class QrackAceBackend:
 
     def _apply_coupling(self, pauli, anti, qb1, hq1, qb2, hq2, lq1_lr, lq1=None, lq2=None):
         shadow_targets = []
-        witnessed_targets = []  # (shadow_target, witness_replica) pairs --
-                                 # "easy case": a replica of the SAME target
-                                 # logical qubit lives in the SAME simulator
-                                 # as the control replica used for this
-                                 # shadow pair, and is therefore always
-                                 # exactly correct regardless of how many
-                                 # later gates happen to the control. No
-                                 # 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
@@ -1766,8 +1624,6 @@ class QrackAceBackend:
                 elif (q2 not in real_gated_q2) and (lq1_lr or (b1[1] == b2[1])):
                     shadow_fn(b1, b2)
                     shadow_targets.append(b2)
-                    if witness is not None and witness != b2:
-                        witnessed_targets.append((b2, witness))
 
         is_flipped = False
         if anc1 is not None:
@@ -1853,30 +1709,6 @@ class QrackAceBackend:
                 self.x(lq2)
             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:
-                wmap[target_replica] = witness_replica
-
-        if (
-            self._coupling_history is not None
-            and lq1 is not None
-            and lq2 is not None
-            and shadow_targets
-        ):
-            # Only the NON-witnessed shadow targets need the bounded,
-            # reactive history/invalidation machinery -- witnessed ones are
-            # always resolvable directly and don't need tracking here at all.
-            witnessed_set = {t for t, _ in witnessed_targets}
-            unwitnessed = tuple(t for t in shadow_targets if t not in witnessed_set)
-            if unwitnessed:
-                entry = (lq2, tuple(unwitnessed))
-                hist = self._coupling_history.setdefault(
-                    lq1, deque(maxlen=self.history_window)
-                )
-                hist.append(entry)
-                self._coupling_history_rev[lq2] = lq1
-
     # A "coupled twirling" scheme was tried here -- after every real
     # inter-logical-qubit coupling gate, SWAP which physical qubit is
     # registered as hq[side] with one of its level-0 scratch qubits, to
@@ -2089,35 +1921,6 @@ class QrackAceBackend:
         sims2 = {r[0] for r in hq2}
 
         if sims1.isdisjoint(sims2):
-            # Zero shared physical substrate: a SWAP is, by definition,
-            # just "exchange which logical index refers to which
-            # subsystem" -- for two qubits with no shared simulator or
-            # replica at all, that IS the swap, exactly, with zero gates
-            # and zero error, regardless of what either is entangled
-            # with elsewhere (SWAP is a relabeling of tensor-factor
-            # indices; nothing about that depends on which name we call
-            # either subsystem). This also sidesteps the separate
-            # _apply_coupling local-index-match limitation entirely for
-            # this case, since no shadow coupling is attempted between
-            # these qubits at all.
-            #
-            # Must fully resolve any pending shadow/consensus state tied
-            # to EACH qubit's CURRENT identity before relabeling --
-            # otherwise a cross-reference recorded under the old identity
-            # (e.g. coupling_history[lq1], witness_map[lq2]) would
-            # silently end up describing the wrong physical qubit
-            # afterward. Reuses the same resolution methods prob() and
-            # every single-qubit gate already depend on for correctness,
-            # rather than hand-rolling new bookkeeping that could miss a
-            # cross-reference.
-            self._invalidate_for_gate(lq1)
-            self._invalidate_for_gate(lq2)
-            if len(hq1) >= 2:
-                self._resolve_witnessed_shadow(lq1)
-                self._resolve_pending_skip(lq1)
-            if len(hq2) >= 2:
-                self._resolve_witnessed_shadow(lq2)
-                self._resolve_pending_skip(lq2)
             self._correct(lq1)
             self._correct(lq2)
 
@@ -2164,6 +1967,13 @@ class QrackAceBackend:
             self.cx(lq1, lq2)
             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
@@ -2308,85 +2118,12 @@ class QrackAceBackend:
         self.cz(lq1, lq2)
         self.swap(lq1, lq2)
 
-    def _resolve_pending_skip(self, lq):
-        """If lq has replicas recorded as STALE (H-reverted after an
-        invalidating control-side rotation, then skipped by their own
-        later gate because _invalidate_for_gate's Case B already popped
-        _pending_skip to decide what to skip -- consuming that record
-        before it could ever reach measurement time), force those
-        specific replicas to match hq[0] directly.
-
-        NOTE: this deliberately does NOT read _pending_skip, because
-        _invalidate_for_gate's Case B already pops (consumes) it the
-        moment the boundary qubit's own next gate runs -- by the time
-        prob()/m() is called at actual measurement time, _pending_skip is
-        already empty even though the replicas never got their intended
-        rotation. _stale_replicas is a SEPARATE record, populated
-        alongside _pending_skip in _revert_shadow_commitment, that is
-        NOT touched by Case B's pop -- only by this method, at the point
-        where staleness actually needs to be resolved.
-
-        Forcing to match hq[0] requires no randomness (unlike an earlier
-        force-correlate-with-control attempt) because hq[0] -- the
-        replica sharing a real simulator with the control, via the exact
-        gate_fn path in _apply_coupling -- is never itself added to
-        shadow_targets/_pending_skip/_stale_replicas, and is verified
-        exact following the _ct_pair_prob/_cz_shadow phase-kickback fix."""
-        if self._stale_replicas is None:
-            return
-        stale = self._stale_replicas.pop(lq, None)
-        if not stale:
-            return
-        hq = self._unpack(lq)
-        b0 = hq[0]
-        ground_truth = self.sim[b0[0]].m(b0[1])
-        for (t_sim, t_idx) in stale:
-            self.sim[t_sim].force_m(t_idx, ground_truth)
-
-    def _resolve_witnessed_shadow(self, lq):
-        """The 'easy case' generalization of history_window: if lq has any
-        shadow replicas with a recorded witness (a replica of the SAME
-        logical qubit living in the SAME simulator as the control used for
-        that shadow coupling), force each one to match its witness's
-        CURRENT value now, unconditionally.
-
-        This is deliberately unbounded -- no history_window, no deque, no
-        reactive invalidation on the control's later gates at all. It
-        doesn't need any of that, because the witness is a real quantum
-        register: it automatically, continuously reflects the correct
-        joint state through ANY NUMBER of intervening gates on the
-        control (or on itself), for free, simply by being the same real
-        simulator. No matter how long resolution is deferred -- one gate
-        later or a thousand -- matching the witness at the moment it's
-        actually needed is exactly as correct as matching it immediately
-        would have been. This is why the fix for the 'easy case' doesn't
-        need a window at all, bounded or otherwise: unlike the harder,
-        no-witness case (still handled by the existing bounded
-        _coupling_history / _stale_replicas machinery, left for a
-        belief-propagation-style treatment another day), there's no
-        approximation being deferred here, so there's nothing for a
-        window size to trade off against."""
-        if self._witness_map is None:
-            return
-        wmap = self._witness_map.pop(lq, None)
-        if not wmap:
-            return
-        for (t_sim, t_idx), (w_sim, w_idx) in wmap.items():
-            ground_truth = self.sim[w_sim].m(w_idx)
-            self.sim[t_sim].force_m(t_idx, ground_truth)
-
     def prob(self, lq):
         hq = self._unpack(lq)
         if len(hq) < 2:
             b = hq[0]
             return self.sim[b[0]].prob(b[1])
 
-        if self._witness_map is not None:
-            self._resolve_witnessed_shadow(lq)
-
-        if self._stale_replicas is not None:
-            self._resolve_pending_skip(lq)
-
         self._correct(lq)
         if len(hq) == 5:
             # RMS

{pyqrack_cpu_complex128-2.21.2 → pyqrack_cpu_complex128-2.22.0/pyqrack_cpu_complex128.egg-info}/PKG-INFO

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

{pyqrack_cpu_complex128-2.21.2 → pyqrack_cpu_complex128-2.22.0}/setup.py

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