pyqrack-cuda 1.50.1__tar.gz → 1.52.0__tar.gz

{pyqrack_cuda-1.50.1 → pyqrack_cuda-1.52.0}/Makefile

@@ -18,7 +18,7 @@ help:
 build-deps:
 ifneq ($(OS),Windows_NT)
 ifeq ($(QRACK_PRESENT),)
-	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout 065d4575ca82be0398ed726de59899c16500581f; cd ..
+	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout f0738286f49fb0ffaeb46d6e5d2294dbfc7f6138; cd ..
 endif
 	mkdir -p qrack/build
 ifeq ($(UNAME_S),Linux)

{pyqrack_cuda-1.50.1/pyqrack_cuda.egg-info → pyqrack_cuda-1.52.0}/PKG-INFO

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

{pyqrack_cuda-1.50.1 → pyqrack_cuda-1.52.0}/pyqrack/qrack_ace_backend.py

@@ -35,12 +35,14 @@ class QrackAceBackend:
 
     The backend was originally designed assuming an (orbifolded) 2D qubit grid like 2019 Sycamore.
     However, it quickly became apparent that users can basically design their own connectivity topologies,
-    without breaking the concept. (Not all will work equally well.) For maximum flexibility, set
-    "alternating_codes=False". (For best performance on Sycamore-like topologies,leave it "True.")
+    without breaking the concept. (Not all will work equally well.)
+
+    Consider distributing the different "patches" to different GPUs with self.sim[sim_id].set_device(gpu_id)!
+    (If you have 3+ patches, maybe your discrete GPU can do multiple patches in the time it takes an Intel HD
+    to do one patch worth of work!)
 
     Attributes:
-        sim(QrackSimulator): Corresponding simulator.
-        alternating_codes(bool): Alternate repetition code elision by index?
+        sim(QrackSimulator): Array of simulators corresponding to "patches" between boundary rows.
         row_length(int): Qubits per row.
         col_length(int): Qubits per column.
         long_range_columns(int): How many ideal rows between QEC boundary rows?
@@ -50,7 +52,6 @@ class QrackAceBackend:
         self,
         qubit_count=1,
         long_range_columns=-1,
-        alternating_codes=True,
         reverse_row_and_col=False,
         isTensorNetwork=False,
         isStabilizerHybrid=False,
@@ -68,7 +69,6 @@ class QrackAceBackend:
             long_range_columns = 3 if (self.row_length % 3) == 1 else 2
         self.long_range_columns = long_range_columns
 
-        self.alternating_codes = alternating_codes
         self._coupling_map = None
 
         # If there's only one or zero "False" columns,
@@ -96,24 +96,24 @@ class QrackAceBackend:
                     self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
                     tot_qubits += 1
                     sim_counts[sim_id] += 1
-                elif not self.alternating_codes or not (r & 1):
-                    self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
-                    tot_qubits += 1
-                    sim_counts[sim_id] += 1
-                    sim_id = (sim_id + 1) % sim_count
+                elif (r & 1):
                     for _ in range(2):
                         self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
                         tot_qubits += 1
                         sim_counts[sim_id] += 1
+                    sim_id = (sim_id + 1) % sim_count
+                    self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
+                    tot_qubits += 1
+                    sim_counts[sim_id] += 1
                 else:
+                    self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
+                    tot_qubits += 1
+                    sim_counts[sim_id] += 1
+                    sim_id = (sim_id + 1) % sim_count
                     for _ in range(2):
                         self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
                         tot_qubits += 1
                         sim_counts[sim_id] += 1
-                    sim_id = (sim_id + 1) % sim_count
-                    self._qubit_dict[tot_qubits] = (sim_id, sim_counts[sim_id])
-                    tot_qubits += 1
-                    sim_counts[sim_id] += 1
 
         self.sim = []
         for i in range(sim_count):
@@ -230,6 +230,16 @@ class QrackAceBackend:
             b2 = hq[2]
             self.sim[b2[0]].mcx([b2[1]], hq[1][1])
 
+    def _encode_decode_half(self, lq, hq, toward_0):
+        if len(hq) < 2:
+            return
+        if toward_0 and (hq[0][0] == hq[1][0]):
+            b0 = hq[0]
+            self.sim[b0[0]].mcx([b0[1]], hq[1][1])
+        elif not toward_0 and (hq[2][0] == hq[1][0]):
+            b2 = hq[2]
+            self.sim[b2[0]].mcx([b2[1]], hq[1][1])
+
     def _correct(self, lq):
         if self._is_col_long_range[lq % self.row_length]:
             return
@@ -258,9 +268,9 @@ class QrackAceBackend:
 
         # Suggestion from Elara (the custom OpenAI GPT):
         # Create phase parity tie before measurement.
-        # self._ccx_shadow(hq[single_bit], hq[other_bits[0]], [ancilla_sim, ancilla])
-        # self.sim[ancilla_sim].mcx([hq[other_bits[1]][1]], ancilla)
-        # self.sim[ancilla_sim].force_m(ancilla, False)
+        self._ccx_shadow(hq[single_bit], hq[other_bits[0]], [ancilla_sim, ancilla])
+        self.sim[ancilla_sim].mcx([hq[other_bits[1]][1]], ancilla)
+        self.sim[ancilla_sim].force_m(ancilla, False)
 
         samples = self.sim[ancilla_sim].measure_shots(
             [hq[other_bits[0]][1], hq[other_bits[1]][1]], shots
@@ -363,13 +373,13 @@ class QrackAceBackend:
 
         if not math.isclose(ph, -lm) and not math.isclose(abs(ph), math.pi / 2):
             # Produces/destroys superposition
-            self._correct_if_like_h(th, lq)
             self._encode_decode(lq, hq)
             b = hq[0]
             self.sim[b[0]].u(b[1], th, ph, lm)
             b = hq[2]
             self.sim[b[0]].u(b[1], th, ph, lm)
             self._encode_decode(lq, hq)
+            self._correct_if_like_h(th, lq)
         else:
             # Shouldn't produce/destroy superposition
             for b in hq:
@@ -386,9 +396,6 @@ class QrackAceBackend:
             th -= 2 * math.pi
         while th <= -math.pi:
             th += 2 * math.pi
-        if p == Pauli.PauliY:
-            self._correct_if_like_h(th, lq)
-
         if (p == Pauli.PauliZ) or math.isclose(abs(th), math.pi):
             # Doesn't produce/destroy superposition
             for b in hq:
@@ -401,6 +408,7 @@ class QrackAceBackend:
             b = hq[2]
             self.sim[b[0]].r(p, th, b[1])
             self._encode_decode(lq, hq)
+            self._correct_if_like_h(th, lq)
 
     def h(self, lq):
         hq = self._unpack(lq)
@@ -409,13 +417,13 @@ class QrackAceBackend:
             self.sim[b[0]].h(b[1])
             return
 
-        self._correct(lq)
         self._encode_decode(lq, hq)
         b = hq[0]
         self.sim[b[0]].h(b[1])
         b = hq[2]
         self.sim[b[0]].h(b[1])
         self._encode_decode(lq, hq)
+        self._correct(lq)
 
     def s(self, lq):
         hq = self._unpack(lq)
@@ -547,13 +555,10 @@ class QrackAceBackend:
                 shadow(b1, b2)
             return
 
-        self._correct(lq1)
-        self._correct(lq2)
-
         if (lq2_col in connected_cols) and (connected_cols.index(lq2_col) < boundary):
             # lq2_col < lq1_col
-            self._encode_decode(lq1, hq1)
-            self._encode_decode(lq2, hq2)
+            self._encode_decode_half(lq1, hq1, True)
+            self._encode_decode_half(lq2, hq2, False)
             b = hq1[0]
             if lq1_lr:
                 self._get_gate(pauli, anti, hq1[0][0])[0]([b[1]], hq2[2][1])
@@ -561,12 +566,12 @@ class QrackAceBackend:
                 self._get_gate(pauli, anti, hq2[0][0])[0]([b[1]], hq2[0][1])
             else:
                 self._get_gate(pauli, anti, b[0])[0]([b[1]], hq2[2][1])
-            self._encode_decode(lq2, hq2)
-            self._encode_decode(lq1, hq1)
+            self._encode_decode_half(lq2, hq2, False)
+            self._encode_decode_half(lq1, hq1, True)
         elif lq2_col in connected_cols:
             # lq1_col < lq2_col
-            self._encode_decode(lq1, hq1)
-            self._encode_decode(lq2, hq2)
+            self._encode_decode_half(lq1, hq1, False)
+            self._encode_decode_half(lq2, hq2, True)
             b = hq2[0]
             if lq1_lr:
                 self._get_gate(pauli, anti, hq1[0][0])[0]([hq1[0][1]], b[1])
@@ -574,37 +579,41 @@ class QrackAceBackend:
                 self._get_gate(pauli, anti, hq2[0][0])[0]([hq1[2][1]], b[1])
             else:
                 self._get_gate(pauli, anti, b[0])[0]([hq1[2][1]], b[1])
-            self._encode_decode(lq2, hq2)
-            self._encode_decode(lq1, hq1)
+            self._encode_decode_half(lq2, hq2, True)
+            self._encode_decode_half(lq1, hq1, False)
         elif lq1_col == lq2_col:
             # Both are in the same boundary column.
+            self._encode_decode(lq1, hq1)
+            self._encode_decode(lq2, hq2)
             b = hq1[0]
             gate, shadow = self._get_gate(pauli, anti, b[0])
             gate([b[1]], hq2[0][1])
             b = hq1[2]
             gate, shadow = self._get_gate(pauli, anti, b[0])
             gate([b[1]], hq2[2][1])
-            if hq1[1][0] != hq2[1][0]:
-                shadow(hq1[1], hq2[1])
-            else:
-                b = hq1[1]
-                gate, shadow = self._get_gate(pauli, anti, b[0])
-                gate([b[1]], hq2[1][1])
         else:
             # The qubits have no quantum connection.
             gate, shadow = self._get_gate(pauli, anti, hq1[0][0])
             if lq1_lr:
+                connected01 = (hq2[0][0] == hq2[1][0])
                 self._encode_decode(lq2, hq2)
-                shadow(hq1[0], hq2[0])
+                shadow(hq1[0], hq2[0] if connected01 else hq2[2])
                 self._encode_decode(lq2, hq2)
             elif lq2_lr:
+                connected01 = (hq1[0][0] == hq1[1][0])
                 self._encode_decode(lq1, hq1)
-                shadow(hq1[0], hq2[0])
+                shadow(hq1[0] if connected01 else hq1[2], hq2[0])
                 self._encode_decode(lq1, hq1)
             else:
+                self._encode_decode(lq1, hq1)
+                self._encode_decode(lq2, hq2)
                 shadow(hq1[0], hq2[0])
-                shadow(hq1[1], hq2[1])
                 shadow(hq1[2], hq2[2])
+                self._encode_decode(lq2, hq2)
+                self._encode_decode(lq1, hq1)
+
+        self._correct(lq1)
+        self._correct(lq2)
 
     def cx(self, lq1, lq2):
         self._cpauli(lq1, lq2, False, Pauli.PauliX)
@@ -725,16 +734,23 @@ class QrackAceBackend:
         result = 0
         # Randomize the order of measurement to amortize error.
         # However, locality of collapse matters:
-        # always measure across rows, and by row directionality.
-        rows = list(range(self.col_length))
-        random.shuffle(rows)
-        for lq_row in rows:
+        # measure in row pairs, and always across rows,
+        # and by row directionality.
+        row_pairs = list(range((self.col_length + 1) // 2))
+        random.shuffle(row_pairs)
+        for row_pair in row_pairs:
             col_offset = random.randint(0, self.row_length - 1)
-            col_reverse = self.alternating_codes and (lq_row & 1)
+            lq_row = row_pair << 1
+            for c in range(self.row_length):
+                lq_col = (c + col_offset) % self.row_length
+                lq = lq_row * self.row_length + lq_col
+                if self.m(lq):
+                    result |= 1 << lq
+            lq_row += 1
+            if lq_row == self.col_length:
+                continue
             for c in range(self.row_length):
-                lq_col = (
-                    ((self.row_length - (c + 1)) if col_reverse else c) + col_offset
-                ) % self.row_length
+                lq_col = ((self.row_length - (c + 1)) + col_offset) % self.row_length
                 lq = lq_row * self.row_length + lq_col
                 if self.m(lq):
                     result |= 1 << lq
@@ -761,7 +777,7 @@ class QrackAceBackend:
             return self.sim[b[0]].prob(b[1])
 
         self._correct(lq)
-        if not self.alternating_codes or not ((lq // self.row_length) & 1):
+        if hq[0][0] == hq[1][0]:
             other_bits = [0, 1]
         else:
             other_bits = [1, 2]
@@ -1171,21 +1187,11 @@ class QrackAceBackend:
                 continue  # No noise on long-to-long
 
             same_col = col_a == col_b
-            even_odd = (row_a % 2) != (row_b % 2)
-
-            if same_col and not even_odd:
-                continue  # No noise for even-even or odd-odd within a boundary column
 
             if same_col:
-                x_cy = 1 - (1 - x) ** 2
-                x_swap = 1 - (1 - x) ** 3
-                noise_model.add_quantum_error(depolarizing_error(x, 2), "cx", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(x_cy, 2), "cy", [a, b])
-                noise_model.add_quantum_error(depolarizing_error(x_cy, 2), "cz", [a, b])
-                noise_model.add_quantum_error(
-                    depolarizing_error(x_swap, 2), "swap", [a, b]
-                )
-            elif is_long_a or is_long_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])

{pyqrack_cuda-1.50.1 → pyqrack_cuda-1.52.0}/pyqrack/qrack_simulator.py

@@ -181,9 +181,15 @@ class QrackSimulator:
         self._throw_if_error()
 
     def set_concurrency(self, p):
+        """ Set the CPU parallel thread count"""
         Qrack.qrack_lib.set_concurrency(self.sid, p)
         self._throw_if_error()
 
+    def set_device(self, d):
+        """ Set the GPU device ID"""
+        Qrack.qrack_lib.set_device(self.sid, d)
+        self._throw_if_error()
+
     def clone(self):
         return QrackSimulator(cloneSid=self.sid)
 

{pyqrack_cuda-1.50.1 → pyqrack_cuda-1.52.0}/pyqrack/qrack_system/qrack_system.py

@@ -143,6 +143,9 @@ class QrackSystem:
         self.qrack_lib.set_concurrency.restype = None
         self.qrack_lib.set_concurrency.argtypes = [c_ulonglong, c_ulonglong]
 
+        self.qrack_lib.set_device.restype = None
+        self.qrack_lib.set_device.argtypes = [c_ulonglong, c_ulonglong]
+
         # pseudo-quantum
 
         self.qrack_lib.ProbAll.restype = None

{pyqrack_cuda-1.50.1 → pyqrack_cuda-1.52.0/pyqrack_cuda.egg-info}/PKG-INFO

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

{pyqrack_cuda-1.50.1 → pyqrack_cuda-1.52.0}/setup.py

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