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

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,7 +89,7 @@ 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
 
@@ -104,6 +108,13 @@ def fix_cdf(hamming_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()
 

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,22 +389,19 @@ 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
@@ -441,17 +438,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]
@@ -488,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:
@@ -496,7 +491,7 @@ def sample_mag(cum_prob):
         else:
             right = m - 1
 
-    return m + 1
+    return m
 
 
 @njit

pyqrackising/otoc.py

@@ -1,59 +1,79 @@
-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 math
 from numba import njit
 import numpy as np
-import random
+import sys
 
 
-def get_otoc_hamming_distribution(J=-1.0, h=2.0, z=4, theta=0.174532925199432957, t=5, n_qubits=56, cycles=1, pauli_string = 'X' + 'I' * 55):
-    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.)")
+epsilon = opencl_context.epsilon
 
-    fwd = probability_by_hamming_weight(J, h, z, theta, t, n_qubits + 1, False)
-    rev = probability_by_hamming_weight(-J, -h, z, -theta, t, n_qubits + 1, False)
-    diff_theta = rev - fwd
-
-    phi = theta - np.pi / 2
-    fwd = probability_by_hamming_weight(J, h, z, phi, t, n_qubits + 1, False)
-    rev = probability_by_hamming_weight(-J, -h, z, -phi, t, n_qubits + 1, False)
-    diff_phi = rev - fwd
-
-    diff_theta *= cycles
-    diff_phi *= cycles
-    diff_lam = 0.5 * (diff_theta + diff_phi)
 
+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_x = np.zeros(n_bias, dtype=np.float64)
-    diff_y = np.zeros(n_bias, dtype=np.float64)
-    for b in pauli_string:
-        match b:
-            case 'X':
-                diff_z += diff_theta
-                diff_x += diff_lam
-                diff_y += diff_phi
-            case 'Z':
-                diff_z += diff_phi
-                diff_x += diff_theta
-                diff_y += diff_lam
-            case 'Y':
-                diff_z += diff_lam
-                diff_x += diff_phi
-                diff_y += diff_theta
-
-    diff_z -= diff_z.min()
-    diff_x -= diff_x.min()
-    diff_y -= diff_y.min()
-
-    diff_z[0] += n_bias
-    diff_x[0] += n_bias
-    diff_y[0] += n_bias
-
+    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()
-    diff_y /= diff_y.sum()
 
-    return { 'X': diff_x, 'Y': diff_y, 'Z': diff_z }
+    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
@@ -70,104 +90,132 @@ def fix_cdf(hamming_prob):
 
 
 @njit
-def take_all(b, basis, sample):
-    for i in range(len(basis)):
-        if basis[i] == b:
-            sample |= (1 << i)
+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 sample
+    return row_len, col_len
 
 
-def take_sample(b, basis, sample, m):
+# Provided by Google search AI
+def find_all_str_occurrences(main_string, sub_string):
     indices = []
-    for i in range(len(basis)):
-        if basis[i] == b:
-            indices.append(i)
-    indices = random.sample(indices, m)
-    for i in 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 generate_otoc_samples(J=-1.0, h=2.0, z=4, theta=0.174532925199432957, t=5, n_qubits=56, cycles=1, pauli_string = 'X' + 'I' * 55, shots=100, measurement_basis='Z' * 56):
-    pauli_string = list(pauli_string)
-    if len(pauli_string) != n_qubits:
-        raise ValueError("OTOC pauli_string must be same length as n_qubits! (Use 'I' for qubits that aren't changed.)")
-
-    measurement_basis = list(measurement_basis)
-    if len(measurement_basis) != n_qubits:
-        raise ValueError("OTOC measurement_basis must be same length as measurement_basis! (Use 'I' for excluded qubits.)")
-
-    basis_x, basis_y, basis_z = [], [], []
-    for b in pauli_string:
-        if b == 'Z':
-            basis_z.append('X')
-            basis_y.append('Z')
-            basis_x.append('I')
-        elif b == 'X':
-            basis_z.append('Z')
-            basis_y.append('I')
-            basis_x.append('X')
-        elif b == 'Y':
-            basis_z.append('I')
-            basis_y.append('I')
-            basis_x.append('X')
+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:
-            basis_z.append('I')
-            basis_y.append('X')
-            basis_x.append('Z')
-
-    bases = { 'X': basis_x, 'Y': basis_y, 'Z': basis_z }
-    thresholds = { key: fix_cdf(value) for key, value in get_otoc_hamming_distribution(J, h, z, theta, t, n_qubits, cycles, pauli_string).items() }
-
-    samples_3_axis = {}
-    for key, value in thresholds.items():
-        basis = bases[key]
+            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):
-        sample_3_axis = { 'X': 0, 'Y': 0, 'Z': 0 }
-        for key, value in thresholds.items():
-            basis = bases[key]
-
-            # First dimension: Hamming weight
-            m = sample_mag(value)
-            if m >= n_qubits:
-                sample_3_axis[key] = (1 << n_qubits) - 1
-                continue
-
-            # Second dimension: permutation within Hamming weight
-            z_count = basis.count('Z')
-            if z_count > m:
-                sample_3_axis[key] = take_sample('Z', basis, sample_3_axis[key], m)
-                continue
-            m -= z_count
-            sample_3_axis[key] = take_all('Z', basis, sample_3_axis[key])
-            if m == 0:
-                continue
-
-            i_count = basis.count('I')
-            if i_count > m:
-                sample_3_axis[key] = take_sample('I', basis, sample_3_axis[key], m)
-                continue
-            m -= i_count
-            sample_3_axis[key] = take_all('I', basis, sample_3_axis[key])
-            if m == 0:
-                continue
-
-            sample_3_axis[key] = take_sample('X', basis, sample_3_axis[key], m)
-
-        sample = 0
-        j = 0
-        for i in range(n_qubits):
-            base = measurement_basis[i]
-            if base not in ['X', 'Y', 'Z']:
-                continue
-            if (sample_3_axis[base] >> i) & 1:
-                sample |= 1 << j
-            j += 1
-
-        samples.append(sample)
+        # 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-9.3.0.dist-info → pyqrackising-9.5.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrackising
-Version: 9.3.0
+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.3.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-pyqrackising/__init__.py,sha256=Q-fHQRApRseeFnnO6VfD1LpjPHCVkWoz0Gnaqmv6lp0,884
-pyqrackising/convert_tensor_network_to_tsp.py,sha256=IbZdPfHQ2bzYqDXUdHfwdZJh-pC8lri_cAgESaskQWI,3450
-pyqrackising/generate_tfim_samples.py,sha256=NZh9dMW7RurMkfawFLdWI8WFZmXS5CTosTQDrwCBOSk,4503
-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=D5tIbfKVLazR6f_INAoFypNJA0iuPin_bkiIM7-_pvg,16937
-pyqrackising/otoc.py,sha256=IzARDeNvuGwL_RHBotQsth5d7iz5oGbsIharCrCLUyg,5620
-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.3.0.dist-info/licenses/LICENSE.md,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-pyqrackising-9.3.0.dist-info/METADATA,sha256=O5jeEBKDsW3iCI2rFiIFTbS997jR8rNZ4ARO-1TrVs4,1143
-pyqrackising-9.3.0.dist-info/WHEEL,sha256=tt4-VHVHv-wywtMZy9Hvv8M6zRlbacCdJyvDZp-_L0E,105
-pyqrackising-9.3.0.dist-info/top_level.txt,sha256=bxlfGuLwzeVEI8Jm5D9HvC_WedgvvkSrpFwbGDjg-Ag,13
-pyqrackising-9.3.0.dist-info/RECORD,,