pyqrackising 9.5.11__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:
@@ -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]:
@@ -239,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,
@@ -261,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:
@@ -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]
@@ -253,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,
@@ -278,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
@@ -324,7 +386,7 @@ def maxcut_tfim_sparse(
         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_data, G_rows, G_cols, shots, thread_count, cum_prob, repulsion_base, is_spin_glass)
+        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, 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
@@ -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]:
@@ -145,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,
@@ -158,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):
@@ -390,19 +392,21 @@ def init_theta(h_mult, n_qubits, J_eff, degrees):
 
 
 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 >> 1):
-        thresholds[q - 1] = p
-        thresholds[n_bias - q] = p
-        tot_prob += 2 * p
+    normalizer = 0
+    for q in range(n_qubits >> 1):
+        normalizer += math.comb(n_qubits, q) << 1
+    if n_qubits & 1:
+        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
-        tot_prob += p
-    thresholds /= tot_prob
+        thresholds[n_qubits >> 1] = p / normalizer
 
     return thresholds
 
@@ -438,7 +442,7 @@ def probability_by_hamming_weight(J, h, z, theta, t, n_bias, normalized=True):
     return bias
 
 
-@njit(parallel=True)
+@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
@@ -446,7 +450,7 @@ def maxcut_hamming_cdf(hamming_prob, n_qubits, J_func, degrees, quality, tot_t,
 
     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

@@ -51,8 +51,6 @@ def get_otoc_hamming_distribution(J=-1.0, h=2.0, z=4, theta=0.0, t=5, n_qubits=6
         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) / 2
-
         for b in pauli_string:
             match b:
                 case 'X':

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.11.dist-info → pyqrackising-9.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.5.11
+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.5.11.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=05nRjk5hhEjNFjtXdKVObL0cYYuJ8URfcjrOGK5tGi4,10106
-pyqrackising/maxcut_tfim_sparse.py,sha256=zMgaVmEgfZWL2tp728PuEg5Dc_jbQBUPsgbP3lXiMiA,11194
-pyqrackising/maxcut_tfim_streaming.py,sha256=EcRXKurqLiQs6pMNz-rhMp2YQzRXD726RnkXsPt4IJ0,6346
-pyqrackising/maxcut_tfim_util.py,sha256=2FSBcba8Ys8HEe_h-ayB68pAqeeJXeveEHGmZKg_tkI,16889
-pyqrackising/otoc.py,sha256=Vq5tHy-XdV6O5qQGVN8E7xLkwHcXDhlWo6GNJTAd4dE,7258
-pyqrackising/spin_glass_solver.py,sha256=YtsIfYfpwhEMQPVd_sbjqpz6nQcrv8p2mUBYZ-wRpnM,13792
-pyqrackising/spin_glass_solver_sparse.py,sha256=E4Ft7H-uKXZyq1cS7Z77AgdkL5fMlKMK6DwnXgrgOhk,14740
-pyqrackising/spin_glass_solver_streaming.py,sha256=xpWq63yODMzBPQQtpDuB1Tro6ta8pPbVwc0ZkDWVASk,10018
-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.5.11.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-pyqrackising-9.5.11.dist-info/METADATA,sha256=6Z3r5ubODul2NQjgGyg7M6l_nUBhntcpEI2mU18q81Q,1144
-pyqrackising-9.5.11.dist-info/WHEEL,sha256=k8EuOMBHdXsN9XSTE5LrpwS4FtdLkoSlyO_7W-lE_zg,109
-pyqrackising-9.5.11.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
-pyqrackising-9.5.11.dist-info/RECORD,,