pyqrackising 9.2.3__py3-none-macosx_15_0_arm64.whl → 9.5.12__py3-none-macosx_15_0_arm64.whl

pyqrackising/__init__.py

@@ -1,9 +1,11 @@
-from .generate_tfim_samples import generate_tfim_samples
+from .generate_tfim_samples import generate_tfim_samples, get_tfim_hamming_distribution
 from .tfim_magnetization import tfim_magnetization
 from .tfim_square_magnetization import tfim_square_magnetization
+from .otoc import generate_otoc_samples, get_otoc_hamming_distribution
 from .maxcut_tfim import maxcut_tfim
 from .maxcut_tfim_sparse import maxcut_tfim_sparse
 from .maxcut_tfim_streaming import maxcut_tfim_streaming
+from .maxcut_tfim_util import probability_by_hamming_weight
 from .spin_glass_solver import spin_glass_solver
 from .spin_glass_solver_sparse import spin_glass_solver_sparse
 from .spin_glass_solver_streaming import spin_glass_solver_streaming

pyqrackising/generate_tfim_samples.py

@@ -1,10 +1,14 @@
-from .maxcut_tfim_util import probability_by_hamming_weight, sample_mag
+from .maxcut_tfim_util import probability_by_hamming_weight, sample_mag, opencl_context
 import itertools
 import math
+import sys
 import numpy as np
 from numba import njit
 
 
+epsilon = opencl_context.epsilon
+
+
 @njit
 def factor_width(width, is_transpose=False):
     col_len = math.floor(math.sqrt(width))
@@ -85,13 +89,12 @@ def expected_closeness_weight(n_rows, n_cols, hamming_weight):
 def sample_hamming_weight(thresholds, shots):
     hamming_samples = np.zeros(shots, dtype=np.int32)
     for s in range(shots):
-        hamming_samples[s] = sample_mag(thresholds)
+        hamming_samples[s] = sample_mag(thresholds) + 1
 
     return hamming_samples
 
 @njit
 def fix_cdf(hamming_prob):
-    hamming_prob /= hamming_prob.sum()
     tot_prob = 0.0
     n_bias = len(hamming_prob)
     cum_prob = np.empty(n_bias, dtype=np.float64)
@@ -103,13 +106,26 @@ def fix_cdf(hamming_prob):
     return cum_prob
 
 
+@njit
+def get_tfim_hamming_distribution(J=-1.0, h=2.0, z=4, theta=0.174532925199432957, t=5, n_qubits=56):
+    if h <= epsilon:
+        bias = np.empty(n_qubits + 1, dtype=np.float64)
+        if J > 0:
+            bias[-1] = 1.0
+        else:
+            bias[0] = 1.0
+        return bias
+    bias = probability_by_hamming_weight(J, h, z, theta, t, n_qubits + 1)
+    return bias / bias.sum()
+
+
 def generate_tfim_samples(
     J=-1.0, h=2.0, z=4, theta=0.174532925199432957, t=5, n_qubits=56, shots=100
 ):
     n_rows, n_cols = factor_width(n_qubits)
 
     # First dimension: Hamming weight
-    thresholds = fix_cdf(probability_by_hamming_weight(J, h, z, theta, t, n_qubits + 1))
+    thresholds = fix_cdf(get_tfim_hamming_distribution(J, h, z, theta, t, n_qubits + 1))
     hamming_samples = sample_hamming_weight(thresholds, shots)
 
     samples = []

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/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_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, 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/maxcut_tfim_util.py

@@ -389,29 +389,26 @@ def init_theta(h_mult, n_qubits, J_eff, degrees):
     return theta
 
 
-@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 = 1.0
-    if n_qubits & 1:
-        q = n_qubits // 2
-        thresholds[q - 1] = p
-        tot_prob = p
-        p /= 2
-    for q in range(1, n_qubits // 2):
-        thresholds[q - 1] = p
-        thresholds[n_bias - q] = p
+    p = 1
+    for q in range(n_qubits >> 1):
+        thresholds[q] = p
+        thresholds[n_bias - (q + 1)] = p
         tot_prob += 2 * p
-        p /= 2
+        p = math.comb(n_qubits, q + 1)
+    if n_qubits & 1:
+        thresholds[n_qubits >> 1] = p
+        tot_prob += p
     thresholds /= tot_prob
 
     return thresholds
 
 
 @njit
-def probability_by_hamming_weight(J, h, z, theta, t, n_bias):
+def probability_by_hamming_weight(J, h, z, theta, t, n_bias, normalized=True):
     zJ = z * J
     theta_c = ((np.pi if J > 0 else -np.pi) / 2) if abs(zJ) < epsilon else np.arcsin(max(-1.0, min(1.0, h / zJ)))
 
@@ -435,20 +432,21 @@ def probability_by_hamming_weight(J, h, z, theta, t, n_bias):
     if J > 0.0:
         return bias[::-1]
 
-    return bias
+    if normalized:
+        bias /= bias.sum()
 
+    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]
@@ -459,8 +457,8 @@ def maxcut_hamming_cdf(n_qubits, J_func, degrees, quality, tot_t, h_mult):
         t = step * delta_t
         tm1 = (step - 1) * delta_t
         h_t = h_mult * (tot_t - t)
-        bias = probability_by_hamming_weight(J_eff, h_t, z, theta_eff, t, n_bias)
-        last_bias = probability_by_hamming_weight(J_eff, h_t, z, theta_eff, tm1, n_bias)
+        bias = probability_by_hamming_weight(J_eff, h_t, z, theta_eff, t, n_bias, False)
+        last_bias = probability_by_hamming_weight(J_eff, h_t, z, theta_eff, tm1, n_bias, False)
         for i in range(n_bias):
             hamming_prob[i] += bias[i] - last_bias[i]
 
@@ -485,7 +483,7 @@ def sample_mag(cum_prob):
     while True:
         m = (left + right) >> 1
 
-        if (cum_prob[m] >= p) and ((m == 0) or cum_prob[m - 1] < p):
+        if (cum_prob[m] >= p) and ((m == 0) or (cum_prob[m - 1] < p)):
             break
 
         if cum_prob[m] < p:
@@ -493,7 +491,7 @@ def sample_mag(cum_prob):
         else:
             right = m - 1
 
-    return m + 1
+    return m
 
 
 @njit

pyqrackising/otoc.py

@@ -0,0 +1,221 @@
+from .maxcut_tfim_util import probability_by_hamming_weight, sample_mag, opencl_context
+import math
+from numba import njit
+import numpy as np
+import sys
+
+
+epsilon = opencl_context.epsilon
+
+
+def get_otoc_hamming_distribution(J=-1.0, h=2.0, z=4, theta=0.0, t=5, n_qubits=65, pauli_strings = ['X' + 'I' * 64]):
+    n_bias = n_qubits + 1
+    if h <= epsilon:
+        bias = np.empty(n_bias, dtype=np.float64)
+        bias[0] = 1.0
+        return bias
+
+    diff_x = np.empty(n_bias, dtype=np.float64)
+    tot_prob = 0
+    p = 1.0
+    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:
+        diff_x[n_qubits >> 1] = p
+        tot_prob += p
+    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)
+        diff_phi = rev - fwd
+
+        for b in pauli_string:
+            match b:
+                case 'X':
+                    diff_z += diff_theta
+                case 'Z':
+                    diff_x += diff_phi
+                case 'Y':
+                    diff_z += diff_theta
+                    diff_x += diff_phi
+                case _:
+                    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()
+
+    return diff_z
+
+
+@njit
+def fix_cdf(hamming_prob):
+    tot_prob = 0.0
+    n_bias = len(hamming_prob)
+    cum_prob = np.empty(n_bias, dtype=np.float64)
+    for i in range(n_bias):
+        tot_prob += hamming_prob[i]
+        cum_prob[i] = tot_prob
+    cum_prob[-1] = 2.0
+
+    return cum_prob
+
+
+@njit
+def factor_width(width):
+    col_len = int(np.floor(np.sqrt(width)))
+    while ((width // col_len) * col_len) != width:
+        col_len -= 1
+    row_len = width // col_len
+
+    return row_len, col_len
+
+
+# Provided by Google search AI
+def find_all_str_occurrences(main_string, sub_string):
+    indices = []
+    start_index = 0
+    while True:
+        index = main_string.find(sub_string, start_index)
+        if index == -1:
+            break
+        indices.append(index)
+        start_index = index + 1  # Start searching after the found occurrence
+
+    return indices
+
+
+def take_sample(n_qubits, sample, m, inv_dist):
+    indices = [i for i in range(n_qubits)]
+    tot_inv_dist = 0.0
+    for i in range(n_qubits):
+        tot_inv_dist += inv_dist[i]
+    selected = []
+    for i in range(m):
+        r = tot_inv_dist * np.random.random()
+        p = inv_dist[indices[0]]
+        idx = 0
+        while p < r:
+            idx += 1
+            if idx >= len(indices):
+                idx = len(indices) - 1
+                break
+            p += inv_dist[indices[idx]]
+        i = indices[idx]
+        del indices[idx]
+        selected.append(i)
+        tot_inv_dist -= inv_dist[i]
+    for i in selected:
+        sample |= 1 << i
+
+    return sample
+
+
+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)
+    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 = 2 ** (inv_dist / t)
+
+    return inv_dist
+
+
+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
+    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)
+            row_d = abs(q_row - b_row)
+            if row_d > half_row:
+                row_d = row_len - row_d
+            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
+    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)
+            row_d = abs(q_row - b_row)
+            if row_d > half_row:
+                row_d = row_len - row_d
+            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 = 2 ** (inv_dist / t)
+
+    return inv_dist
+
+
+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))
+
+    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, t)
+        else:
+            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)]
+    samples = []
+    for _ in range(shots):
+        # First dimension: Hamming weight
+        m = sample_mag(thresholds)
+        if m == 0:
+            samples.append(0)
+            continue
+        if m >= n_qubits:
+            samples.append((1 << n_qubits) - 1)
+            continue
+
+        # Second dimension: permutation within Hamming weight
+        samples.append(take_sample(n_qubits, 0, m, inv_dist))
+
+    return samples

pyqrackising/spin_glass_solver.py

@@ -376,6 +376,33 @@ def spin_glass_solver(
             max_energy = energy
             best_theta = state
             improved = True
+            continue
+
+        # Post-reheat phase
+        reheat_theta = state
+
+        # Single bit flips with O(n^2)
+        if is_opencl:
+            theta_buf = make_best_theta_buf(reheat_theta)
+            energy, state = run_bit_flips_opencl(False, n_qubits, single_bit_flips_kernel, max_energy, reheat_theta, theta_buf, G_m_buf, is_segmented, *opencl_args)
+        else:
+            energy, state = run_single_bit_flips(reheat_theta, is_spin_glass, G_m)
+        if energy > max_energy:
+            max_energy = energy
+            best_theta = state
+            improved = True
+            continue
+
+        # Double bit flips with O(n^3)
+        if is_opencl:
+            # theta_buf has not changed
+            energy, state = run_bit_flips_opencl(True, n_qubits, double_bit_flips_kernel, max_energy, reheat_theta, theta_buf, G_m_buf, is_segmented, *opencl_args)
+        else:
+            energy, state = run_double_bit_flips(reheat_theta, is_spin_glass, G_m, thread_count)
+        if energy > max_energy:
+            max_energy = energy
+            best_theta = state
+            improved = True
 
     bitstring, l, r = get_cut(best_theta, nodes, n_qubits)
     if is_spin_glass:

pyqrackising/spin_glass_solver_sparse.py

@@ -380,6 +380,33 @@ def spin_glass_solver_sparse(
             max_energy = energy
             best_theta = state
             improved = True
+            continue
+
+        # Post-reheat phase
+        reheat_theta = state
+
+        # Single bit flips with O(n^2)
+        if is_opencl:
+            theta_buf = make_best_theta_buf(reheat_theta)
+            energy, state = run_bit_flips_opencl(False, n_qubits, single_bit_flips_kernel, max_energy, reheat_theta, theta_buf, G_data_buf, G_rows_buf, G_cols_buf, is_segmented, *opencl_args)
+        else:
+            energy, state = run_single_bit_flips(reheat_theta, is_spin_glass, G_m.data, G_m.indptr, G_m.indices)
+        if energy > max_energy:
+            max_energy = energy
+            best_theta = state
+            improved = True
+            continue
+
+        # Double bit flips with O(n^3)
+        if is_opencl:
+            # theta_buf has not changed
+            energy, state = run_bit_flips_opencl(True, n_qubits, double_bit_flips_kernel, max_energy, reheat_theta, theta_buf, G_data_buf, G_rows_buf, G_cols_buf, is_segmented, *opencl_args)
+        else:
+            energy, state = run_double_bit_flips(reheat_theta, is_spin_glass, G_m.data, G_m.indptr, G_m.indices, thread_count)
+        if energy > max_energy:
+            max_energy = energy
+            best_theta = state
+            improved = True
 
     bitstring, l, r = get_cut(best_theta, nodes, n_qubits)
     if is_spin_glass:

pyqrackising/spin_glass_solver_streaming.py

@@ -261,6 +261,25 @@ def spin_glass_solver_streaming(
             max_energy = energy
             best_theta = state
             improved = True
+            continue
+
+        # Post-reheat phase
+        reheat_theta = state
+
+        # Single bit flips with O(n^2)
+        energy, state = run_single_bit_flips(reheat_theta, is_spin_glass, G_func, nodes)
+        if energy > max_energy:
+            max_energy = energy
+            best_theta = state
+            improved = True
+            continue
+
+        # Double bit flips with O(n^3)
+        energy, state = run_double_bit_flips(reheat_theta, is_spin_glass, G_func, nodes, thread_count)
+        if energy > max_energy:
+            max_energy = energy
+            best_theta = state
+            improved = True
 
     bitstring, l, r = get_cut(best_theta, nodes, n_qubits)
     if is_spin_glass:

pyqrackising/tsp.py

@@ -1,7 +1,6 @@
 from .maxcut_tfim_util import binary_search, opencl_context, to_scipy_sparse_upper_triangular
-from .maxcut_tfim import maxcut_tfim
+from .spin_glass_solver import spin_glass_solver
 from concurrent.futures import ProcessPoolExecutor
-import time
 import itertools
 import networkx as nx
 from numba import njit, prange
@@ -639,7 +638,7 @@ def tsp_symmetric_header(G_m, nodes, quality, shots, anneal_t, anneal_h, repulsi
             for _ in range(multi_start):
                 bits = ([], [])
                 while (len(bits[0]) == 0) or (len(bits[1]) == 0):
-                    _, cut_value, bits = maxcut_tfim(G_m, quality=quality, shots=shots, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base)
+                    _, cut_value, bits, _ = spin_glass_solver(G_m, is_spin_glass=False, quality=quality, shots=shots, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base)
                 if cut_value > best_cut:
                     best_cut = cut_value
                     a, b = bits
@@ -851,7 +850,7 @@ def tsp_asymmetric_header(G_m, nodes, quality, shots, anneal_t, anneal_h, repuls
             for _ in range(multi_start):
                 bits = ([], [])
                 while (len(bits[0]) == 0) or (len(bits[1]) == 0):
-                    _, cut_value, bits = maxcut_tfim((G_m + G_m.T) / 2, quality=quality, shots=shots, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base)
+                    _, cut_value, bits, _ = spin_glass_solver((G_m + G_m.T) / 2, is_spin_glass=False, quality=quality, shots=shots, anneal_t=anneal_t, anneal_h=anneal_h, repulsion_base=repulsion_base)
                 if cut_value > best_cut:
                     best_cut = cut_value
                     a, b = bits

{pyqrackising-9.2.3.dist-info → pyqrackising-9.5.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.2.3
+Version: 9.5.12
 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.12.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=05nRjk5hhEjNFjtXdKVObL0cYYuJ8URfcjrOGK5tGi4,10106
+pyqrackising/maxcut_tfim_sparse.py,sha256=dddVdu54bvA5NCmknkWthnszPsCsC0OKoJswb3qI-hA,11205
+pyqrackising/maxcut_tfim_streaming.py,sha256=EcRXKurqLiQs6pMNz-rhMp2YQzRXD726RnkXsPt4IJ0,6346
+pyqrackising/maxcut_tfim_util.py,sha256=lbyNrUnjPajUUVDbSh1pRwru0eshFsP2hOrVppUf4Co,16865
+pyqrackising/otoc.py,sha256=PKmpjwkGpMmwXGWmeqtvbVj1NfE35i9kkIdjQnDUZKE,7208
+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.12.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+pyqrackising-9.5.12.dist-info/METADATA,sha256=BzfdPzf4NK65jk4YO3KtSlSfkSlLoRrWAU827KVmVRM,1144
+pyqrackising-9.5.12.dist-info/WHEEL,sha256=tt4-VHVHv-wywtMZy9Hvv8M6zRlbacCdJyvDZp-_L0E,105
+pyqrackising-9.5.12.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
+pyqrackising-9.5.12.dist-info/RECORD,,

pyqrackising-9.2.3.dist-info/RECORD

@@ -1,20 +0,0 @@
-pyqrackising/__init__.py,sha256=nrX4qYm9kEPcjbiy3KEMrLSPBtkVGFXVF3iosptSv1w,722
-pyqrackising/convert_tensor_network_to_tsp.py,sha256=IbZdPfHQ2bzYqDXUdHfwdZJh-pC8lri_cAgESaskQWI,3450
-pyqrackising/generate_tfim_samples.py,sha256=wi1I-pqZelYe3qoKQgW9mdDu41LBHIcUkl4cbYTlXEw,4325
-pyqrackising/kernels.cl,sha256=Q9LZ1oBOZ2A_VsQ8uRUGQKNVpzqVXYwhG6c27FO6ljI,27004
-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=2-tJrBMe7A5hjY-Q1rQKm6PHJfFOgL5WpPGhKndIf_Y,16856
-pyqrackising/spin_glass_solver.py,sha256=WzH3Ud0MGHsaWDfBDZ2dPUFArmG1S4A318SiA0c03Fk,12687
-pyqrackising/spin_glass_solver_sparse.py,sha256=UmpHO7IbPc3uaTdYRl2ilBmH0fTQuIphiJIVEBIGNdo,13521
-pyqrackising/spin_glass_solver_streaming.py,sha256=ccvuxN042R2TKhd1JJrYWDI1001g6OzzOmaIMaNse-w,9400
-pyqrackising/tfim_magnetization.py,sha256=On1MhCNGGHRxJFRmCOpMcdqQJiy25gWkjz0Ka8i5f-Q,499
-pyqrackising/tfim_square_magnetization.py,sha256=9uJCT8ytyufcGFrZiignjCkWJr9UcP44sAAy0BIBw34,531
-pyqrackising/tsp.py,sha256=UbWxMdmf9yEAAoGULWYbQW5c-dgOkGiuE_uyY3Js6KU,62404
-pyqrackising/tsp_maxcut.py,sha256=ngxfSJgePXVwJXfNXYdk4jv1ISznx8zHOqR-Vbf33B0,9772
-pyqrackising-9.2.3.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-pyqrackising-9.2.3.dist-info/METADATA,sha256=SGmIq39ouVgjTbk9R8jb-DDNmwxPHW4GMkc_ajFx7T8,1143
-pyqrackising-9.2.3.dist-info/WHEEL,sha256=tt4-VHVHv-wywtMZy9Hvv8M6zRlbacCdJyvDZp-_L0E,105
-pyqrackising-9.2.3.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
-pyqrackising-9.2.3.dist-info/RECORD,,