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

{pyqrack_cpu_complex128-2.26.6 → pyqrack_cpu_complex128-2.28.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 b140695ddde41ecd9099bad08e9cc0a32a46a9f9; cd ..
+	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout 5c5a54c0d44b6039e57de770f57a37b6e8caeafa; cd ..
 endif
 	mkdir -p qrack/build
 ifeq ($(UNAME_S),Linux)

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

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

{pyqrack_cpu_complex128-2.26.6 → pyqrack_cpu_complex128-2.28.0}/pyqrack/__init__.py

@@ -7,6 +7,7 @@ from .pauli import Pauli
 from .neuron_activation_fn import NeuronActivationFn
 from .quimb_circuit_type import QuimbCircuitType
 from .qrack_ace_backend import QrackAceBackend
+from .qrack_ace_mps_backend import QrackAceMPSBackend, QrackMPSPatch
 from .qrack_near_clifford_qec_backend import QrackNearCliffordQecBackend
 from .qrack_circuit import QrackCircuit
 from .qrack_neuron import QrackNeuron

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

@@ -252,6 +252,7 @@ class QrackAceBackend:
         is_1d_chain=False,
         is_error_detection=True,
         is_boundary_repetition_code=False,
+        use_crossbars=True,
         to_clone=None,
     ):
         if to_clone:
@@ -263,6 +264,7 @@ class QrackAceBackend:
             is_1d_chain = to_clone.is_1d_chain
             is_error_detection = to_clone.is_error_detection
             is_boundary_repetition_code = to_clone.is_boundary_repetition_code
+            use_crossbars = to_clone.use_crossbars
         if qubit_count < 0:
             qubit_count = 0
         if long_range_columns < 0:
@@ -275,6 +277,19 @@ class QrackAceBackend:
         self.is_transpose = is_transpose
         self.is_torus = is_torus
         self.is_error_detection = is_error_detection
+        # Opt-in revival of the shared boundary "crossbar" QrackSimulator
+        # (see the note just below, at the qubit-allocation loop) that was
+        # previously removed outright for not scaling with patch count.
+        # Off by default -- same topology/behavior as before this option
+        # existed. On, it gives every boundary qubit one extra REAL replica
+        # in a single simulator shared by every boundary site in the whole
+        # grid, which is itself an un-scalable idea (that one simulator's
+        # qubit count grows with total boundary-qubit count, not with
+        # patch count) -- but for a small number of patches (e.g. 3-4,
+        # fitting on one GPU) it was measured to add real, genuine
+        # connectivity value on top of the classical LHV proxy, so it's
+        # kept available for exactly that regime rather than discarded.
+        self.use_crossbars = use_crossbars
         self.is_boundary_repetition_code = is_boundary_repetition_code
 
         if Qrack.fppow < 5:
@@ -334,19 +349,26 @@ class QrackAceBackend:
                 self._is_row_long_range[-1] = False
         sim_count = col_patch_count * row_patch_count
 
-        # The shared boundary "crossbar" QrackSimulator has been removed.
-        # It used to give every boundary site (row- and/or column-boundary
-        # alike) one extra real replica in a single simulator shared by ALL
-        # boundary qubits, trusting that simulator's own greedy elision
-        # (set_sdrp) to automatically factor apart whatever boundary sites
-        # turned out to be separable, rather than hand-coding "crossbar
-        # intersection" logic. Measurement showed it adds real, and
-        # growing-with-patch-count, connectivity value -- but per explicit
-        # instruction, it is being ripped out cleanly regardless, to get an
-        # empirical read on XEB without it. Every boundary qubit already
-        # carries a classical LHVQubit proxy (self._lhv, below) in
-        # parallel; _correct() now falls back to that proxy for tie-
-        # breaking wherever the crossbar replica used to be consulted.
+        # The shared boundary "crossbar" QrackSimulator, self.use_crossbars
+        # (see the constructor): every boundary site (row- and/or column-
+        # boundary alike) gets one extra real replica in a single
+        # simulator shared by ALL boundary qubits, trusting that
+        # simulator's own greedy elision (set_sdrp) to automatically
+        # factor apart whatever boundary sites turn out to be separable,
+        # rather than hand-coding "crossbar intersection" logic. Measured
+        # to add real connectivity value, but the single shared simulator
+        # grows with total boundary-qubit count rather than patch count,
+        # so it doesn't scale -- off by default, and worth turning on only
+        # for a handful of patches. Every boundary qubit ALSO still gets
+        # its classical LHVQubit proxy (self._lhv, below) regardless, same
+        # as when this option is off: with the crossbar on, the proxy
+        # drops to being only the last-resort tie-breaker _correct() falls
+        # back to when even the crossbar replica is itself ambiguous; with
+        # it off, the proxy is promoted to cover the crossbar's old
+        # tie-breaking role directly.
+        boundary_sim_id = sim_count
+        boundary_count = 0
+
         self._qubits = []
         self._lhv = {}
         sim_counts = [0] * sim_count
@@ -362,6 +384,10 @@ class QrackAceBackend:
                     qubit.append((t_sim_id, sim_counts[t_sim_id]))
                     sim_counts[t_sim_id] += 1
 
+                    if self.use_crossbars:
+                        qubit.append((boundary_sim_id, boundary_count))
+                        boundary_count += 1
+
                     if (not to_clone) or (tot_qubits in to_clone._lhv):
                         self._lhv[tot_qubits] = LHVQubit(
                             to_clone=(to_clone._lhv[tot_qubits] if to_clone else None)
@@ -384,6 +410,18 @@ class QrackAceBackend:
                 )
                 tot_qubits += 1
 
+        # The crossbar's size is fixed by how many boundary sites exist.
+        # When there are none at all (e.g. a grid small enough, relative
+        # to long_range_rows/columns, to be fully connected with no QEC
+        # boundary), we must NOT allocate a 0-qubit QrackSimulator for it
+        # -- sim_count/sim_counts simply stay exactly as they were,
+        # exactly mirroring how every other per-simulator allocation below
+        # already guards for "nothing to allocate."
+        has_boundary = self.use_crossbars and (boundary_count > 0)
+        if has_boundary:
+            sim_counts.append(boundary_count)
+            sim_count += 1
+
         # Error-detection gadget (IBM-style detect-and-post-select, not
         # correction): one shared ancilla per simulator -- one per patch,
         # "a single ancilla per patch, overall" -- reused across every real
@@ -460,25 +498,34 @@ class QrackAceBackend:
             # "Golden value"
             self._sdrp = 0.0
 
+        sim_kwargs = dict(
+            is_schmidt_decompose_multi=is_schmidt_decompose_multi,
+            is_stabilizer_hybrid=is_stabilizer_hybrid,
+            is_binary_decision_tree=is_binary_decision_tree,
+            is_gpu=is_gpu,
+            is_host_pointer=is_host_pointer,
+            is_near_clifford_tableau_writer=is_near_clifford_tableau_writer,
+            noise=noise,
+        )
         self.sim = []
         for i in range(sim_count):
             self.sim.append(
                 to_clone.sim[i].clone()
                 if to_clone
-                else QrackSimulator(
-                    sim_counts[i],
-                    is_schmidt_decompose_multi=is_schmidt_decompose_multi,
-                    is_stabilizer_hybrid=is_stabilizer_hybrid,
-                    is_binary_decision_tree=is_binary_decision_tree,
-                    is_gpu=is_gpu,
-                    is_host_pointer=is_host_pointer,
-                    is_near_clifford_tableau_writer=is_near_clifford_tableau_writer,
-                    noise=noise,
-                )
+                else self._new_patch_sim(sim_counts[i], sim_kwargs)
             )
 
+    def _new_patch_sim(self, qubit_count, sim_kwargs):
+        # Factory for one patch's "just-in-time state machine." Nothing
+        # else in this class depends on the patch being a QrackSimulator:
+        # any object exposing the same gate/prob/m/force_m/clone interface
+        # can be substituted by overriding this (see QrackAceMPSBackend).
+        return QrackSimulator(qubit_count, **sim_kwargs)
+
     def clone(self):
-        return QrackAceBackend(to_clone=self)
+        # type(self), not QrackAceBackend, so subclasses survive cloning
+        # (measure_shots() and run_qiskit_circuit() clone constantly).
+        return type(self)(to_clone=self)
 
     def set_sdrp(self, sdrp):
         sdrp = min(1, sdrp)
@@ -729,16 +776,19 @@ class QrackAceBackend:
 
     @staticmethod
     def _get_qb_lhv_indices(hq):
-        # With the shared boundary "crossbar" QrackSimulator removed,
-        # every entry of hq is again an ordinary (sim_id, idx) tuple into a
-        # real physical replica: 1 for a bulk qubit, 2 for an edge-boundary
-        # qubit (home + adjacent-patch), or 4 for a corner-boundary qubit
-        # (home + adjacent-patch + 2 diagonal-patch). None of them are
-        # virtual/LHV-backed slots any more -- the classical LHVQubit
-        # proxy (self._lhv) is tracked entirely separately from hq, not as
-        # one of its indices -- so qb is simply every index, in order. We
-        # keep this helper's name and signature for minimal call-site
-        # churn; "lhv" is always -1 (no index needs special-casing).
+        # Every entry of hq is an ordinary (sim_id, idx) tuple into a real
+        # physical replica: 1 for a bulk qubit; with use_crossbars=False
+        # (default), 2 for an edge-boundary qubit (home + adjacent-patch)
+        # or 4 for a corner-boundary qubit (home + adjacent-patch + 2
+        # diagonal-patch); with use_crossbars=True, 3 (home + adjacent-
+        # patch + shared crossbar) or 5 (home + adjacent-patch + shared
+        # crossbar + 2 diagonal-patch). None of them are virtual/LHV-
+        # backed slots -- the classical LHVQubit proxy (self._lhv) is
+        # tracked entirely separately from hq, not as one of its indices
+        # -- so qb is simply every index, in order, regardless of which
+        # of those counts applies. We keep this helper's name and
+        # signature for minimal call-site churn; "lhv" is always -1 (no
+        # index needs special-casing).
         qb = list(range(len(hq)))
         lhv = -1
 
@@ -945,6 +995,164 @@ class QrackAceBackend:
                 # all -- skip the rotation rather than rotate toward an
                 # arbitrary/undefined target derived from noise.
 
+        elif len(hq) == 5:
+            # Corner-boundary qubit, self.use_crossbars=True: 5 real
+            # replicas (home, adjacent-patch, the shared crossbar at
+            # slot 2, and the 2 diagonal-patch shadows). Structurally
+            # identical to the no-crossbar 4-replica case above -- the 4
+            # "end-cap" replicas [p0, p1, p3, p4] vote via their own RMS
+            # pool first; a genuine 2-2 split among them defers to the
+            # crossbar replica (hq[2], a REAL qubit, not a classical
+            # proxy); the classical LHV proxy is consulted only if the
+            # crossbar itself also turns out ambiguous.
+            p0 = self.sim[hq[0][0]].prob(hq[0][1])
+            p1 = self.sim[hq[1][0]].prob(hq[1][1])
+            p2 = self.sim[hq[2][0]].prob(hq[2][1])
+            p3 = self.sim[hq[3][0]].prob(hq[3][1])
+            p4 = self.sim[hq[4][0]].prob(hq[4][1])
+            lhv = self._lhv.get(lq)
+
+            end_caps = [p0, p1, p3, p4]
+            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
+            end_caps_tied = (high_count == 2 and low_count == 2) or (undecided_count > 0)
+
+            if not end_caps_tied:
+                prms = math.sqrt(sum(x**2 for x in end_caps) / 4)
+                qrms = math.sqrt(sum((1 - x) ** 2 for x in end_caps) / 4)
+                eff_prob = (prms + (1 - qrms)) / 2
+                result = (
+                    (random.random() < 0.5)
+                    if abs(eff_prob - 0.5) <= self._epsilon
+                    else (eff_prob >= 0.5)
+                )
+            elif abs(p2 - 0.5) > self._epsilon:
+                result = p2 >= 0.5
+            elif lhv is not None:
+                p_lhv = lhv.prob()
+                result = (
+                    (random.random() < 0.5)
+                    if abs(p_lhv - 0.5) <= self._epsilon
+                    else (p_lhv >= 0.5)
+                )
+            else:
+                result = random.random() < 0.5
+
+            p = [p0, p1, p2, p3, p4]
+            syndrome = [1 - x for x in p] if result else list(p)
+            for q in range(5):
+                if syndrome[q] > (0.5 + self._epsilon):
+                    self.sim[hq[q][0]].x(hq[q][1])
+
+            if not skip_rotation:
+                a, i, rs = [0] * 5, [0] * 5, [0] * 5
+                for idx in range(5):
+                    a[idx], i[idx], rs[idx] = self._get_bloch_angles(hq[idx])
+                w = [1 - r for r in rs]
+
+                w_total = sum(w)
+                if w_total > self._epsilon:
+                    a_target = sum(wx * ax for wx, ax in zip(w, a)) / w_total
+                    i_target = sum(wx * ix for wx, ix in zip(w, i)) / w_total
+                    # Same separability gating as the 4-replica case
+                    # above (hq[0] excluded outright, hq[1:] only
+                    # rotated while still reasonably separable).
+                    for x in range(1, 5):
+                        if rs[x] <= self._rot_epsilon:
+                            self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+
+        elif len(hq) == 3:
+            # Edge-boundary qubit, self.use_crossbars=True: 3 real
+            # replicas (home, adjacent-patch, and the shared crossbar at
+            # slot 2). Same conditional tie-breaking cascade as the
+            # no-crossbar 2-replica case below, but with the crossbar
+            # (hq[2], a REAL qubit) taking over the role the classical
+            # LHV proxy plays there: trust slot1 (adjacent-patch) and
+            # slot2 (crossbar) together whenever they agree; fall back
+            # to slot0 (home) when they disagree and it has a decisive
+            # opinion; consult the classical LHV proxy only as an
+            # absolute last resort, if even slot0 is ambiguous.
+            p0 = self.sim[hq[0][0]].prob(hq[0][1])
+            p1 = self.sim[hq[1][0]].prob(hq[1][1])
+            p2 = self.sim[hq[2][0]].prob(hq[2][1])
+            lhv = self._lhv.get(lq)
+
+            p1_high = p1 > (0.5 + self._epsilon)
+            p1_low = p1 < (0.5 - self._epsilon)
+            p2_high = p2 > (0.5 + self._epsilon)
+            p2_low = p2 < (0.5 - self._epsilon)
+            end_caps_agree = (p1_high and p2_high) or (p1_low and p2_low)
+            slot0_disagrees_with_end_caps = (
+                end_caps_agree
+                and (abs(p0 - 0.5) > self._epsilon)
+                and ((p0 >= 0.5) != p1_high)
+            )
+            if slot0_disagrees_with_end_caps:
+                # Same reasoning as the no-crossbar 2-replica case below:
+                # the pair agreeing is not, by itself, reliable
+                # corroboration if slot0 has a real, decisive, opposing
+                # opinion -- that contradiction is the signal the pair is
+                # stale, not corroborating.
+                result = p0 >= 0.5
+            elif end_caps_agree:
+                prms = math.sqrt((p1**2 + p2**2) / 2)
+                qrms = math.sqrt(((1 - p1) ** 2 + (1 - p2) ** 2) / 2)
+                eff_prob = (prms + (1 - qrms)) / 2
+                result = (
+                    (random.random() < 0.5)
+                    if abs(eff_prob - 0.5) <= self._epsilon
+                    else (eff_prob >= 0.5)
+                )
+            elif abs(p0 - 0.5) > self._epsilon:
+                # Genuine deadlock between slot1/slot2; slot0 (a real,
+                # exactly-entangled qubit in this common topology) has a
+                # real opinion, so it breaks the tie.
+                result = p0 >= 0.5
+            elif lhv is not None:
+                # slot0 is itself ambiguous, and so is the crossbar pair
+                # above it; only now does the classical LHV's continuous,
+                # non-collapsing proxy actually decide, as the last
+                # resort.
+                p_lhv = lhv.prob()
+                result = (
+                    (random.random() < 0.5)
+                    if abs(p_lhv - 0.5) <= self._epsilon
+                    else (p_lhv >= 0.5)
+                )
+            else:
+                result = random.random() < 0.5
+
+            p = [p0, p1, p2]
+            syndrome = [1 - x for x in p] if result else list(p)
+            for q in range(3):
+                if syndrome[q] > (0.5 + self._epsilon):
+                    self.sim[hq[q][0]].x(hq[q][1])
+            # The LHV proxy is never hard-collapsed via x(); it is only
+            # ever updated by its own transversal gate evolution and
+            # _cpauli_lhv, same as every other branch here.
+
+            if (not skip_rotation) and (not end_caps_agree):
+                a, i, rs = [0, 0, 0], [0, 0, 0], [0, 0, 0]
+                a[0], i[0], rs[0] = self._get_bloch_angles(hq[0])
+                a[1], i[1], rs[1] = self._get_bloch_angles(hq[1])
+                a[2], i[2], rs[2] = self._get_bloch_angles(hq[2])
+                w = [1 - r for r in rs]
+
+                w_total = sum(w)
+                if w_total > self._epsilon:
+                    a_target = sum(wx * ax for wx, ax in zip(w, a)) / w_total
+                    i_target = sum(wx * ix for wx, ix in zip(w, i)) / w_total
+                    # slot0 (hq[0]) is excluded from the rotation itself,
+                    # same reasoning as every other branch here; slot1
+                    # and slot2 (the crossbar) are both real, lossy
+                    # shadow-style replicas with no comparable
+                    # entanglement to protect, so both are eligible,
+                    # each gated on its own separability.
+                    for x in (1, 2):
+                        if rs[x] <= self._rot_epsilon:
+                            self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+
         else:
             # Edge-boundary qubit: only 2 real replicas remain (home +
             # adjacent-patch) now that the crossbar replica that used to
@@ -2112,36 +2320,21 @@ class QrackAceBackend:
             return self.sim[b[0]].prob(b[1])
 
         self._correct(lq)
-        if len(hq) == 4:
-            # The 4 real replicas are already mutually consistent here
-            # (the _correct() call above already ran the tie-breaking
-            # cascade, using the LHV proxy as needed, and forced
-            # agreement via x()). A plain, unweighted RMS over the
-            # now-settled replicas is the correct, already-decided
-            # answer -- there is no crossbar replica left to weight
-            # specially any more.
-            p = [
-                self.sim[hq[0][0]].prob(hq[0][1]),
-                self.sim[hq[1][0]].prob(hq[1][1]),
-                self.sim[hq[2][0]].prob(hq[2][1]),
-                self.sim[hq[3][0]].prob(hq[3][1]),
-            ]
-            prms = math.sqrt(sum(x**2 for x in p) / 4)
-            qrms = math.sqrt(sum((1 - x) ** 2 for x in p) / 4)
-        else:
-            # The 2 real replicas are already mutually consistent here
-            # (the _correct() call above already ran the conditional
-            # tie-breaking cascade, using the LHV proxy as needed, and
-            # forced agreement via x()). Re-weighting in the LHV here
-            # would reintroduce the same center-dragging distortion the
-            # cascade was built to avoid -- a plain RMS over the
-            # now-settled pair is the correct, already-decided answer.
-            p = [
-                self.sim[hq[0][0]].prob(hq[0][1]),
-                self.sim[hq[1][0]].prob(hq[1][1]),
-            ]
-            prms = math.sqrt((p[0] ** 2 + p[1] ** 2) / 2)
-            qrms = math.sqrt(((1 - p[0]) ** 2 + (1 - p[1]) ** 2) / 2)
+        # The real replicas are already mutually consistent here (the
+        # _correct() call above already ran the appropriate tie-breaking
+        # cascade for however many replicas hq has -- 2, 3, 4, or 5,
+        # depending on self.use_crossbars and whether this is an edge or
+        # corner boundary qubit -- using the LHV proxy and/or the
+        # crossbar replica as needed, and forced agreement via x()). A
+        # plain, unweighted RMS over the now-settled replicas is the
+        # correct, already-decided answer, regardless of replica count:
+        # re-weighting any particular replica specially here would
+        # reintroduce the same center-dragging distortion the cascade in
+        # _correct() was built to avoid.
+        p = [self.sim[b[0]].prob(b[1]) for b in hq]
+        n = len(p)
+        prms = math.sqrt(sum(x**2 for x in p) / n)
+        qrms = math.sqrt(sum((1 - x) ** 2 for x in p) / n)
 
         return (prms + (1 - qrms)) / 2
 
@@ -2523,7 +2716,7 @@ class QrackAceBackend:
                 self._classical_memory = 0
                 self._classical_register = 0
             else:
-                self._sim = QrackAceBackend(to_clone=preamble_sim)
+                self._sim = type(preamble_sim)(to_clone=preamble_sim)
                 self._classical_memory = preamble_memory
                 self._classical_register = preamble_register
 

pyqrack_cpu_complex128-2.28.0/pyqrack/qrack_ace_mps_backend.py

@@ -0,0 +1,392 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+#
+# Produced with input from (Anthropic) Claude
+#
+# QrackAceBackend over matrix-product-state patches.
+#
+# QrackAceBackend's elision scheme (replicated boundary qubits, shadow
+# couplers, _correct() reconciliation, LHV tie-breakers, error-detection
+# gadgets) never inspects HOW a patch stores its state: it only drives each
+# patch through a small "just-in-time state machine" interface -- single-
+# qubit gates, (anti-)controlled Paulis, swap, prob(), m(), force_m(),
+# clone(). QrackMPSPatch implements exactly that interface on an MPS, so
+# every line of ACE's own logic runs unchanged on top of it.
+#
+# What MPS buys: a patch's cost is set by its entanglement (bond dimension
+# chi), not by 2^(patch width), so patches far wider than a state vector
+# could hold become possible when in-patch entanglement allows -- and, with
+# max_bond/cutoff, a second, tunable approximation layer (truncation INSIDE
+# a patch) composes with ACE's first one (elision BETWEEN patches).
+#
+# Implementation notes:
+#   * Plain numpy MPS, site tensors A[s] of shape (Dl, 2, Dr), with an
+#     explicitly tracked orthogonality center. (A quimb-backed prototype
+#     was ~180x slower inside ACE, almost entirely from re-deriving the
+#     orthogonality center on every prob() call -- and ACE calls prob()
+#     constantly. Tracking it explicitly makes prob() O(chi^2) plus the
+#     cost of moving the center, usually zero or one QR step.)
+#   * Logical qubits map to MPS sites through a permutation, so swap() is a
+#     free, exact relabeling -- the same reason ACE's own native swap is
+#     exact -- and non-adjacent 2-qubit gates are routed by adjacent SWAPs
+#     that are LEFT in place (relabeled), not undone.
+#   * Truncation: max_bond caps chi; cutoff is a per-split budget on
+#     discarded probability weight (sum of discarded s^2 / total s^2).
+#     set_sdrp() sets cutoff, as the MPS analog of Qrack's SDRP.
+
+import math
+import random
+
+_IS_NUMPY_AVAILABLE = True
+try:
+    import numpy as np
+except:
+    _IS_NUMPY_AVAILABLE = False
+
+from .pauli import Pauli
+from .qrack_ace_backend import QrackAceBackend
+
+
+_I2 = np.eye(2, dtype=complex)
+_X = np.array([[0, 1], [1, 0]], dtype=complex)
+_Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
+_Z = np.array([[1, 0], [0, -1]], dtype=complex)
+_H = np.array([[1, 1], [1, -1]], dtype=complex) / math.sqrt(2)
+_S = np.diag([1, 1j]).astype(complex)
+_SDG = _S.conj().T
+_T = np.diag([1, np.exp(1j * math.pi / 4)]).astype(complex)
+_TDG = _T.conj().T
+_SX = 0.5 * np.array([[1 + 1j, 1 - 1j], [1 - 1j, 1 + 1j]], dtype=complex)
+_SXDG = _SX.conj().T
+_P0 = np.diag([1, 0]).astype(complex)
+_P1 = np.diag([0, 1]).astype(complex)
+_SWAP = np.array(
+    [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=complex
+)
+_PAULI_MTRX = {Pauli.PauliX: _X, Pauli.PauliY: _Y, Pauli.PauliZ: _Z}
+
+
+def _controlled(u, anti=False):
+    # 4x4 in the (control, target) basis, control = first (most significant).
+    g = np.eye(4, dtype=complex)
+    if anti:
+        g[0:2, 0:2] = u
+    else:
+        g[2:4, 2:4] = u
+    return g
+
+
+_CX = _controlled(_X)
+
+
+class QrackMPSPatch:
+    """One ACE patch held as an MPS, exposing the subset of the
+    QrackSimulator interface that QrackAceBackend calls on its patches.
+
+    Args:
+        qubit_count: patch width.
+        max_bond: bond-dimension cap (None = no cap).
+        cutoff: per-split discarded-weight budget (0 = exact up to
+            numerical zeros).
+    """
+
+    _ZERO_TOL = 1e-14
+
+    def __init__(self, qubit_count, max_bond=None, cutoff=0.0, _state=None):
+        if not _IS_NUMPY_AVAILABLE:
+            raise RuntimeError(
+                "Before instantiating QrackAceMPSPatch, you must install numpy!"
+            )
+        self.n = qubit_count
+        self.max_bond = max_bond
+        self.cutoff = float(cutoff)
+        self.truncation_error = 0.0  # accumulated discarded weight
+        if _state is not None:
+            self.A, self.site_of, self.q_at, self.center = _state
+        else:
+            t = np.zeros((1, 2, 1), dtype=complex)
+            t[0, 0, 0] = 1.0
+            self.A = [t.copy() for _ in range(max(1, qubit_count))]
+            self.site_of = list(range(qubit_count))
+            self.q_at = list(range(qubit_count))
+            self.center = 0
+
+    # --- bookkeeping -------------------------------------------------------
+
+    def clone(self):
+        c = QrackMPSPatch(
+            self.n, self.max_bond, self.cutoff,
+            _state=([a.copy() for a in self.A], list(self.site_of), list(self.q_at), self.center),
+        )
+        c.truncation_error = self.truncation_error
+        return c
+
+    def set_sdrp(self, sdrp):
+        self.cutoff = max(0.0, float(sdrp))
+
+    def set_device(self, device_id):
+        # MPS patches run on the host; accepted for interface compatibility.
+        pass
+
+    def num_qubits(self):
+        return self.n
+
+    def max_bond_dim(self):
+        return max(a.shape[2] for a in self.A)
+
+    # --- canonical-form machinery -------------------------------------------
+
+    def _move_center(self, s):
+        A = self.A
+        while self.center < s:
+            c = self.center
+            dl, d, dr = A[c].shape
+            q, r = np.linalg.qr(A[c].reshape(dl * d, dr))
+            A[c] = q.reshape(dl, d, q.shape[1])
+            A[c + 1] = np.tensordot(r, A[c + 1], axes=(1, 0))
+            self.center += 1
+        while self.center > s:
+            c = self.center
+            dl, d, dr = A[c].shape
+            q, r = np.linalg.qr(A[c].reshape(dl, d * dr).T)
+            A[c] = q.T.reshape(q.shape[1], d, dr)
+            A[c - 1] = np.tensordot(A[c - 1], r.T, axes=(2, 0))
+            self.center -= 1
+
+    def _apply_site_1q(self, mat, s, unitary=True):
+        if not unitary:
+            # Non-unitary (projector): only safe at the orthogonality center.
+            self._move_center(s)
+        self.A[s] = np.einsum("ab,lbr->lar", mat, self.A[s])
+
+    def _apply_adjacent_2q(self, g4, s):
+        # g4 acts on (site s, site s+1), site s = most significant.
+        self._move_center(s)
+        a, b = self.A[s], self.A[s + 1]
+        dl, dr = a.shape[0], b.shape[2]
+        theta = np.tensordot(a, b, axes=(2, 0))                      # (dl,2,2,dr)
+        theta = np.einsum("ijkl,aklb->aijb", g4.reshape(2, 2, 2, 2), theta)
+        u, sv, vh = np.linalg.svd(theta.reshape(dl * 2, 2 * dr), full_matrices=False)
+        w = sv ** 2
+        total = float(np.sum(w))
+        keep = len(sv)
+        # Drop numerical zeros always; drop more only within the budget.
+        tail = np.cumsum(w[::-1])[::-1]  # tail[k] = sum_{j>=k} w[j]
+        budget = max(self.cutoff * total, self._ZERO_TOL * total)
+        while keep > 1 and tail[keep - 1] <= budget:
+            keep -= 1
+        if self.max_bond is not None and keep > self.max_bond:
+            keep = self.max_bond
+        discarded = float(np.sum(w[keep:]))
+        if discarded > 0 and total > 0:
+            self.truncation_error += discarded / total
+        u, sv, vh = u[:, :keep], sv[:keep], vh[:keep, :]
+        if discarded > 0:
+            # Restore the pre-truncation norm (the center carries it all).
+            sv = sv * math.sqrt(total / float(np.sum(sv ** 2)))
+        self.A[s] = u.reshape(dl, 2, keep)
+        self.A[s + 1] = (sv[:, None] * vh).reshape(keep, 2, dr)
+        self.center = s + 1
+
+    def _swap_sites(self, s):
+        # Physically exchange sites s, s+1 and relabel.
+        self._apply_adjacent_2q(_SWAP, s)
+        qa, qb = self.q_at[s], self.q_at[s + 1]
+        self.q_at[s], self.q_at[s + 1] = qb, qa
+        self.site_of[qa], self.site_of[qb] = s + 1, s
+
+    # --- gate application --------------------------------------------------
+
+    def _g1(self, mat, q, unitary=True):
+        self._apply_site_1q(mat, self.site_of[q], unitary)
+
+    def _g2(self, g4, q1, q2):
+        # g4 acts on (q1, q2), q1 = most significant.
+        if q1 == q2:
+            raise ValueError("Two-qubit gate on identical qubits.")
+        # Route q2 next to q1 with adjacent swaps, left in place.
+        while abs(self.site_of[q1] - self.site_of[q2]) > 1:
+            s1, s2 = self.site_of[q1], self.site_of[q2]
+            if s2 > s1:
+                self._swap_sites(s2 - 1)
+            else:
+                self._swap_sites(s2)
+        s1, s2 = self.site_of[q1], self.site_of[q2]
+        if s1 < s2:
+            self._apply_adjacent_2q(g4, s1)
+        else:
+            self._apply_adjacent_2q(_SWAP @ g4 @ _SWAP, s2)
+
+    def mtrx(self, m, q):
+        self._g1(np.array([[m[0], m[1]], [m[2], m[3]]], dtype=complex), q)
+
+    def u(self, q, th, ph, la):
+        c, s = math.cos(th / 2), math.sin(th / 2)
+        self._g1(np.array(
+            [[c, -np.exp(1j * la) * s],
+             [np.exp(1j * ph) * s, np.exp(1j * (ph + la)) * c]], dtype=complex), q)
+
+    def r(self, b, ph, q):
+        p = _PAULI_MTRX.get(b)
+        if p is None:
+            return  # PauliI: global phase only
+        self._g1(math.cos(ph / 2) * _I2 - 1j * math.sin(ph / 2) * p, q)
+
+    def h(self, q): self._g1(_H, q)
+    def x(self, q): self._g1(_X, q)
+    def y(self, q): self._g1(_Y, q)
+    def z(self, q): self._g1(_Z, q)
+    def s(self, q): self._g1(_S, q)
+    def adjs(self, q): self._g1(_SDG, q)
+    def t(self, q): self._g1(_T, q)
+    def adjt(self, q): self._g1(_TDG, q)
+    def sx(self, q): self._g1(_SX, q)
+    def adjsx(self, q): self._g1(_SXDG, q)
+
+    def _toffoli(self, c1, c2, t):
+        self.h(t)
+        self._g2(_CX, c2, t); self.adjt(t)
+        self._g2(_CX, c1, t); self.t(t)
+        self._g2(_CX, c2, t); self.adjt(t)
+        self._g2(_CX, c1, t); self.t(t)
+        self.h(t)
+        self.t(c2)
+        self._g2(_CX, c1, c2); self.t(c1); self.adjt(c2)
+        self._g2(_CX, c1, c2)
+
+    def _mc_pauli(self, c, q, u, anti):
+        c = list(c)
+        if len(c) == 0:
+            self._g1(u, q)
+        elif len(c) == 1:
+            self._g2(_controlled(u, anti), c[0], q)
+        elif len(c) == 2:
+            # Exact 1-/2-qubit Toffoli decomposition, conjugated into
+            # X, Y, or Z on the target.
+            if anti:
+                for x in c:
+                    self.x(x)
+            pre, post = None, None
+            if u is _Y:
+                pre, post = _SDG, _S
+            elif u is _Z:
+                pre, post = _H, _H
+            if pre is not None:
+                self._g1(pre, q)
+            self._toffoli(c[0], c[1], q)
+            if post is not None:
+                self._g1(post, q)
+            if anti:
+                for x in c:
+                    self.x(x)
+        else:
+            raise NotImplementedError("QrackMPSPatch supports at most 2 controls per gate.")
+
+    def mcx(self, c, q): self._mc_pauli(c, q, _X, False)
+    def mcy(self, c, q): self._mc_pauli(c, q, _Y, False)
+    def mcz(self, c, q): self._mc_pauli(c, q, _Z, False)
+    def macx(self, c, q): self._mc_pauli(c, q, _X, True)
+    def macy(self, c, q): self._mc_pauli(c, q, _Y, True)
+    def macz(self, c, q): self._mc_pauli(c, q, _Z, True)
+
+    def swap(self, q1, q2):
+        # Exact and free: relabel which site each logical qubit lives on.
+        if q1 == q2:
+            return
+        s1, s2 = self.site_of[q1], self.site_of[q2]
+        self.site_of[q1], self.site_of[q2] = s2, s1
+        self.q_at[s1], self.q_at[s2] = q2, q1
+
+    def cswap(self, c, q1, q2):
+        c = list(c)
+        if q1 == q2:
+            return
+        if len(c) != 1:
+            raise NotImplementedError("QrackMPSPatch.cswap() supports exactly 1 control.")
+        self._g2(_CX, q2, q1)
+        self._toffoli(c[0], q1, q2)
+        self._g2(_CX, q2, q1)
+
+    # --- readout -----------------------------------------------------------
+
+    def prob(self, q):
+        s = self.site_of[q]
+        self._move_center(s)
+        a = self.A[s]
+        total = float(np.sum(np.abs(a) ** 2))
+        if total <= 0:
+            return 0.0
+        one = float(np.sum(np.abs(a[:, 1, :]) ** 2))
+        return min(1.0, max(0.0, one / total))
+
+    def force_m(self, q, r):
+        s = self.site_of[q]
+        self._move_center(s)
+        a = self.A[s].copy()
+        a[:, 0 if r else 1, :] = 0
+        nrm = math.sqrt(float(np.sum(np.abs(a) ** 2)))
+        if nrm > 0:
+            self.A[s] = a / nrm
+        return bool(r)
+
+    def m(self, q):
+        return self.force_m(q, random.random() < self.prob(q))
+
+    def m_all(self):
+        result = 0
+        for q in range(self.n):
+            if self.m(q):
+                result |= 1 << q
+        return result
+
+    # --- dense readout (testing only; 2^n) ----------------------------------
+
+    def out_ket(self):
+        v = self.A[0]
+        for a in self.A[1:]:
+            v = np.tensordot(v, a, axes=(v.ndim - 1, 0))
+        v = v.reshape([2] * self.n)  # axis k = site k
+        # Reorder axes into Qrack's little-endian logical order: the
+        # C-order flatten treats axis 0 as most significant, so axis 0
+        # must be logical qubit n-1.
+        v = np.transpose(v, [self.site_of[q] for q in range(self.n - 1, -1, -1)])
+        return v.reshape(-1)
+
+    def out_probs(self):
+        return np.abs(self.out_ket()) ** 2
+
+
+class QrackAceMPSBackend(QrackAceBackend):
+    """QrackAceBackend whose patches are MPS (QrackMPSPatch) instead of
+    QrackSimulator. All elision, shadow-coupling, reconciliation and
+    error-detection logic is inherited unchanged.
+
+    Extra args:
+        max_bond: per-patch MPS bond-dimension cap (None = no cap).
+        mps_cutoff: per-split discarded-weight budget (0 = exact).
+    QrackSimulator-only construction options (is_gpu, is_stabilizer_hybrid,
+    ...) are accepted and ignored.
+    """
+
+    def __init__(self, *args, max_bond=None, mps_cutoff=0.0, to_clone=None, **kwargs):
+        if not _IS_NUMPY_AVAILABLE:
+            raise RuntimeError(
+                "Before instantiating QrackAceMPSBackend, you must install numpy!"
+            )
+        if to_clone is not None:
+            max_bond = to_clone.max_bond
+            mps_cutoff = to_clone.mps_cutoff
+        self.max_bond = max_bond
+        self.mps_cutoff = mps_cutoff
+        super().__init__(*args, to_clone=to_clone, **kwargs)
+
+    def _new_patch_sim(self, qubit_count, sim_kwargs):
+        return QrackMPSPatch(qubit_count, max_bond=self.max_bond, cutoff=self.mps_cutoff)
+
+    def max_bond_dims(self):
+        return [s.max_bond_dim() for s in self.sim]
+
+    def truncation_errors(self):
+        return [s.truncation_error for s in self.sim]

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

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

{pyqrack_cpu_complex128-2.26.6 → pyqrack_cpu_complex128-2.28.0}/pyqrack_cpu_complex128.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ pyqrack/__init__.py
 pyqrack/neuron_activation_fn.py
 pyqrack/pauli.py
 pyqrack/qrack_ace_backend.py
+pyqrack/qrack_ace_mps_backend.py
 pyqrack/qrack_circuit.py
 pyqrack/qrack_near_clifford_qec_backend.py
 pyqrack/qrack_neuron.py

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

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