pyqrackising 9.7.0__py3-none-manylinux_2_39_x86_64.whl → 9.7.1__py3-none-manylinux_2_39_x86_64.whl

pyqrackising/maxcut_tfim.py

@@ -3,7 +3,7 @@ import numpy as np
 from numba import njit, prange
 import os
 
-from .maxcut_tfim_util import compute_cut, compute_energy, convert_bool_to_uint, get_cut, get_cut_base, init_thresholds, make_G_m_buf, make_theta_buf, maxcut_hamming_cdf, opencl_context, sample_mag, setup_opencl, bit_pick
+from .maxcut_tfim_util import compute_cut, compute_energy, convert_bool_to_uint, get_cut, get_cut_base, heuristic_threshold, init_thresholds, make_G_m_buf, make_theta_buf, maxcut_hamming_cdf, opencl_context, sample_mag, setup_opencl, bit_pick
 
 IS_OPENCL_AVAILABLE = True
 try:
@@ -242,6 +242,60 @@ def run_cut_opencl(best_energy, samples, G_m_buf, is_segmented, local_size, glob
     return samples[max_index_host[best_x]], energy
 
 
+@njit
+def exact_maxcut(G):
+    """Brute-force exact MAXCUT solver using Numba JIT."""
+    n = G.shape[0]
+    max_cut = -1.0
+    best_mask = 0
+
+    # Enumerate all 2^n possible bitstrings
+    for mask in range(1 << n):
+        cut = 0.0
+        for i in range(n):
+            bi = (mask >> i) & 1
+            for j in range(i + 1, n):
+                if bi != ((mask >> j) & 1):
+                    cut += G[i, j]
+        if cut > max_cut:
+            max_cut = cut
+            best_mask = mask
+
+    # Reconstruct best bitstring
+    best_bits = np.zeros(n, dtype=np.bool_)
+    for i in range(n):
+        best_bits[i] = (best_mask >> i) & 1
+
+    return best_bits, max_cut
+
+
+@njit
+def exact_spin_glass(G):
+    """Brute-force exact spin-glass solver using Numba JIT."""
+    n = G.shape[0]
+    max_cut = -1.0
+    best_mask = 0
+
+    # Enumerate all 2^n possible bitstrings
+    for mask in range(1 << n):
+        cut = 0.0
+        for i in range(n):
+            bi = (mask >> i) & 1
+            for j in range(i + 1, n):
+                val = G[i, j]
+                cut += val if bi == ((mask >> j) & 1) else -val
+        if cut > max_cut:
+            max_cut = cut
+            best_mask = mask
+
+    # Reconstruct best bitstring
+    best_bits = np.zeros(n, dtype=np.bool_)
+    for i in range(n):
+        best_bits[i] = (best_mask >> i) & 1
+
+    return best_bits, max_cut
+
+
 def maxcut_tfim(
     G,
     quality=None,
@@ -264,22 +318,15 @@ def maxcut_tfim(
 
     n_qubits = len(G_m)
 
-    if n_qubits < 3:
-        empty = [nodes[0]]
-        empty.clear()
-
-        if n_qubits == 0:
-            return "", 0, (empty, empty.copy())
-
-        if n_qubits == 1:
-            return "0", 0, (nodes, empty)
+    if n_qubits < heuristic_threshold:
+        best_solution, best_value = exact_spin_glass(G_m) if is_spin_glass else exact_maxcut(G_m)
+        bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 
-        if n_qubits == 2:
-            weight = G_m[0, 1]
-            if weight < 0.0:
-                return "00", 0, (nodes, empty)
+        if best_value < 0.0:
+            # Best cut is trivial partition, all/empty
+            return '0' * n_qubits, 0.0, (nodes, [])
 
-            return "01", weight, ([nodes[0]], [nodes[1]])
+        return bit_string, best_value, (l, r)
 
     if quality is None:
         quality = 6

pyqrackising/maxcut_tfim_sparse.py

@@ -3,7 +3,7 @@ import numpy as np
 from numba import njit, prange
 import os
 
-from .maxcut_tfim_util import binary_search, compute_cut_sparse, compute_energy_sparse, convert_bool_to_uint, get_cut, get_cut_base, init_thresholds, make_G_m_csr_buf, make_theta_buf, maxcut_hamming_cdf, opencl_context, sample_mag, setup_opencl, bit_pick, to_scipy_sparse_upper_triangular
+from .maxcut_tfim_util import binary_search, compute_cut_sparse, compute_energy_sparse, convert_bool_to_uint, get_cut, get_cut_base, heuristic_threshold_sparse, init_thresholds, make_G_m_csr_buf, make_theta_buf, maxcut_hamming_cdf, opencl_context, sample_mag, setup_opencl, bit_pick, to_scipy_sparse_upper_triangular
 
 IS_OPENCL_AVAILABLE = True
 try:
@@ -256,6 +256,69 @@ def run_cut_opencl(best_energy, samples, G_data_buf, G_rows_buf, G_cols_buf, is_
     return samples[max_index_host[best_x]], energy
 
 
+@njit
+def exact_maxcut(G_data, G_rows, G_cols):
+    """Brute-force exact MAXCUT solver using Numba JIT."""
+    n = G_rows.shape[0] - 1
+    max_cut = -1.0
+    best_mask = 0
+
+    # Enumerate all 2^n possible bitstrings
+    for mask in range(1 << n):
+        cut = 0.0
+        for i in range(n):
+            bi = (mask >> i) & 1
+            for j in range(i + 1, n):
+                if bi != ((mask >> j) & 1):
+                    u, v = (i, j) if i < j else (j, i)
+                    start = G_rows[u]
+                    end = G_rows[u + 1]
+                    k = binary_search(G_cols[start:end], v) + start
+                    if k < end:
+                        cut += G_data[k]
+        if cut > max_cut:
+            max_cut = cut
+            best_mask = mask
+
+    # Reconstruct best bitstring
+    best_bits = np.zeros(n, dtype=np.bool_)
+    for i in range(n):
+        best_bits[i] = (best_mask >> i) & 1
+
+    return best_bits, max_cut
+
+
+@njit
+def exact_spin_glass(G_data, G_rows, G_cols):
+    """Brute-force exact spin-glass solver using Numba JIT."""
+    n = G_rows.shape[0] - 1
+    max_cut = -1.0
+    best_mask = 0
+
+    # Enumerate all 2^n possible bitstrings
+    for mask in range(1 << n):
+        cut = 0.0
+        for i in range(n):
+            bi = (mask >> i) & 1
+            for j in range(i + 1, n):
+                u, v = (i, j) if i < j else (j, i)
+                start = G_rows[u]
+                end = G_rows[u + 1]
+                k = binary_search(G_cols[start:end], v) + start
+                if k < end:
+                    val = G_data[k]
+                    cut += val if bi == ((mask >> j) & 1) else -val
+        if cut > max_cut:
+            max_cut = cut
+            best_mask = mask
+
+    # Reconstruct best bitstring
+    best_bits = np.zeros(n, dtype=np.bool_)
+    for i in range(n):
+        best_bits[i] = (best_mask >> i) & 1
+
+    return best_bits, max_cut
+
 
 def maxcut_tfim_sparse(
     G,
@@ -281,19 +344,15 @@ def maxcut_tfim_sparse(
         nodes = list(range(n_qubits))
         G_m = G
 
-    if n_qubits < 3:
-        if n_qubits == 0:
-            return "", 0, ([], [])
-
-        if n_qubits == 1:
-            return "0", 0, (nodes, [])
+    if n_qubits < heuristic_threshold_sparse:
+        best_solution, best_value = exact_spin_glass(G_m.data, G_m.indptr, G_m.indices) if is_spin_glass else exact_maxcut(G_m.data, G_m.indptr, G_m.indices)
+        bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 
-        if n_qubits == 2:
-            weight = G_m[0, 1]
-            if weight < 0.0:
-                return "00", 0, (nodes, [])
+        if best_value < 0.0:
+            # Best cut is trivial partition, all/empty
+            return '0' * n_qubits, 0.0, (nodes, [])
 
-            return "01", weight, ([nodes[0]], [nodes[1]])
+        return bit_string, best_value, (l, r)
 
     if quality is None:
         quality = 6

pyqrackising/maxcut_tfim_streaming.py

@@ -3,7 +3,7 @@ import numpy as np
 from numba import njit, prange
 import os
 
-from .maxcut_tfim_util import compute_cut_streaming, compute_energy_streaming, get_cut, get_cut_base, init_thresholds, maxcut_hamming_cdf, opencl_context, sample_mag, bit_pick
+from .maxcut_tfim_util import compute_cut_streaming, compute_energy_streaming, get_cut, get_cut_base, heuristic_threshold, init_thresholds, maxcut_hamming_cdf, opencl_context, sample_mag, bit_pick
 
 
 epsilon = opencl_context.epsilon
@@ -148,6 +148,58 @@ def find_G_min(G_func, nodes, n_nodes):
     return G_min
 
 
+@njit
+def exact_maxcut(G_func, n):
+    """Brute-force exact MAXCUT solver using Numba JIT."""
+    max_cut = -1.0
+    best_mask = 0
+
+    # Enumerate all 2^n possible bitstrings
+    for mask in range(1 << n):
+        cut = 0.0
+        for i in range(n):
+            bi = (mask >> i) & 1
+            for j in range(i + 1, n):
+                if bi != ((mask >> j) & 1):
+                    cut += G_func(i, j)
+        if cut > max_cut:
+            max_cut = cut
+            best_mask = mask
+
+    # Reconstruct best bitstring
+    best_bits = np.zeros(n, dtype=np.bool_)
+    for i in range(n):
+        best_bits[i] = (best_mask >> i) & 1
+
+    return best_bits, max_cut
+
+
+@njit
+def exact_spin_glass(G_func, n):
+    """Brute-force exact spin-glass solver using Numba JIT."""
+    max_cut = -1.0
+    best_mask = 0
+
+    # Enumerate all 2^n possible bitstrings
+    for mask in range(1 << n):
+        cut = 0.0
+        for i in range(n):
+            bi = (mask >> i) & 1
+            for j in range(i + 1, n):
+                val = G_func(i, j)
+                cut += val if bi == ((mask >> j) & 1) else -val
+        if cut > max_cut:
+            max_cut = cut
+            best_mask = mask
+
+    # Reconstruct best bitstring
+    best_bits = np.zeros(n, dtype=np.bool_)
+    for i in range(n):
+        best_bits[i] = (best_mask >> i) & 1
+
+    return best_bits, max_cut
+
+
 def maxcut_tfim_streaming(
     G_func,
     nodes,
@@ -161,19 +213,15 @@ def maxcut_tfim_streaming(
     wgs = opencl_context.work_group_size
     n_qubits = len(nodes)
 
-    if n_qubits < 3:
-        if n_qubits == 0:
-            return "", 0, ([], [])
-
-        if n_qubits == 1:
-            return "0", 0, (nodes, [])
+    if n_qubits < heuristic_threshold:
+        best_solution, best_value = exact_spin_glass(G_func, n_qubits) if is_spin_glass else exact_maxcut(G_func, n_qubits)
+        bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 
-        if n_qubits == 2:
-            weight = G_func(nodes[0], nodes[1])
-            if weight < 0.0:
-                return "00", 0, (nodes, [])
+        if best_value < 0.0:
+            # Best cut is trivial partition, all/empty
+            return '0' * n_qubits, 0.0, (nodes, [])
 
-            return "01", weight, ([nodes[0]], [nodes[1]])
+        return bit_string, best_value, (l, r)
 
     if quality is None:
         quality = 6

pyqrackising/maxcut_tfim_util.py

@@ -121,6 +121,8 @@ except ImportError:
     print("PyOpenCL not installed. (If you have any OpenCL accelerator devices with available ICDs, you might want to optionally install pyopencl.)")
 
 opencl_context = OpenCLContext(compute_units, IS_OPENCL_AVAILABLE, work_group_size, dtype, epsilon, max_alloc, ctx, queue, calculate_cut_kernel, calculate_cut_sparse_kernel, calculate_cut_segmented_kernel, calculate_cut_sparse_segmented_kernel, single_bit_flips_kernel, single_bit_flips_sparse_kernel, single_bit_flips_segmented_kernel, single_bit_flips_sparse_segmented_kernel, double_bit_flips_kernel, double_bit_flips_sparse_kernel, double_bit_flips_segmented_kernel, double_bit_flips_sparse_segmented_kernel)
+heuristic_threshold = 24
+heuristic_threshold_sparse = 23
 
 
 def setup_opencl(l, g, args_np):

pyqrackising/spin_glass_solver.py

@@ -1,5 +1,5 @@
 from .maxcut_tfim import maxcut_tfim
-from .maxcut_tfim_util import compute_cut, compute_energy, get_cut, gray_code_next, gray_mutation, int_to_bitstring, make_G_m_buf, make_best_theta_buf, opencl_context, setup_opencl
+from .maxcut_tfim_util import compute_cut, compute_energy, get_cut, gray_code_next, gray_mutation, heuristic_threshold, int_to_bitstring, make_G_m_buf, make_best_theta_buf, opencl_context, setup_opencl
 import networkx as nx
 import numpy as np
 from numba import njit, prange
@@ -296,6 +296,9 @@ def spin_glass_solver(
 
             return "01", weight, ([nodes[0]], [nodes[1]]), -weight
 
+    if n_qubits < heuristic_threshold:
+        best_guess = None
+
     bitstring = ""
     if isinstance(best_guess, str):
         bitstring = best_guess
@@ -305,7 +308,20 @@ def spin_glass_solver(
         bitstring = "".join(["1" if b else "0" for b in best_guess])
     else:
         bitstring, cut_value, _ = maxcut_tfim(G_m, quality=quality, shots=shots, is_spin_glass=is_spin_glass, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base, is_maxcut_gpu=is_maxcut_gpu, is_nested=True)
+
     best_theta = np.array([b == "1" for b in list(bitstring)], dtype=np.bool_)
+    max_energy = compute_energy(best_theta, G_m, n_qubits) if is_spin_glass else cut_value
+
+    if n_qubits < heuristic_threshold:
+        bitstring, l, r = get_cut(best_theta, nodes, n_qubits)
+        if is_spin_glass:
+            cut_value = compute_cut(best_theta, G_m, n_qubits)
+            min_energy = -max_energy
+        else:
+            cut_value = max_energy
+            min_energy = compute_energy(best_theta, G_m, n_qubits)
+
+        return bitstring, float(cut_value), (l, r), float(min_energy)
 
     if gray_iterations is None:
         gray_iterations = n_qubits * n_qubits
@@ -313,8 +329,6 @@ def spin_glass_solver(
     if gray_seed_multiple is None:
         gray_seed_multiple = os.cpu_count()
 
-    max_energy = compute_energy(best_theta, G_m, n_qubits) if is_spin_glass else cut_value
-
     is_opencl = is_maxcut_gpu and IS_OPENCL_AVAILABLE
 
     if is_opencl:

pyqrackising/spin_glass_solver_sparse.py

@@ -1,5 +1,5 @@
 from .maxcut_tfim_sparse import maxcut_tfim_sparse
-from .maxcut_tfim_util import compute_cut_sparse, compute_energy_sparse, get_cut, gray_code_next, gray_mutation, int_to_bitstring, make_G_m_csr_buf, make_best_theta_buf, opencl_context, setup_opencl, to_scipy_sparse_upper_triangular
+from .maxcut_tfim_util import compute_cut_sparse, compute_energy_sparse, get_cut, gray_code_next, gray_mutation, heuristic_threshold_sparse, int_to_bitstring, make_G_m_csr_buf, make_best_theta_buf, opencl_context, setup_opencl, to_scipy_sparse_upper_triangular
 import networkx as nx
 import numpy as np
 from numba import njit, prange
@@ -300,6 +300,9 @@ def spin_glass_solver_sparse(
 
             return "01", weight, ([nodes[0]], [nodes[1]]), -weight
 
+    if n_qubits < heuristic_threshold_sparse:
+        best_guess = None
+
     bitstring = ""
     if isinstance(best_guess, str):
         bitstring = best_guess
@@ -309,7 +312,20 @@ def spin_glass_solver_sparse(
         bitstring = "".join(["1" if b else "0" for b in best_guess])
     else:
         bitstring, cut_value, _ = maxcut_tfim_sparse(G_m, quality=quality, shots=shots, is_spin_glass=is_spin_glass, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base, is_maxcut_gpu=is_maxcut_gpu, is_nested=True)
+
     best_theta = np.array([b == "1" for b in list(bitstring)], dtype=np.bool_)
+    max_energy = compute_energy(best_theta, G_m, n_qubits) if is_spin_glass else cut_value
+
+    if n_qubits < heuristic_threshold_sparse:
+        bitstring, l, r = get_cut(best_theta, nodes, n_qubits)
+        if is_spin_glass:
+            cut_value = compute_cut_sparse(best_theta, G_m.data, G_m.indptr, G_m.indices, n_qubits)
+            min_energy = -max_energy
+        else:
+            cut_value = max_energy
+            min_energy = compute_energy_sparse(best_theta, G_m.data, G_m.indptr, G_m.indices, n_qubits)
+
+        return bitstring, float(cut_value), (l, r), float(min_energy)
 
     if gray_iterations is None:
         gray_iterations = n_qubits * n_qubits
@@ -317,8 +333,6 @@ def spin_glass_solver_sparse(
     if gray_seed_multiple is None:
         gray_seed_multiple = os.cpu_count()
 
-    max_energy = compute_energy_sparse(best_theta, G_m.data, G_m.indptr, G_m.indices, n_qubits) if is_spin_glass else cut_value
-
     is_opencl = is_maxcut_gpu and IS_OPENCL_AVAILABLE
 
     if is_opencl:

pyqrackising/spin_glass_solver_streaming.py

@@ -1,5 +1,5 @@
 from .maxcut_tfim_streaming import maxcut_tfim_streaming
-from .maxcut_tfim_util import compute_cut_streaming, compute_energy_streaming, get_cut, get_cut_base, gray_code_next, gray_mutation, int_to_bitstring, opencl_context
+from .maxcut_tfim_util import compute_cut_streaming, compute_energy_streaming, get_cut, get_cut_base, gray_code_next, gray_mutation, heuristic_threshold, int_to_bitstring, opencl_context
 import networkx as nx
 import numpy as np
 from numba import njit, prange
@@ -207,6 +207,9 @@ def spin_glass_solver_streaming(
 
             return "01", weight, ([nodes[0]], [nodes[1]]), -weight
 
+    if n_qubits < heuristic_threshold:
+        best_guess = None
+
     bitstring = ""
     if isinstance(best_guess, str):
         bitstring = best_guess
@@ -216,7 +219,20 @@ def spin_glass_solver_streaming(
         bitstring = "".join(["1" if b else "0" for b in best_guess])
     else:
         bitstring, cut_value, _ = maxcut_tfim_streaming(G_func, nodes, quality=quality, shots=shots, is_spin_glass=is_spin_glass, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base)
+
     best_theta = np.array([b == "1" for b in list(bitstring)], dtype=np.bool_)
+    max_energy = compute_energy(best_theta, G_m, n_qubits) if is_spin_glass else cut_value
+
+    if n_qubits < heuristic_threshold:
+        bitstring, l, r = get_cut(best_theta, nodes, n_qubits)
+        if is_spin_glass:
+            cut_value = compute_cut_streaming(best_theta, G_func, nodes, n_qubits)
+            min_energy = -max_energy
+        else:
+            cut_value = max_energy
+            min_energy = compute_energy_streaming(best_theta, G_func, nodes, n_qubits)
+
+        return bitstring, float(cut_value), (l, r), float(min_energy)
 
     if gray_iterations is None:
         gray_iterations = n_qubits * n_qubits
@@ -224,8 +240,6 @@ def spin_glass_solver_streaming(
     if gray_seed_multiple is None:
         gray_seed_multiple = os.cpu_count()
 
-    max_energy = compute_energy_streaming(best_theta, G_func, nodes, n_qubits) if is_spin_glass else cut_value
-
     thread_count = os.cpu_count() ** 2
     improved = True
     while improved:

{pyqrackising-9.7.0.dist-info → pyqrackising-9.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.7.0
+Version: 9.7.1
 Summary: Fast MAXCUT, TSP, and sampling heuristics from near-ideal transverse field Ising model (TFIM)
 Home-page: https://github.com/vm6502q/PyQrackIsing
 Author: Dan Strano

pyqrackising-9.7.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+pyqrackising/__init__.py,sha256=Q-fHQRApRseeFnnO6VfD1LpjPHCVkWoz0Gnaqmv6lp0,884
+pyqrackising/convert_tensor_network_to_tsp.py,sha256=IbZdPfHQ2bzYqDXUdHfwdZJh-pC8lri_cAgESaskQWI,3450
+pyqrackising/generate_tfim_samples.py,sha256=IlAz1l8oLExO6wJBO8LCQKlU_4ZPlyGsNE8xUt_iTrg,4762
+pyqrackising/kernels.cl,sha256=Q9LZ1oBOZ2A_VsQ8uRUGQKNVpzqVXYwhG6c27FO6ljI,27004
+pyqrackising/maxcut_tfim.py,sha256=a2gbK_WypOQz8JTbMSXAtG5h-poumSTUNjK1jfNAF_c,11586
+pyqrackising/maxcut_tfim_sparse.py,sha256=26Rv5yt_LC9OJRobCtOvEFgNphRfof9rduG7XoPehmQ,13361
+pyqrackising/maxcut_tfim_streaming.py,sha256=ne0NH8_I6S9iYE6315UUCMlOtQyYuSJOjckRTIfkHH0,7893
+pyqrackising/maxcut_tfim_util.py,sha256=I2iRXrrEr_YXKcmVlez8ZMwhmIQH3TegdepyM19J0CU,17062
+pyqrackising/otoc.py,sha256=PKmpjwkGpMmwXGWmeqtvbVj1NfE35i9kkIdjQnDUZKE,7208
+pyqrackising/spin_glass_solver.py,sha256=4CP4dTdxl2itZ9Iogth91LJY3DLVV9aXiVNpIYRgbxA,14289
+pyqrackising/spin_glass_solver_sparse.py,sha256=p8w2it4reeqMRDoHvd7CeLkyV872oW1sUiIayEAM0ek,15295
+pyqrackising/spin_glass_solver_streaming.py,sha256=pjn-XFPM4-rMEHVDzZHXzxK_c6tBmXzAVaVH6ujhFY0,10535
+pyqrackising/tfim_magnetization.py,sha256=On1MhCNGGHRxJFRmCOpMcdqQJiy25gWkjz0Ka8i5f-Q,499
+pyqrackising/tfim_square_magnetization.py,sha256=9uJCT8ytyufcGFrZiignjCkWJr9UcP44sAAy0BIBw34,531
+pyqrackising/tsp.py,sha256=kqDxU2RCjad-T4tW_C9WO1I-COSwX7fHB6VhIuQsjfQ,62464
+pyqrackising/tsp_maxcut.py,sha256=ngxfSJgePXVwJXfNXYdk4jv1ISznx8zHOqR-Vbf33B0,9772
+pyqrackising-9.7.1.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+pyqrackising-9.7.1.dist-info/METADATA,sha256=0hLsFLy5aO3y7j-S1qwCTn6GxKTl-v95V3oOClgn71I,1143
+pyqrackising-9.7.1.dist-info/WHEEL,sha256=k8EuOMBHdXsN9XSTE5LrpwS4FtdLkoSlyO_7W-lE_zg,109
+pyqrackising-9.7.1.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
+pyqrackising-9.7.1.dist-info/RECORD,,

pyqrackising-9.7.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-pyqrackising/__init__.py,sha256=Q-fHQRApRseeFnnO6VfD1LpjPHCVkWoz0Gnaqmv6lp0,884
-pyqrackising/convert_tensor_network_to_tsp.py,sha256=IbZdPfHQ2bzYqDXUdHfwdZJh-pC8lri_cAgESaskQWI,3450
-pyqrackising/generate_tfim_samples.py,sha256=IlAz1l8oLExO6wJBO8LCQKlU_4ZPlyGsNE8xUt_iTrg,4762
-pyqrackising/kernels.cl,sha256=Q9LZ1oBOZ2A_VsQ8uRUGQKNVpzqVXYwhG6c27FO6ljI,27004
-pyqrackising/maxcut_tfim.py,sha256=uqC7Ryw1ikehGfG4OFV7rHojWlx5u8wL2l8yxsmNkWY,10170
-pyqrackising/maxcut_tfim_sparse.py,sha256=YyenDVmXR46Pf9LClvpNEWjziToE6U7WOy68mKseTkk,11269
-pyqrackising/maxcut_tfim_streaming.py,sha256=7vPKulDRcQ-YvPacCNT11Ba-CXhBYggjpu_aDMov6NE,6410
-pyqrackising/maxcut_tfim_util.py,sha256=Ye8kNEunHQLdbTdyT8hTFlsRy0f3QCnKUDIwZXAm0rM,17003
-pyqrackising/otoc.py,sha256=PKmpjwkGpMmwXGWmeqtvbVj1NfE35i9kkIdjQnDUZKE,7208
-pyqrackising/spin_glass_solver.py,sha256=-hQAyTCRpadYhH4E8cT9kBFK9vdSDNK22XESXGSnfjc,13786
-pyqrackising/spin_glass_solver_sparse.py,sha256=F07Y92FCaUJHX1h1ydTFp6HjWLgo_A2buPErIvtYM7g,14734
-pyqrackising/spin_glass_solver_streaming.py,sha256=dDl7VYeu7BkJlLHTCCovaT3z6-Zx4RGwTVcNGzwxTXY,10012
-pyqrackising/tfim_magnetization.py,sha256=On1MhCNGGHRxJFRmCOpMcdqQJiy25gWkjz0Ka8i5f-Q,499
-pyqrackising/tfim_square_magnetization.py,sha256=9uJCT8ytyufcGFrZiignjCkWJr9UcP44sAAy0BIBw34,531
-pyqrackising/tsp.py,sha256=kqDxU2RCjad-T4tW_C9WO1I-COSwX7fHB6VhIuQsjfQ,62464
-pyqrackising/tsp_maxcut.py,sha256=ngxfSJgePXVwJXfNXYdk4jv1ISznx8zHOqR-Vbf33B0,9772
-pyqrackising-9.7.0.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-pyqrackising-9.7.0.dist-info/METADATA,sha256=OWfrA57TEpL09F0zzFdKL5UmCBTvihkTGF739CIUFcU,1143
-pyqrackising-9.7.0.dist-info/WHEEL,sha256=k8EuOMBHdXsN9XSTE5LrpwS4FtdLkoSlyO_7W-lE_zg,109
-pyqrackising-9.7.0.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
-pyqrackising-9.7.0.dist-info/RECORD,,