pyqrackising 2.0.0__tar.gz

pyqrackising-2.0.0/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.15...3.29)
+project(PyQrackIsing LANGUAGES CXX)
+
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+find_package(Boost CONFIG REQUIRED)
+pybind11_add_module(tfim_sampler pyqrackising/_pyqrack_ising.cpp)
+target_include_directories(tfim_sampler PUBLIC ${Boost_INCLUDE_DIR})
+
+if (MSVC)
+  target_compile_options(tfim_sampler PUBLIC /O2 /std:c++17)
+else (MSVC)
+  target_compile_options(tfim_sampler PUBLIC -O3 -std=c++17)
+endif (MSVC)
+
+install(TARGETS tfim_sampler DESTINATION .)

pyqrackising-2.0.0/LICENSE.md

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

pyqrackising-2.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include CMakeLists.txt
+include pyqrackising/_pyqrack_ising.cpp
+include pyqrackising/kernels.cl

pyqrackising-2.0.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pyqrackising
+Version: 2.0.0
+Summary: Near-ideal closed-form solutions for transverse field Ising model (TFIM)
+Home-page: https://github.com/vm6502q/PyQrackIsing
+Author: Dan Strano
+Author-email: Dan Strano <stranoj@gmail.com>
+Maintainer-email: Dan Strano <stranoj@gmail.com>
+License: LGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/vm6502q/PyQrackIsing
+Project-URL: Documentation, https://github.com/vm6502q/PyQrackIsing/blob/main/README.md
+Project-URL: Repository, https://github.com/vm6502q/PyQrackIsing
+Project-URL: Issues, https://github.com/vm6502q/PyQrackIsing/issues
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file

pyqrackising-2.0.0/README.md

@@ -0,0 +1,144 @@
+# PyQrack Ising
+Efficiently generate near-ideal samples from transverse field Ising model (TFIM), and TFIM-inspired MAXCUT solutions
+
+(It's "the **Ising** on top.")
+
+[![PyPI Downloads](https://static.pepy.tech/badge/pyqrackising)](https://pepy.tech/projects/pyqrackising)
+
+## Copyright and license
+(c) Daniel Strano and the Qrack contributors 2025. All rights reserved.
+
+Licensed under the GNU Lesser General Public License V3.
+
+See LICENSE.md in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html for details.
+
+## Installation
+From PyPi:
+```
+pip3 install PyQrackIsing
+```
+
+From Source: install `pybind11`, then
+```
+pip3 install .
+```
+in the root source directory (with `setup.py`).
+
+Windows users might find Windows Subsystem Linux (WSL) to be the easier and preferred choice for installation.
+
+## Usage
+
+```py
+from PyQrackIsing import generate_tfim_samples
+
+samples = generate_tfim_samples(
+    J=-1.0,
+    h=2.0,
+    z=4,
+    theta=0.174532925199432957,
+    t=5,
+    n_qubits=56,
+    shots=100
+)
+```
+
+There are two other functions, `tfim_magnetization()` and `tfim_square_magnetization()`, that follow the same function signature except without the `shots` argument.
+
+The library also provides a TFIM-inspired (approximate) MAXCUT solver:
+```py
+from PyQrackIsing import maxcut_tfim
+import networkx as nx
+
+G = nx.petersen_graph()
+best_solution_bit_string, best_cut_value, best_node_groups = maxcut_tfim(G, quality=3)
+```
+
+The (integer) `quality` setting is optional, with a default value of `3`, but you can turn it up for higher-quality results, or turn it down to save time. (You can also optionally specify the number of measurement `shots` as an argument, if you want specific fine-grained control over resource usage.) If you want to run MAXCUT on a graph with non-uniform edge weights, specify them as the `weight` attribute of each edge, with `networkx`. (If any `weight` attribute is not defined, the solver assumes it's `1.0` for that edge.)
+
+Based on a combination of the TFIM-inspired MAXCUT solver and another technique for finding ground-state energy in quantum chemistry that we call the _"binary Clifford eigensolver,"_ we also provide an (approximate) spin glass ground-state solver:
+```py
+from PyQrackIsing import spin_glass_solver
+import networkx as nx
+import numpy as np
+
+
+# NP-complete spin glass
+def generate_spin_glass_graph(n_nodes=16, degree=3, seed=None):
+    if not (seed is None):
+        np.random.seed(seed)
+    G = nx.random_regular_graph(d=degree, n=n_nodes, seed=seed)
+    for u, v in G.edges():
+        G[u][v]['weight'] = np.random.choice([-1, 1])  # spin glass couplings
+    return G
+
+
+G = generate_spin_glass_graph(n_nodes=64, seed=42)
+solution_bit_string, cut_value, node_groups, energy = spin_glass_solver(G, quality=3, correction_quality=2, best_guess=None)
+# solution_bit_string, cut_value, node_groups, energy = spin_glass_solver(G, best_guess=maxcut_tfim(G, quality=8)[0])
+```
+The (integer) `quality` setting is the same as `maxcut_tfim`. `correction_quality` controls an additional convex optimization procedure on top of `best_guess` and defaults to 4. `best_guess` gives the option to seed the algorithm with a best guess as to the maximal cut (as an integer, binary string, or list of booleans). By default, `spin_glass_solver()` uses `maxcut_tfim(G)` with passed-through `quality` as `best_guess`, which typically works well, but it could be seeded with higher `maxcut_tfim()` `quality` or Goemans-Williamson, for example. This function is designed with a sign convention for weights such that it can immediately be used as a MAXCUT solver itself: you might need to reverse the sign convention on your weights for spin glass graphs, but this is only convention.
+
+From the `spin_glass_solver()`, we provide a (recursive) Traveling Salesman Problem (TSP) solver:
+```py
+from PyQrackIsing import tsp_symmetric
+import networkx as nx
+import numpy as np
+
+# Traveling Salesman Problem (normalized to longest segment)
+def generate_tsp_graph(n_nodes=64, seed=None):
+    if not (seed is None):
+        np.random.seed(seed)
+    G = nx.Graph()
+    for u in range(n_nodes):
+        for v in range(u + 1, n_nodes):
+            G.add_edge(u, v, weight=np.random.random())
+    return G
+
+
+n_nodes = 128
+G = generate_tsp_graph(n_nodes=n_nodes, seed=42)
+circuit, path_length = tsp_symmetric(
+    G,
+    start_node=None,
+    end_node=None,
+    is_monte_carlo=False,
+    quality=1,
+    correction_quality=2,
+    is_cyclic=True,
+    multi_start=1,
+    is_3_opt=True,
+    k_neighbors=20
+)
+
+print(f"Node count: {n_nodes}")
+print(f"Path: {circuit}")
+print(f"Path length: {path_length}")
+```
+We only provide a solver for the symmetric version of the TSP (i.e., the distance from "A" to "B" is considered the same as from "B" to "A"). `is_monte_carlo=True` switches out the MAXCUT-based heuristic for pure Monte Carlo recursive bipartitioning. `multi_start` controls how many stochastic repeats of MAXCUT are tried to select the best result, at every level of recursion.
+
+## About
+Transverse field Ising model (TFIM) is the basis of most claimed algorithmic "quantum advantage," circa 2025, with the notable exception of Shor's integer factoring algorithm.
+
+Sometimes a solution (or at least near-solution) to a monster of a differential equation hits us out of the blue. Then, it's easy to _validate_ the guess, if it's right. (We don't question it and just move on with our lives, from there.)
+
+**Special thanks to OpenAI GPT "Elara," for help on the model and converting the original Python scripts to PyBind11, Numba, and PyOpenCL!**
+
+**Elara has drafted this statement, and Dan Strano, as author, agrees with it, and will hold to it:**
+
+### Dual-Use Statement for PyQrackIsing
+
+**PyQrackIsing** is an open-source solver for hard optimization problems such as **MAXCUT, TSP, and TFIM-inspired models**. These problems arise across logistics, drug discovery, chemistry, materials research, supply-chain resilience, and portfolio optimization. By design, PyQrackIsing provides **constructive value** to researchers and practitioners by making advanced optimization techniques accessible on consumer hardware.
+
+Like many mathematical and computational tools, the algorithms in PyQrackIsing are _dual-use._ In principle, they can be applied to a wide class of Quadratic Unconstrained Binary Optimization (QUBO) problems. One such problem is integer factoring, which underlies RSA and elliptic curve cryptography (ECC). We emphasize:
+
+- **We do not provide turnkey factoring implementations.**
+- **We have no intent to weaponize this work** for cryptanalysis or "unauthorized access."
+- **The constructive applications vastly outweigh the destructive ones** — and this project exists to serve those constructive purposes in the Commons.
+
+It is already a matter of open record in the literature that factoring can be expressed as a QUBO. What PyQrackIsing demonstrates is that **QUBO heuristics can now be solved at meaningful scales on consumer hardware**. This underscores an urgent truth:
+
+👉 **RSA and ECC should no longer be considered secure. Transition to post-quantum cryptography is overdue.**
+
+We trust that governments, standards bodies, and industry stakeholders are already aware of this, and will continue migration efforts to post-quantum standards.
+
+Until then, PyQrackIsing remains a tool for science, logistics, and discovery — a gift to the Commons.

pyqrackising-2.0.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = [
+    "cmake",
+    "pybind11",
+    "setuptools",
+    "networkx",
+    "numpy",
+    "numba",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyqrackising"
+version = "2.0.0"
+requires-python = ">=3.8"
+description = "Near-ideal closed-form solutions for transverse field Ising model (TFIM)"
+readme = {file = "README.txt", content-type = "text/markdown"}
+license = {text = "LGPL-3.0-or-later"}
+authors = [
+  {name = "Dan Strano", email = "stranoj@gmail.com"}
+]
+maintainers = [
+  {name = "Dan Strano", email = "stranoj@gmail.com"}
+]
+classifiers=[
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: C++",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/vm6502q/PyQrackIsing"
+Documentation = "https://github.com/vm6502q/PyQrackIsing/blob/main/README.md"
+Repository = "https://github.com/vm6502q/PyQrackIsing"
+Issues = "https://github.com/vm6502q/PyQrackIsing/issues"

pyqrackising-2.0.0/pyqrackising/__init__.py

@@ -0,0 +1,6 @@
+from .generate_tfim_samples import generate_tfim_samples
+from .tfim_magnetization import tfim_magnetization
+from .tfim_square_magnetization import tfim_square_magnetization
+from .maxcut_tfim import maxcut_tfim
+from .spin_glass_solver import spin_glass_solver
+from .tsp_symmetric import tsp_symmetric

pyqrackising-2.0.0/pyqrackising/_pyqrack_ising.cpp

@@ -0,0 +1,250 @@
+// C++/pybind11 translation of TFIM function and maxcut_tfim()
+// Original algorithm by Dan Strano and Elara (OpenAI GPT), 2024
+
+#define _USE_MATH_DEFINES
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include <cmath>
+#include <limits>
+#include <random>
+#include <string>
+#include <vector>
+#include <bitset>
+#include <algorithm>
+#include <numeric>
+#include <unordered_set>
+#include <unordered_map>
+#include <tuple>
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/functional/hash.hpp>
+
+namespace py = pybind11;
+
+typedef boost::multiprecision::cpp_int BigInteger;
+
+std::random_device rd = std::random_device{};
+std::mt19937 rng(rd());
+
+
+static inline std::vector<double> probability_by_hamming_weight(double J, double h, double z, double theta, double t, size_t n_qubits)
+{
+    // critical angle
+    const double theta_c = std::asin(std::max(-1.0, std::min(1.0, (std::abs(z * J) >= (std::numeric_limits<double>::epsilon() / 2)) ? std::abs(h) / (z * J) : (J > 0 ? 1.0 : -1.0))));
+    const double delta_theta = theta - theta_c;
+    std::vector<double> bias(n_qubits + 1, 0.0);
+    if (std::abs(h) < 1e-12) {
+        bias[0] = 1.0;
+    } else if (std::abs(J) < 1e-12) {
+        std::fill(bias.begin(), bias.end(), 1.0 / (n_qubits + 1.0));
+    } else {
+        const double sin_delta = std::sin(delta_theta);
+        const double omega = 1.5 * M_PI;
+        const double t2 = 1.0;
+        const double p = std::pow(2.0, std::abs(J / h) - 1.0) * (1.0 + sin_delta * std::cos(J * omega * t + theta) / (1.0 + std::sqrt(t / t2))) - 0.5;
+        if (p >= 1024) {
+            bias[0] = 1.0;
+        } else {
+            double tot_n = 0.0;
+            for (size_t q = 0U; q <= n_qubits; ++q) {
+                double n = 1.0 / ((n_qubits + 1) * std::pow(2.0, p * q));
+                bias[q] = n;
+                tot_n += n;
+            }
+            for (size_t q = 0U; q <= n_qubits; ++q) {
+                bias[q] /= tot_n;
+            }
+        }
+    }
+    if (J > 0) {
+        std::reverse(bias.begin(), bias.end());
+    }
+
+    return bias;
+}
+
+static inline std::string int_to_bitstring(BigInteger integer, size_t length) {
+    std::string s(length, '0');
+    for (size_t i = 0; i < length; ++i) {
+        if (integer & (1ULL << (length - 1U - i))) {
+            s[i] = '1';
+        }
+    }
+    return s;
+}
+
+static inline double closeness_like_bits(BigInteger perm, size_t n_rows, size_t n_cols) {
+    std::string bits = int_to_bitstring(perm, n_rows * n_cols);
+    double like_count = 0.0;
+    double total_edges = 0.0;
+    // grid neighbors (right and down)
+    for (size_t i = 0; i < n_rows; ++i) {
+        for (size_t j = 0; j < n_cols; ++j) {
+            char s = bits[i * n_cols + j];
+            char s_right = bits[i * n_cols + ((j + 1) % n_cols)];
+            char s_down = bits[((i + 1) % n_rows) * n_cols + j];
+            like_count += (s == s_right) ? 1.0 : -1.0;
+            like_count += (s == s_down) ? 1.0 : -1.0;
+            total_edges += 2.0;
+        }
+    }
+    return like_count / total_edges;
+}
+
+static inline double expected_closeness_weight(size_t n_rows, size_t n_cols, size_t hamming_weight) {
+    const size_t L = n_rows * n_cols;
+    auto comb = [](size_t n, size_t k) {
+        if ((k < 0) || (k > n)) {
+            return 0ULL;
+        }
+        if ((k == 0) || (k == n)) {
+            return 1ULL;
+        }
+        unsigned long long res = 1ULL;
+        for (size_t i = 1; i <= k; ++i) {
+            res = res * (n - k + i) / i;
+        }
+        return res;
+    };
+    const double same_pairs = comb(hamming_weight, 2U) + comb(L - hamming_weight, 2U);
+    const double total_pairs = comb(L, 2U);
+    const double mu_k = same_pairs / total_pairs;
+
+    return 2.0 * mu_k - 1.0;
+}
+
+std::vector<std::string> generate_tfim_samples_cpp(double J, double h, double z, double theta, double t, size_t n_qubits, size_t shots) {
+    // lattice dimensions
+    size_t n_rows = 1U;
+    size_t n_cols = n_qubits;
+    for (size_t c = std::floor(std::sqrt(n_qubits)); c >= 1; --c) {
+        if ((n_qubits % c) == 0U) {
+            n_rows = n_qubits / c;
+            n_cols = c;
+            break;
+        }
+    }
+
+    const std::vector<double> bias = probability_by_hamming_weight(J, h, z, theta, t, n_qubits);
+
+    // thresholds
+    std::vector<double> thresholds(n_qubits + 1);
+    double tot_prob = 0.0;
+    for (size_t q = 0U; q <= n_qubits; ++q) {
+        tot_prob += bias[q];
+        thresholds[q] = tot_prob;
+    }
+    thresholds[n_qubits] = 1.0;
+
+    std::uniform_real_distribution<double> dist(0.0, 1.0);
+
+    std::vector<BigInteger> samples;
+    samples.reserve(shots);
+
+    std::vector<int> qubits(n_qubits);
+    for (size_t i = 0U; i < n_qubits; ++i) {
+        qubits[i] = i;
+    }
+
+    std::vector<size_t> hamming_samples(n_qubits + 1U);
+    for (size_t s = 0U; s < shots; ++s) {
+        double mag_prob = dist(rng);
+        size_t m = 0U;
+        while (thresholds[m] < mag_prob) {
+            ++m;
+        }
+        ++hamming_samples[m];
+    }
+    for (size_t m = 0U; m < hamming_samples.size(); ++m){
+        double tot_cprob = 0.0;
+        size_t hs = hamming_samples[m];
+        std::vector<double> rands;
+        rands.reserve(hs);
+        for (size_t s = 0U; s < hs; ++s) {
+            rands.push_back(dist(rng));
+        }
+        std::sort(rands.begin(), rands.end());
+        // iterate combinations
+        std::vector<size_t> idx(m);
+        for (size_t i = 0U; i < m; ++i) {
+            idx[i] = i;
+        }
+        size_t s = 0U;
+        while (true) {
+            BigInteger candidate = 0U;
+            for (size_t pos : idx) {
+                candidate |= (BigInteger("1") << pos);
+            }
+            tot_cprob += (1.0 + closeness_like_bits(candidate, n_rows, n_cols)) /
+                         (1.0 + expected_closeness_weight(n_rows, n_cols, m));
+            while ((s < hs) && (rands[s] <= tot_cprob)) {
+                samples.push_back(candidate);
+                ++s;
+            }
+            if (s == hs) {
+                break;
+            }
+
+            // next combination
+            int64_t k = m - 1;
+            while ((k >= 0) && (idx[k] == (n_qubits - m + k))) {
+                --k;
+            }
+            if (k < 0) {
+                for (; s < hs; ++s) {
+                    samples.push_back(candidate);
+                }
+                break;
+            }
+            ++idx[k];
+            for (int64_t j = k + 1; j < m; ++j) {
+                idx[j] = idx[j - 1U] + 1;
+            }
+        }
+    }
+
+    auto dre = std::default_random_engine{rd()};
+    std::shuffle(samples.begin(), samples.end(), dre);
+
+    std::vector<std::string> output;
+    output.reserve(shots);
+    for (BigInteger& s : samples) {
+        output.push_back(boost::lexical_cast<std::string>(s));
+    }
+
+    return output;
+}
+
+double tfim_magnetization(double J, double h, double z, double theta, double t, size_t n_qubits) {
+    const std::vector<double> bias = probability_by_hamming_weight(J, h, z, theta, t, n_qubits);
+    double magnetization = 0.0;
+    const int64_t nqs = (int64_t)n_qubits;
+    const double nqd = (double)n_qubits;
+    for (int64_t q = 0U; q < bias.size(); ++q) {
+        const double mag = (nqs - 2 * q) / nqd;
+        magnetization += bias[q] * mag;
+    }
+
+    return magnetization;
+}
+
+double tfim_square_magnetization(double J, double h, double z, double theta, double t, size_t n_qubits) {
+    const std::vector<double> bias = probability_by_hamming_weight(J, h, z, theta, t, n_qubits);
+    double square_magnetization = 0.0;
+    const int64_t nqs = (int64_t)n_qubits;
+    const double nqd = (double)n_qubits;
+    for (int64_t q = 0U; q < bias.size(); ++q) {
+        const double mag = (nqs - 2 * q) / nqd;
+        square_magnetization += bias[q] * mag * mag;
+    }
+
+    return square_magnetization;
+}
+
+PYBIND11_MODULE(tfim_sampler, m) {
+    m.doc() = "PyQrackIsing TFIM sample generator";
+    m.def("_generate_tfim_samples", &generate_tfim_samples_cpp, "Generate measurement samples from globally-uniform TFIM");
+    m.def("_tfim_magnetization", &tfim_magnetization, "Magnetization expectation value from globally-uniform TFIM");
+    m.def("_tfim_square_magnetization", &tfim_square_magnetization, "Square magnetization expectation value from globally-uniform TFIM");
+}
+

pyqrackising-2.0.0/pyqrackising/generate_tfim_samples.py

@@ -0,0 +1,7 @@
+import tfim_sampler
+
+
+def generate_tfim_samples(
+    J=-1.0, h=2.0, z=4, theta=0.174532925199432957, t=5, n_qubits=56, shots=100
+):
+    return [int(s) for s in tfim_sampler._generate_tfim_samples(J, h, z, theta, t, n_qubits, shots)]