pyqrack-cpu 2.5.1__tar.gz → 2.7.0__tar.gz

{pyqrack_cpu-2.5.1 → pyqrack_cpu-2.7.0}/Makefile

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

{pyqrack_cpu-2.5.1/pyqrack_cpu.egg-info → pyqrack_cpu-2.7.0}/PKG-INFO

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

{pyqrack_cpu-2.5.1 → pyqrack_cpu-2.7.0}/pyqrack/qrack_ace_backend.py

@@ -9,6 +9,7 @@ import os
 import random
 import sys
 import time
+from collections import deque
 
 from .qrack_simulator import QrackSimulator
 from .pauli import Pauli
@@ -230,6 +231,7 @@ 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,
         to_clone=None,
     ):
         if to_clone:
@@ -237,15 +239,19 @@ 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
         if qubit_count < 0:
             qubit_count = 0
         if long_range_columns < 0:
             long_range_columns = 0
+        if history_window < 0:
+            history_window = 0
 
         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
 
         fppow = 5
         if "QRACK_FPPOW" in os.environ:
@@ -295,6 +301,22 @@ 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()}
+            else:
+                self._coupling_history = {}
+                self._coupling_history_rev = {}
+                self._pending_skip = {}
+        else:
+            self._coupling_history = None
+            self._coupling_history_rev = None
+            self._pending_skip = None
         sim_counts = [0] * sim_count
         sim_id = 0
         tot_qubits = 0
@@ -864,14 +886,17 @@ 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]
-            self.sim[b[0]].u(b[1], th, ph, lm)
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].u(b[1], th, ph, lm)
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -879,18 +904,85 @@ 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
+            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]
-            self.sim[b[0]].r(p, th, b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].r(p, th, b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -907,16 +999,19 @@ 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
 
         self._correct(lq)
+        skip = self._invalidate_for_gate(lq)
 
         qb, _ = QrackAceBackend._get_qb_lhv_indices(hq)
 
         for q in qb:
             b = hq[q]
-            self.sim[b[0]].h(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].h(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -928,14 +1023,17 @@ 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]
-            self.sim[b[0]].s(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].s(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -945,14 +1043,17 @@ 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]
-            self.sim[b[0]].adjs(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].adjs(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -962,14 +1063,17 @@ 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]
-            self.sim[b[0]].x(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].x(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -979,14 +1083,17 @@ 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]
-            self.sim[b[0]].y(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].y(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -996,14 +1103,17 @@ 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]
-            self.sim[b[0]].z(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].z(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1013,14 +1123,17 @@ 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]
-            self.sim[b[0]].t(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].t(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1030,14 +1143,17 @@ 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]
-            self.sim[b[0]].adjt(b[1])
+            if (b[0], b[1]) not in skip:
+                self.sim[b[0]].adjt(b[1])
 
         lhv = self._lhv.get(lq)
         if lhv is not None:
@@ -1081,7 +1197,8 @@ class QrackAceBackend:
 
         return connected, boundary
 
-    def _apply_coupling(self, pauli, anti, qb1, hq1, qb2, hq2, lq1_lr):
+    def _apply_coupling(self, pauli, anti, qb1, hq1, qb2, hq2, lq1_lr, lq1=None, lq2=None):
+        shadow_targets = []
         for q1 in qb1:
             b1 = hq1[q1]
             gate_fn, shadow_fn = self._get_gate(pauli, anti, b1[0])
@@ -1091,6 +1208,20 @@ class QrackAceBackend:
                     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 (
+            self._coupling_history is not None
+            and lq1 is not None
+            and lq2 is not None
+            and shadow_targets
+        ):
+            entry = (lq2, tuple(shadow_targets))
+            hist = self._coupling_history.setdefault(
+                lq1, deque(maxlen=self.history_window)
+            )
+            hist.append(entry)
+            self._coupling_history_rev[lq2] = lq1
 
     def _cpauli(self, lq1, lq2, anti, pauli):
         lq1_row = lq1 // self._row_length
@@ -1110,7 +1241,7 @@ class QrackAceBackend:
         qb2, _ = QrackAceBackend._get_qb_lhv_indices(hq2)
         # Apply cross coupling on every qubit, including former-LHV boundary
         # qubits, which now live as real qubits in the shared boundary sim.
-        self._apply_coupling(pauli, anti, qb1, hq1, qb2, hq2, lq1_lr)
+        self._apply_coupling(pauli, anti, qb1, hq1, qb2, hq2, lq1_lr, lq1, lq2)
 
         if lq2 in self._lhv:
             ctrl_prob = self.sim[hq1[0][0]].prob(hq1[0][1])
@@ -1642,10 +1773,6 @@ class QrackAceBackend:
         return [
             "id",
             "u",
-            "u1",
-            "u2",
-            "u3",
-            "r",
             "rx",
             "ry",
             "rz",
@@ -1655,9 +1782,6 @@ class QrackAceBackend:
             "z",
             "s",
             "sdg",
-            "sx",
-            "sxdg",
-            "p",
             "t",
             "tdg",
             "cx",

{pyqrack_cpu-2.5.1 → pyqrack_cpu-2.7.0}/pyqrack/qrack_simulator.py

@@ -3202,9 +3202,26 @@ class QrackSimulator:
         Raises:
             Runtimeerror: QrackSimulator raised an exception.
         """
-        result = Qrack.qrack_lib.Separate(self.sid, len(qs), QrackSimulator._ulonglong_byref(qs))
+        Qrack.qrack_lib.Separate(self.sid, len(qs), QrackSimulator._ulonglong_byref(qs))
         self._throw_if_error()
 
+    def are_factorized(self, a, b):
+        """Check whether bits in "a" are factorized from bits in "b"
+
+        After flushing all buffers, check whether "a" set of qubits is factorized separate from "b" set of qubits
+
+        Args:
+            a: first list of qubits
+            b: second list of qubits
+
+        Raises:
+            Runtimeerror: QrackSimulator raised an exception.
+        """
+        result = Qrack.qrack_lib.AreFactorized(self.sid, len(a), QrackSimulator._ulonglong_byref(a), len(b), QrackSimulator._ulonglong_byref(b))
+        self._throw_if_error()
+
+        return result
+
     def get_unitary_fidelity(self):
         """Get fidelity estimate
 
@@ -4499,10 +4516,6 @@ class QrackSimulator:
         return [
             "id",
             "u",
-            "u1",
-            "u2",
-            "u3",
-            "r",
             "rx",
             "ry",
             "rz",
@@ -4512,14 +4525,9 @@ class QrackSimulator:
             "z",
             "s",
             "sdg",
-            "sx",
-            "sxdg",
-            "p",
             "t",
             "tdg",
             "cu",
-            "cu1",
-            "cu3",
             "cx",
             "cy",
             "cz",

{pyqrack_cpu-2.5.1 → pyqrack_cpu-2.7.0}/pyqrack/qrack_system/qrack_system.py

@@ -1204,6 +1204,15 @@ class QrackSystem:
             POINTER(c_ulonglong),
         ]
 
+        self.qrack_lib.AreFactorized.restype = c_bool
+        self.qrack_lib.AreFactorized.argtypes = [
+            c_ulonglong,
+            c_ulonglong,
+            POINTER(c_ulonglong),
+            c_ulonglong,
+            POINTER(c_ulonglong),
+        ]
+
         self.qrack_lib.GetUnitaryFidelity.restype = c_double
         self.qrack_lib.GetUnitaryFidelity.argtypes = [c_ulonglong]
 

{pyqrack_cpu-2.5.1 → pyqrack_cpu-2.7.0/pyqrack_cpu.egg-info}/PKG-INFO

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

{pyqrack_cpu-2.5.1 → pyqrack_cpu-2.7.0}/setup.py

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