pyqrackising 9.5.3__py3-none-win_amd64.whl → 9.7.1__py3-none-win_amd64.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, 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:
@@ -22,6 +22,9 @@ def update_repulsion_choice(G_m, weights, n, used, node, repulsion_base):
     # Select node
     used[node] = True
 
+    if abs(1.0 - repulsion_base) <= epsilon:
+        return
+
     # Repulsion: penalize neighbors
     for nbr in range(n):
         if used[nbr]:
@@ -177,21 +180,6 @@ def init_J_and_z(G_m, repulsion_base):
     return J_eff, degrees
 
 
-@njit
-def cpu_footer(shots, thread_count, quality, n_qubits, G_m, nodes, is_spin_glass, anneal_t, anneal_h, repulsion_base):
-    J_eff, degrees = init_J_and_z(G_m, repulsion_base)
-    hamming_prob = maxcut_hamming_cdf(n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
-
-    degrees = None
-    J_eff = None
-
-    best_solution, best_value = sample_measurement(G_m, shots, thread_count, hamming_prob, repulsion_base, is_spin_glass)
-
-    bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
-
-    return bit_string, best_value, (l, r)
-
-
 def run_cut_opencl(best_energy, samples, G_m_buf, is_segmented, local_size, global_size, args_buf, local_energy_buf, local_index_buf, max_energy_host, max_index_host, max_energy_buf, max_index_buf):
     queue = opencl_context.queue
     calculate_cut_kernel = opencl_context.calculate_cut_segmented_kernel if is_segmented else opencl_context.calculate_cut_kernel
@@ -253,6 +241,61 @@ 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,
@@ -275,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
@@ -308,31 +344,21 @@ def maxcut_tfim(
     if repulsion_base is None:
         repulsion_base = 5.0
 
-    is_opencl = is_maxcut_gpu and IS_OPENCL_AVAILABLE
-
-    if not is_opencl:
-        thread_count = os.cpu_count() ** 2
-
-        bit_string, best_value, partition = cpu_footer(shots, thread_count, quality, n_qubits, G_m, nodes, is_spin_glass, anneal_t, anneal_h, repulsion_base)
-
-        if best_value < 0.0:
-            # Best cut is trivial partition, all/empty
-            return '0' * n_qubits, 0.0, (nodes, [])
-
-        return bit_string, best_value, partition
-
-    segment_size = (G_m.shape[0] * G_m.shape[1] + 3) >> 2
-    theta_segment_size = (((n_qubits + 31) >> 5) * (((shots + wgs - 1) // wgs) * wgs) + 3) >> 2
-    is_segmented = ((G_m.nbytes << 1) > opencl_context.max_alloc) or ((theta_segment_size << 3) > opencl_context.max_alloc)
-    G_m_buf = make_G_m_buf(G_m, is_segmented, segment_size)
-
     J_eff, degrees = init_J_and_z(G_m, repulsion_base)
-    hamming_prob = maxcut_hamming_cdf(n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
+    cum_prob = maxcut_hamming_cdf(init_thresholds(n_qubits), n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
 
     degrees = None
     J_eff = None
 
-    best_solution, best_value = sample_for_opencl(G_m, G_m_buf, shots, hamming_prob, repulsion_base, is_spin_glass, is_segmented, segment_size, theta_segment_size)
+    if is_maxcut_gpu and IS_OPENCL_AVAILABLE:
+        segment_size = (G_m.shape[0] * G_m.shape[1] + 3) >> 2
+        theta_segment_size = (((n_qubits + 31) >> 5) * (((shots + wgs - 1) // wgs) * wgs) + 3) >> 2
+        is_segmented = ((G_m.nbytes << 1) > opencl_context.max_alloc) or ((theta_segment_size << 3) > opencl_context.max_alloc)
+        G_m_buf = make_G_m_buf(G_m, is_segmented, segment_size)
+        best_solution, best_value = sample_for_opencl(G_m, G_m_buf, shots, cum_prob, repulsion_base, is_spin_glass, is_segmented, segment_size, theta_segment_size)
+    else:
+        thread_count = os.cpu_count() ** 2
+        best_solution, best_value = sample_measurement(G_m, shots, thread_count, cum_prob, repulsion_base, is_spin_glass)
 
     bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 

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, 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:
@@ -22,6 +22,9 @@ def update_repulsion_choice(G_data, G_rows, G_cols, weights, n, used, node, repu
     # Select node
     used[node] = True
 
+    if abs(1.0 - repulsion_base) <= epsilon:
+        return
+
     # Repulsion: penalize neighbors
     for j in range(G_rows[node], G_rows[node + 1]):
         nbr = G_cols[j]
@@ -187,17 +190,6 @@ def init_J_and_z(G_m, repulsion_base):
     return J_eff, degrees
 
 
-@njit
-def cpu_footer(J_eff, degrees, shots, thread_count, quality, n_qubits, G_data, G_rows, G_cols, nodes, is_spin_glass, anneal_t, anneal_h, repulsion_base):
-    hamming_prob = maxcut_hamming_cdf(n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
-
-    best_solution, best_value = sample_measurement(G_data, G_rows, G_cols, shots, thread_count, hamming_prob, repulsion_base, is_spin_glass)
-
-    bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
-
-    return bit_string, best_value, (l, r)
-
-
 def run_cut_opencl(best_energy, samples, G_data_buf, G_rows_buf, G_cols_buf, is_segmented, local_size, global_size, args_buf, local_energy_buf, local_index_buf, max_energy_host, max_index_host, max_energy_buf, max_index_buf):
     queue = opencl_context.queue
     calculate_cut_kernel = opencl_context.calculate_cut_sparse_segmented_kernel if is_segmented else opencl_context.calculate_cut_sparse_kernel
@@ -264,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,
@@ -289,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 < 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 == 1:
-            return "0", 0, (nodes, [])
-
-        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
@@ -319,35 +370,23 @@ def maxcut_tfim_sparse(
     if repulsion_base is None:
         repulsion_base = 5.0
 
-    J_eff, degrees = init_J_and_z(G_m, repulsion_base)
-
     n_qubits = G_m.shape[0]
 
-    is_opencl = is_maxcut_gpu and IS_OPENCL_AVAILABLE
-
-    if not is_opencl:
-        thread_count = os.cpu_count() ** 2
-
-        bit_string, best_value, partition = cpu_footer(J_eff, degrees, shots, thread_count, quality, n_qubits, G_m.data, G_m.indptr, G_m.indices, nodes, is_spin_glass, anneal_t, anneal_h, repulsion_base)
-
-        if best_value < 0.0:
-            # Best cut is trivial partition, all/empty
-            return '0' * n_qubits, 0.0, (nodes, [])
-
-        return bit_string, best_value, partition
-
-    segment_size = (G_m.data.shape[0] + 3) >> 2
-    theta_segment_size = (((n_qubits + 31) >> 5) * (((shots + wgs - 1) // wgs) * wgs) + 3) >> 2
-    is_segmented = (G_m.data.nbytes << 1) > opencl_context.max_alloc or ((theta_segment_size << 3) > opencl_context.max_alloc)
-
-    G_data_buf, G_rows_buf, G_cols_buf = make_G_m_csr_buf(G_m, is_segmented, segment_size)
-
-    hamming_prob = maxcut_hamming_cdf(n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
+    J_eff, degrees = init_J_and_z(G_m, repulsion_base)
+    cum_prob = maxcut_hamming_cdf(init_thresholds(n_qubits), n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
 
     degrees = None
     J_eff = None
 
-    best_solution, best_value = sample_for_opencl(G_m.data, G_m.indptr, G_m.indices, G_data_buf, G_rows_buf, G_cols_buf, shots, hamming_prob, repulsion_base, is_spin_glass, is_segmented, segment_size, theta_segment_size)
+    if is_maxcut_gpu and IS_OPENCL_AVAILABLE:
+        segment_size = (G_m.data.shape[0] + 3) >> 2
+        theta_segment_size = (((n_qubits + 31) >> 5) * (((shots + wgs - 1) // wgs) * wgs) + 3) >> 2
+        is_segmented = (G_m.data.nbytes << 1) > opencl_context.max_alloc or ((theta_segment_size << 3) > opencl_context.max_alloc)
+        G_data_buf, G_rows_buf, G_cols_buf = make_G_m_csr_buf(G_m, is_segmented, segment_size)
+        best_solution, best_value = sample_for_opencl(G_m.data, G_m.indptr, G_m.indices, G_data_buf, G_rows_buf, G_cols_buf, shots, cum_prob, repulsion_base, is_spin_glass, is_segmented, segment_size, theta_segment_size)
+    else:
+        thread_count = os.cpu_count() ** 2
+        best_solution, best_value = sample_measurement(G_m.data, G_m.indptr, G_m.indices, shots, thread_count, cum_prob, repulsion_base, is_spin_glass)
 
     bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 

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, 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
@@ -15,6 +15,9 @@ def update_repulsion_choice(G_func, nodes, weights, n, used, node, repulsion_bas
     # Select node
     used[node] = True
 
+    if abs(1.0 - repulsion_base) <= epsilon:
+        return
+
     # Repulsion: penalize neighbors
     for nbr in range(n):
         if used[nbr]:
@@ -146,18 +149,55 @@ def find_G_min(G_func, nodes, n_nodes):
 
 
 @njit
-def cpu_footer(shots, thread_count, quality, n_qubits, G_min, G_func, nodes, is_spin_glass, anneal_t, anneal_h, repulsion_base):
-    J_eff, degrees = init_J_and_z(G_func, nodes, G_min, repulsion_base)
-    hamming_prob = maxcut_hamming_cdf(n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
-
-    degrees = None
-    J_eff = None
+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
 
-    best_solution, best_value = sample_measurement(G_func, nodes, shots, thread_count, hamming_prob, n_qubits, repulsion_base, is_spin_glass)
 
-    bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
-
-    return bit_string, best_value, (l, r)
+@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(
@@ -173,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 < 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 == 1:
-            return "0", 0, (nodes, [])
+        if best_value < 0.0:
+            # Best cut is trivial partition, all/empty
+            return '0' * n_qubits, 0.0, (nodes, [])
 
-        if n_qubits == 2:
-            weight = G_func(nodes[0], nodes[1])
-            if weight < 0.0:
-                return "00", 0, (nodes, [])
-
-            return "01", weight, ([nodes[0]], [nodes[1]])
+        return bit_string, best_value, (l, r)
 
     if quality is None:
         quality = 6
@@ -207,10 +243,18 @@ def maxcut_tfim_streaming(
 
     thread_count = os.cpu_count() ** 2
 
-    bit_string, best_value, partition = cpu_footer(shots, thread_count, quality, n_qubits, G_min, G_func, nodes, is_spin_glass, anneal_t, anneal_h, repulsion_base)
+    J_eff, degrees = init_J_and_z(G_func, nodes, G_min, repulsion_base)
+    cum_prob = maxcut_hamming_cdf(init_thresholds(n_qubits), n_qubits, J_eff, degrees, quality, anneal_t, anneal_h)
+
+    degrees = None
+    J_eff = None
+
+    best_solution, best_value = sample_measurement(G_func, nodes, shots, thread_count, cum_prob, n_qubits, repulsion_base, is_spin_glass)
+
+    bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 
     if best_value < 0.0:
         # Best cut is trivial partition, all/empty
         return '0' * n_qubits, 0.0, (nodes, [])
 
-    return bit_string, best_value, partition
+    return bit_string, best_value, (l, r)

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):
@@ -389,58 +391,22 @@ def init_theta(h_mult, n_qubits, J_eff, degrees):
     return theta
 
 
-# From Google Search AI
-@njit
-def factorial(num):
-    """Calculates the factorial of a non-negative integer."""
-    if num == 0:
-        return 1
-
-    result = 1
-    for i in range(1, num + 1):
-        result *= i
-
-    return result
-
-
-# From Google Search AI
-@njit
-def comb(n, k):
-    """
-    Calculates the number of combinations (n choose k) from scratch.
-    n: The total number of items.
-    k: The number of items to choose.
-    """
-    # Optimize by choosing the smaller of k and (n-k)
-    # This reduces the number of multiplications in the factorial calculation
-    k = min(k, n - k)
-
-    # Calculate the numerator: n * (n-1) * ... * (n-k+1)
-    numerator = 1
-    for i in range(k):
-        numerator *= (n - i)
-
-    # Calculate the denominator: k!
-    denominator = factorial(k)
-
-    return numerator // denominator
-
-
-@njit
 def init_thresholds(n_qubits):
-    n_bias = n_qubits - 1
+    n_bias = n_qubits + 1
     thresholds = np.empty(n_bias, dtype=np.float64)
-    tot_prob = 0
-    p = n_qubits
-    for q in range(1, n_qubits // 2):
-        thresholds[q - 1] = p
-        thresholds[n_bias - q] = p
-        tot_prob += 2 * p
-        p = comb(n_qubits, q + 1)
+    normalizer = 0
+    for q in range(n_qubits >> 1):
+        normalizer += math.comb(n_qubits, q) << 1
     if n_qubits & 1:
-        thresholds[q - 1] = p
-        tot_prob += p
-    thresholds /= tot_prob
+        normalizer += math.comb(n_qubits, n_qubits >> 1)
+    p = 1
+    for q in range(n_qubits >> 1):
+        val = p / normalizer
+        thresholds[q] = val
+        thresholds[n_bias - (q + 1)] = val
+        p = math.comb(n_qubits, q + 1)
+    if n_qubits & 1:
+        thresholds[n_qubits >> 1] = p / normalizer
 
     return thresholds
 
@@ -476,17 +442,15 @@ def probability_by_hamming_weight(J, h, z, theta, t, n_bias, normalized=True):
     return bias
 
 
-@njit(parallel=True)
-def maxcut_hamming_cdf(n_qubits, J_func, degrees, quality, tot_t, h_mult):
-    hamming_prob = init_thresholds(n_qubits)
-
+@njit
+def maxcut_hamming_cdf(hamming_prob, n_qubits, J_func, degrees, quality, tot_t, h_mult):
     n_steps = 1 << quality
     delta_t = tot_t / n_steps
     n_bias = n_qubits + 1
 
     theta = init_theta(h_mult, n_qubits, J_func, degrees)
 
-    for qc in prange(n_qubits, n_steps * n_qubits):
+    for qc in range(n_qubits, n_steps * n_qubits):
         step = qc // n_qubits
         q = qc % n_qubits
         J_eff = J_func[q]

pyqrackising/otoc.py

@@ -15,54 +15,60 @@ def get_otoc_hamming_distribution(J=-1.0, h=2.0, z=4, theta=0.0, t=5, n_qubits=6
         bias[0] = 1.0
         return bias
 
-    max_entropy = np.empty(n_bias, dtype=np.float64)
+    diff_x = np.empty(n_bias, dtype=np.float64)
     tot_prob = 0
     p = 1.0
-    for q in range(n_qubits // 2):
-        max_entropy[q] = p
-        max_entropy[n_bias - (q + 1)] = p
+    for q in range(n_qubits >> 1):
+        diff_x[q] = p
+        diff_x[n_bias - (q + 1)] = p
         tot_prob += 2 * p
         p = math.comb(n_qubits, q + 1)
     if n_qubits & 1:
-        max_entropy[q - 1] = p
+        diff_x[n_qubits >> 1] = p
         tot_prob += p
-    max_entropy /= tot_prob
+    diff_x *= n_qubits / tot_prob
 
+    signal_frac = 0.0
     diff_z = np.zeros(n_bias, dtype=np.float64)
+    diff_z[0] = n_qubits
     for pauli_string in pauli_strings:
         pauli_string = list(pauli_string)
         if len(pauli_string) != n_qubits:
             raise ValueError("OTOCS pauli_string must be same length as n_qubits! (Use 'I' for qubits that aren't changed.)")
 
+        term_signal = 0.5 * pauli_string.count('X') + pauli_string.count('Z') + 1.5 * pauli_string.count('Y')
+        if term_signal == 0:
+            continue
+
+        signal_frac -= term_signal
+
         fwd = probability_by_hamming_weight(J, h, z, theta, t, n_qubits + 1)
         rev = probability_by_hamming_weight(-J, -h, z, theta + np.pi, t, n_qubits + 1)
         diff_theta = rev - fwd
 
         phi = theta + np.pi / 2
         fwd = probability_by_hamming_weight(-h, -J, z, phi, t, n_qubits + 1)
-        rev = probability_by_hamming_weight(h, J, z, phi + np.pi, t, n_qubits + 1)
+        rev = probability_by_hamming_weight(h, J, z, phi - np.pi, t, n_qubits + 1)
         diff_phi = rev - fwd
 
-        diff_lam = diff_theta + diff_phi
-
-        diff_theta[0] += 1.0
-        diff_phi[0] += 1.0
-        diff_lam[0] += 1.0
-
-        diff_theta += max_entropy
-        diff_phi += max_entropy
-        diff_lam += max_entropy
-
         for b in pauli_string:
             match b:
                 case 'X':
                     diff_z += diff_theta
                 case 'Z':
-                    diff_z += diff_phi
+                    diff_x += diff_phi
                 case 'Y':
-                    diff_z += diff_lam
+                    diff_z += diff_theta
+                    diff_x += diff_phi
                 case _:
-                    diff_z[0] += 1.0
+                    pass
+
+    # Normalize:
+    diff_z /= diff_z.sum()
+    diff_x /= diff_x.sum()
+
+    signal_frac = 2 ** signal_frac
+    diff_z = signal_frac * diff_z + (1 - signal_frac) * diff_x
 
     # Normalize:
     diff_z /= diff_z.sum()
@@ -133,24 +139,24 @@ def take_sample(n_qubits, sample, m, inv_dist):
     return sample
 
 
-def get_willow_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len):
+def get_willow_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len, t):
     inv_dist = np.zeros(n_qubits, dtype=np.float64)
     for idx in butterfly_idx_x:
         b_row, b_col = divmod(idx, row_len)
         for q in range(n_qubits):
             q_row, q_col = divmod(q, row_len)
-            inv_dist[q] -= abs(q_row - b_row) + abs(q_col - b_col)
+            inv_dist[q] += abs(q_row - b_row) + abs(q_col - b_col)
     for idx in butterfly_idx_z:
         b_row, b_col = divmod(idx, row_len)
         for q in range(n_qubits):
             q_row, q_col = divmod(q, row_len)
-            inv_dist[q] += abs(q_row - b_row) + abs(q_col - b_col)
-    inv_dist += 1.0 - inv_dist.min()
+            inv_dist[q] -= abs(q_row - b_row) + abs(q_col - b_col)
+    inv_dist = 2 ** (inv_dist / t)
 
     return inv_dist
 
 
-def get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len):
+def get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len, t):
     inv_dist = np.zeros(n_qubits, dtype=np.float64)
     half_row = row_len >> 1
     half_col = col_len >> 1
@@ -164,7 +170,7 @@ def get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len):
             col_d = abs(q_col - b_col)
             if col_d > half_col:
                 col_d = col_len - col_d
-            inv_dist[q] -= row_d + col_d
+            inv_dist[q] += row_d + col_d
     for idx in butterfly_idx_z:
         b_row, b_col = divmod(idx, row_len)
         for q in range(n_qubits):
@@ -175,8 +181,8 @@ def get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len):
             col_d = abs(q_col - b_col)
             if col_d > half_col:
                 col_d = col_len - col_d
-            inv_dist[q] += row_d + col_d
-    inv_dist += 1.0 - inv_dist.min()
+            inv_dist[q] -= row_d + col_d
+    inv_dist = 2 ** (inv_dist / t)
 
     return inv_dist
 
@@ -184,21 +190,17 @@ def get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len):
 def generate_otoc_samples(J=-1.0, h=2.0, z=4, theta=0.0, t=5, n_qubits=65, pauli_strings = ['X' + 'I' * 64], shots=100, is_orbifold=True):
     thresholds = fix_cdf(get_otoc_hamming_distribution(J, h, z, theta, t, n_qubits, pauli_strings))
 
-    entropy_frac = 0.0
-    for pauli_string in pauli_strings:
-        pauli_string = list(pauli_string)
-        entropy_frac += pauli_string.count('X') + pauli_string.count('Y') + pauli_string.count('Z')
-    entropy_frac /= n_qubits * len(pauli_strings)
-
     row_len, col_len = factor_width(n_qubits)
     inv_dist = np.zeros(n_qubits, dtype=np.float64)
     for pauli_string in pauli_strings:
+        if (pauli_string.count('X') + pauli_string.count('Y') + pauli_string.count('Z')) == 0:
+            continue
         butterfly_idx_x = find_all_str_occurrences(pauli_string, 'X')
         butterfly_idx_z = find_all_str_occurrences(pauli_string, 'Z')
         if is_orbifold:
-            inv_dist += get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len)
+            inv_dist += get_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len, t)
         else:
-            inv_dist += get_willow_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len)
+            inv_dist += get_willow_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len, t)
         inv_dist /= 2.0
 
     qubit_pows = [1 << q for q in range(n_qubits)]
@@ -214,13 +216,6 @@ def generate_otoc_samples(J=-1.0, h=2.0, z=4, theta=0.0, t=5, n_qubits=65, pauli
             continue
 
         # Second dimension: permutation within Hamming weight
-        if np.random.random() < entropy_frac:
-            bit_pows = np.random.choice(qubit_pows, size=m, replace=False)
-            sample = 0
-            for bit_pow in bit_pows:
-                sample |= bit_pow
-            samples.append(sample)
-        else:
-            samples.append(take_sample(n_qubits, 0, m, inv_dist))
+        samples.append(take_sample(n_qubits, 0, m, inv_dist))
 
     return samples

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,16 +308,27 @@ 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 * os.cpu_count()
+        gray_iterations = n_qubits * n_qubits
 
     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,16 +312,27 @@ 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 * os.cpu_count()
+        gray_iterations = n_qubits * n_qubits
 
     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,16 +219,27 @@ 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 * os.cpu_count()
+        gray_iterations = n_qubits * n_qubits
 
     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.5.3.dist-info → pyqrackising-9.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.5.3
+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=MWxOmzFfQ2csz2A6o30Kf8zQvEtd996d3dz4kYaLtHM,898
+pyqrackising/convert_tensor_network_to_tsp.py,sha256=55ajnvdBXFgf-Tx8Ck4i_tXOWULft3LZd_xz5Z6s4qw,3547
+pyqrackising/generate_tfim_samples.py,sha256=IlAz1l8oLExO6wJBO8LCQKlU_4ZPlyGsNE8xUt_iTrg,4762
+pyqrackising/kernels.cl,sha256=YLWWyWxd38VzB_SbhSPaVtz0EHzLiat7oINtzR7moXQ,27861
+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=j0vB3YaQE-CMInhVKE6z9_K8TXTb3T3lJATe3IY58OQ,14718
+pyqrackising/spin_glass_solver_sparse.py,sha256=a_j06Jvl6dKuWoYCvp0pOyoe4clNwaT7OEuhm8kF2nU,15728
+pyqrackising/spin_glass_solver_streaming.py,sha256=aUf8XIt3bIeBP3C5_k0ATyboib7C6hwZ30bG9wvLeZo,10841
+pyqrackising/tfim_magnetization.py,sha256=On1MhCNGGHRxJFRmCOpMcdqQJiy25gWkjz0Ka8i5f-Q,499
+pyqrackising/tfim_square_magnetization.py,sha256=9uJCT8ytyufcGFrZiignjCkWJr9UcP44sAAy0BIBw34,531
+pyqrackising/tsp.py,sha256=k8VK6fKw_niR-dVz8MyOT7LedABIwTzcSkhTOircYBg,64290
+pyqrackising/tsp_maxcut.py,sha256=lEDruz5lhjVu0ufvH5VaMJW3_nohO-rEijJJabEtuSU,10084
+pyqrackising-9.7.1.dist-info/licenses/LICENSE.md,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyqrackising-9.7.1.dist-info/METADATA,sha256=Xl5EKxdkXuGdVQLgQumsHhJXl-kHPxNZqORLpgMRDFY,1170
+pyqrackising-9.7.1.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
+pyqrackising-9.7.1.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
+pyqrackising-9.7.1.dist-info/RECORD,,

pyqrackising-9.5.3.dist-info/RECORD

@@ -1,21 +0,0 @@
-pyqrackising/__init__.py,sha256=MWxOmzFfQ2csz2A6o30Kf8zQvEtd996d3dz4kYaLtHM,898
-pyqrackising/convert_tensor_network_to_tsp.py,sha256=55ajnvdBXFgf-Tx8Ck4i_tXOWULft3LZd_xz5Z6s4qw,3547
-pyqrackising/generate_tfim_samples.py,sha256=IlAz1l8oLExO6wJBO8LCQKlU_4ZPlyGsNE8xUt_iTrg,4762
-pyqrackising/kernels.cl,sha256=YLWWyWxd38VzB_SbhSPaVtz0EHzLiat7oINtzR7moXQ,27861
-pyqrackising/maxcut_tfim.py,sha256=U1nNjyfMS48TtTQk7TRf5_VF3pVPfAcZEa2awc2nR8k,10862
-pyqrackising/maxcut_tfim_sparse.py,sha256=eenJNSEwRvgwACfKoH0tj6rpn7uqH6nNTBuxUPh_lDg,11941
-pyqrackising/maxcut_tfim_streaming.py,sha256=FkBsRoXSRhv4gUeN9O7Ivx54oxq_SqiCDKnYsyxU4bs,6664
-pyqrackising/maxcut_tfim_util.py,sha256=S8W_Hxi4mwdSxK76uBG66fZwd9yODSVCDtmV9Jrirjs,17781
-pyqrackising/otoc.py,sha256=cfnE8TOgrgVHU7MWcYYoHLv8ncyRJ9Rl60XrX4u6uVA,7399
-pyqrackising/spin_glass_solver.py,sha256=tgmdJ6b1TetnFM--QEzOZFsNkquQYRVYiHVSzIGYvMI,14207
-pyqrackising/spin_glass_solver_sparse.py,sha256=cmXfAR43n1beRk4LaQbwfrQWkkhMPzPXpdK2T1HhQrk,15159
-pyqrackising/spin_glass_solver_streaming.py,sha256=joQLMKotgjQMwbG0msv_AookiWva_AiVBIR0Xr1Unho,10310
-pyqrackising/tfim_magnetization.py,sha256=On1MhCNGGHRxJFRmCOpMcdqQJiy25gWkjz0Ka8i5f-Q,499
-pyqrackising/tfim_square_magnetization.py,sha256=9uJCT8ytyufcGFrZiignjCkWJr9UcP44sAAy0BIBw34,531
-pyqrackising/tsp.py,sha256=k8VK6fKw_niR-dVz8MyOT7LedABIwTzcSkhTOircYBg,64290
-pyqrackising/tsp_maxcut.py,sha256=lEDruz5lhjVu0ufvH5VaMJW3_nohO-rEijJJabEtuSU,10084
-pyqrackising-9.5.3.dist-info/licenses/LICENSE.md,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-pyqrackising-9.5.3.dist-info/METADATA,sha256=IRBVTz7T_zf7jfPxQxOB3aLtlgtjvCIZmSbbGkUP26I,1170
-pyqrackising-9.5.3.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
-pyqrackising-9.5.3.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
-pyqrackising-9.5.3.dist-info/RECORD,,