pyqrackising 9.5.2__tar.gz → 9.5.4__tar.gz

{pyqrackising-9.5.2/pyqrackising.egg-info → pyqrackising-9.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.5.2
+Version: 9.5.4
 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.5.2 → pyqrackising-9.5.4}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyqrackising"
-version = "9.5.2"
+version = "9.5.4"
 requires-python = ">=3.8"
 description = "Fast MAXCUT, TSP, and sampling heuristics from near-ideal transverse field Ising model (TFIM)"
 readme = {file = "README.txt", content-type = "text/markdown"}

{pyqrackising-9.5.2 → pyqrackising-9.5.4}/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, 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:
@@ -177,21 +177,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 +238,7 @@ def run_cut_opencl(best_energy, samples, G_m_buf, is_segmented, local_size, glob
 
     return samples[max_index_host[best_x]], energy
 
+
 def maxcut_tfim(
     G,
     quality=None,
@@ -308,31 +294,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-9.5.2 → pyqrackising-9.5.4}/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, 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:
@@ -187,17 +187,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
@@ -319,35 +308,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_data, G_rows, G_cols, shots, thread_count, cum_prob, repulsion_base, is_spin_glass)
 
     bit_string, l, r = get_cut(best_solution, nodes, n_qubits)
 

{pyqrackising-9.5.2 → pyqrackising-9.5.4}/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, init_thresholds, maxcut_hamming_cdf, opencl_context, sample_mag, bit_pick
 
 
 epsilon = opencl_context.epsilon
@@ -145,21 +145,6 @@ def find_G_min(G_func, nodes, n_nodes):
     return G_min
 
 
-@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
-
-    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)
-
-
 def maxcut_tfim_streaming(
     G_func,
     nodes,
@@ -207,10 +192,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-9.5.2 → pyqrackising-9.5.4}/pyqrackising/maxcut_tfim_util.py

@@ -389,44 +389,6 @@ 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
     thresholds = np.empty(n_bias, dtype=np.float64)
@@ -436,7 +398,7 @@ def init_thresholds(n_qubits):
         thresholds[q - 1] = p
         thresholds[n_bias - q] = p
         tot_prob += 2 * p
-        p = comb(n_qubits, q + 1)
+        p = math.comb(n_qubits, q + 1)
     if n_qubits & 1:
         thresholds[q - 1] = p
         tot_prob += p
@@ -477,9 +439,7 @@ def probability_by_hamming_weight(J, h, z, theta, t, n_bias, normalized=True):
 
 
 @njit(parallel=True)
-def maxcut_hamming_cdf(n_qubits, J_func, degrees, quality, tot_t, h_mult):
-    hamming_prob = init_thresholds(n_qubits)
-
+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

{pyqrackising-9.5.2 → pyqrackising-9.5.4}/pyqrackising/otoc.py

@@ -184,6 +184,12 @@ 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:
@@ -195,6 +201,7 @@ def generate_otoc_samples(J=-1.0, h=2.0, z=4, theta=0.0, t=5, n_qubits=65, pauli
             inv_dist += get_willow_inv_dist(butterfly_idx_x, butterfly_idx_z, n_qubits, row_len, col_len)
         inv_dist /= 2.0
 
+    qubit_pows = [1 << q for q in range(n_qubits)]
     samples = []
     for _ in range(shots):
         # First dimension: Hamming weight
@@ -207,6 +214,13 @@ 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
-        samples.append(take_sample(n_qubits, 0, m, inv_dist))
+        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))
 
     return samples

{pyqrackising-9.5.2 → pyqrackising-9.5.4/pyqrackising.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.5.2
+Version: 9.5.4
 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.5.2 → pyqrackising-9.5.4}/setup.py

@@ -7,7 +7,7 @@ with open(README_PATH) as readme_file:
 
 setup(
     name='pyqrackising',
-    version='9.5.2',
+    version='9.5.4',
     author='Dan Strano',
     author_email='stranoj@gmail.com',
     description='Fast MAXCUT, TSP, and sampling heuristics from near-ideal transverse field Ising model (TFIM)',