pyqrack-complex128 2.1.0__tar.gz → 2.1.2__tar.gz

{pyqrack_complex128-2.1.0/pyqrack_complex128.egg-info → pyqrack_complex128-2.1.2}/PKG-INFO

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

{pyqrack_complex128-2.1.0 → pyqrack_complex128-2.1.2}/pyqrack/qrack_ace_backend.py

@@ -2,6 +2,8 @@
 #
 # 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 (OpenAI) ChatGPT and (Anthropic) Claude
 import math
 import os
 import random
@@ -332,6 +334,50 @@ class QrackAceBackend:
     def clone(self):
         return QrackAceBackend(to_clone=self)
 
+    def measure_shots_consensus(self, q, s, n_instances=3, threshold=0.1):
+        # Consensus measurement across n_instances independent clones.
+        #
+        # For each shot, run n_instances clones of the current state and
+        # compare their marginal probabilities on every logical qubit via
+        # prob(). For each qubit, take the majority vote over all instances:
+        # if the average marginal >= 0.5, force_m to |1>; else to |0>.
+        #
+        # This resolves the parity ambiguity that causes XEB flip-flopping:
+        # a bit-flip on a boundary qubit appears as disagreement between
+        # instances (one sees p~0.9, another sees p~0.1). The majority vote
+        # across n_instances corrects isolated odd-parity errors without
+        # requiring a second full circuit run — just cheap prob() queries.
+        #
+        # threshold: minimum spread in marginals to trigger consensus
+        # correction (below threshold, instances agree and no correction needed).
+        n_qubits = self.num_qubits()
+        samples = []
+        for _ in range(s):
+            # Run n_instances clones, collect marginals for every qubit
+            clones = [self.clone() for _ in range(n_instances)]
+            marginals = [
+                [c.prob(lq) for lq in range(n_qubits)]
+                for c in clones
+            ]
+            # Majority vote: average marginal across instances per qubit
+            avg_marginals = [
+                sum(marginals[i][lq] for i in range(n_instances)) / n_instances
+                for lq in range(n_qubits)
+            ]
+            # Force all qubits in first clone to majority-vote outcome
+            primary = clones[0]
+            for lq in range(n_qubits):
+                result = avg_marginals[lq] >= 0.5
+                primary.force_m(lq, result)
+            # Read out requested qubits
+            _sample = primary.m_all()
+            sample = 0
+            for i in range(len(q)):
+                if (_sample >> q[i]) & 1:
+                    sample |= 1 << i
+            samples.append(sample)
+        return samples
+
     def num_qubits(self):
         return self._row_length * self._col_length
 
@@ -672,8 +718,7 @@ class QrackAceBackend:
         b = hq[lhv]
         b.u(th, ph, lm)
 
-        self._correct(lq, False, True)
-        self._correct(lq, True, False)
+        # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
     def r(self, p, th, lq):
         hq = self._unpack(lq)
@@ -696,10 +741,7 @@ class QrackAceBackend:
         elif p == Pauli.PauliZ:
             b.rz(th)
 
-        if p != Pauli.PauliZ:
-            self._correct(lq, False, p != Pauli.PauliX)
-        if p != Pauli.PauliX:
-            self._correct(lq, True)
+        # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
     def h(self, lq):
         hq = self._unpack(lq)
@@ -719,7 +761,7 @@ class QrackAceBackend:
         b = hq[lhv]
         b.h()
 
-        self._correct(lq)
+        # Correction deferred to next 2-qubit gate (_cpauli calls _correct)
 
     def s(self, lq):
         hq = self._unpack(lq)
@@ -1475,38 +1517,48 @@ class QrackAceBackend:
         return self._coupling_map
 
     # Designed by Dan, and implemented by Elara:
-    def create_noise_model(self, x=0.25, y=0.25):
+    def create_noise_model(self, x=0.125, y=0.25):
         if not _IS_QISKIT_AER_AVAILABLE:
             raise RuntimeError(
                 "Before trying to run_qiskit_circuit() with QrackAceBackend, you must install Qiskit Aer!"
             )
         noise_model = NoiseModel()
 
+        # Single-qubit depolarizing only on boundary qubits
+        boundary_qubits = set()
+        for a, b in self.get_logical_coupling_map():
+            col_a = a % self._row_length
+            col_b = b % self._row_length
+            is_long_a = self._is_col_long_range[col_a]
+            is_long_b = self._is_col_long_range[col_b]
+            if not (is_long_a and is_long_b):
+                if not is_long_a:
+                    boundary_qubits.add(a)
+                if not is_long_b:
+                    boundary_qubits.add(b)
+
+        for q in boundary_qubits:
+            for gate in ["u", "u1", "u2", "u3", "h", "x", "y", "z",
+                         "s", "sdg", "t", "tdg", "rx", "ry", "rz"]:
+                noise_model.add_quantum_error(
+                    depolarizing_error(x, 1), gate, [q])
+
+        # Two-qubit depolarizing on boundary-crossing and boundary-adjacent gates
         for a, b in self.get_logical_coupling_map():
-            col_a, col_b = a % self._row_length, b % self._row_length
-            row_a, row_b = a // self._row_length, b // self._row_length
+            col_a = a % self._row_length
+            col_b = b % self._row_length
             is_long_a = self._is_col_long_range[col_a]
             is_long_b = self._is_col_long_range[col_b]
 
             if is_long_a and is_long_b:
-                continue  # No noise on long-to-long
-
-            if (col_a == col_b) or (row_a == row_b):
-                continue  # No noise for same column
-
-            if is_long_a or is_long_b:
-                y_cy = 1 - (1 - y) ** 2
-                y_swap = 1 - (1 - y) ** 3
-                noise_model.add_quantum_error(depolarizing_error(y, 2), "cx", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cy", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cz", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(y_swap, 2), "swap", [a, b])
-            else:
-                y_cy = 1 - (1 - y) ** 2
-                y_swap = 1 - (1 - y) ** 3
-                noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cx", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cy", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(y_cy, 2), "cz", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(y_swap, 2), "swap", [a, b])
+                continue
+
+            p2 = 1 - (1 - y) ** 2 if (is_long_a or is_long_b) else y
+            p3 = 1 - (1 - y) ** 3 if (is_long_a or is_long_b) else 1 - (1 - y) ** 2
+
+            for gate in ["cx", "cy", "cz"]:
+                noise_model.add_quantum_error(depolarizing_error(p2, 2), gate, [a, b])
+            for gate in ["swap", "iswap"]:
+                noise_model.add_quantum_error(depolarizing_error(p3, 2), gate, [a, b])
 
         return noise_model

{pyqrack_complex128-2.1.0 → pyqrack_complex128-2.1.2/pyqrack_complex128.egg-info}/PKG-INFO

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

{pyqrack_complex128-2.1.0 → pyqrack_complex128-2.1.2}/setup.py

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