# Simulated Bifurcation for Python
[](https://pytorch.org/)
[](https://pypi.org/project/simulated-bifurcation/)
[](https://codecov.io/gh/bqth29/simulated-bifurcation-algorithm)
The **Simulated Bifurcation** (SB) algorithm is a fast and highly parallelizable state-of-the-art algorithm for combinatorial optimization inspired by quantum physics and spins dynamics. It relies on Hamiltonian quantum mechanics to find local minima of **Ising** problems. The last accuracy tests showed a median optimality gap of less than 1% on high-dimensional instances.
This open-source package utilizes **PyTorch** to leverage GPU computations, harnessing the high potential for parallelization offered by the SB algorithm.
It also provides an API to define Ising models or other NP-hard and NP-complete problems (QUBO, Karp problems, ...) that can be solved using the SB algorithm.
## ⚙️ Install
<table>
<thead>
<tr>
<th>Compute Plateform</th>
<th>CPU</th>
<th>GPU</th>
</tr>
</thead>
<tbody>
<tr>
<th>Instructions</th>
<td>
```console
pip install simulated-bifurcation
```
</td>
<td>
Install [PyTorch](https://pytorch.org/get-started/locally/) with GPU support
```console
pip install simulated-bifurcation
```
</td>
</tr>
</tbody>
</table>
## 🧪 The _Simulated Bifurcation_ (SB) algorithm
### Ising model
An Ising problem, given a null-diagonal square symmetrical matrix $J$ of size $N \times N$ and a vector $h$ of size $N$, consists in finding the spin vector $\mathbf{s} = (s_{1}, ... s_{N})$ called the _ground state_, (each $s_{i}$ being equal to either 1 or -1) such that the following value, called _Ising energy_, is minimal:
$$- \frac{1}{2} \sum_{i=1}^{N} \sum_{j=1}^{N} J_{ij}s_{i}s_{j} + \sum_{i=1}^{N} h_{i}s_{i}$$
This problem is known to be NP-hard but is very useful since it can be used in many sectors such as finance, transportation or chemistry or derived as other well-know optimization problems (QUBO, MAXCUT, Knapsack problem, etc.).
The Simulated Bifurcation algorithm was originally introduced to solve Ising problems by simulating the adiabatic evolution of spins in a quantum Hamiltonian system, but can also be generalized to a wider range of optimization problems.
### Usage on polynomial instances
The SB algorithm can be written as the minimization or maximization of multivariable polynomials of degree two, i.e. written as
$$\sum_{i=1}^{N} \sum_{j=1}^{N} M_{ij}x_{i}x_{j} + \sum_{i=1}^{N} v_{i}x_{i} + c$$
for which the $x_{i}$'s can be spins, binary or non-negative integer.
This can also be seen as the sum of a quadratic form, a linear form and a constant term and such a formulation is the basis of many optimization problems.
The `minimize` and `maximize` functions allow to respectively minimize and maximize the value of such polynomials for a given type of input values, relying on the SB algorithm. They both return the optimal polynomial value found by the SB algorithm, along with its associated input vector.
The input types must be passed to the `domain` argument:
- `spin` (default value) for a spin optimization: the optimal vector will only have ±1 values
- `binary` for a binary optimization: the optimal vector will only have 0 or 1 values
- `intX` for a `X`-bits encoded integer optimization: the optimal vector will only have integer value encoded with `X` bits or less, i.e. belonging to the range 0 to $2^{X} - 1$.
> For instance, 9-bits integer correspond to the `int9` input type and the accepted values span from 0 to 511.
```python
import simulated_bifurcation as sb
```
```python
matrix = torch.tensor([[0, 1, 2], [1, 0, -2], [2, -2, 0]])
vector = torch.tensor([-1, 0, 2])
constant = 2.0
```
#### Minimization
```python
# Spin minimization
spin_value, spin_vector = sb.minimize(matrix, vector, constant, domain='spin')
# Binary minimization
binary_value, binary_vector = sb.minimize(matrix, vector, constant, domain='binary')
# 3-bits integer minimization
int_value, int_vector = sb.minimize(matrix, vector, constant, domain='int3')
```
#### Maximization
```python
# Spin maximization
spin_value, spin_vector = sb.maximize(matrix, vector, constant, domain='spin')
# Binary maximization
binary_value, binary_vector = sb.maximize(matrix, vector, constant, domain='binary')
# 10-bits integer maximization
int_value, int_vector = sb.maximize(matrix, vector, constant, domain='int10')
```
> For both functions, only the matrix is required, the vector and constant terms are optional.
### Parallelization (multi-agent search)
The Simulated Bifurcation algorithm is highly parallelizable since it only relies on linear matrices equations. To take advantage of this property, this implementation offers the possibility to perform a multi-agent search of the optimal solution by evolving several spin vectors in parallel (each one being called an **agent**). The number of agents is set by the `agents` parameter in the `minimize` and `maximize` functions.
> **💡 Tip:** it is faster to run once the algorithm with N agents than to run N times the algorithm with only one agent.
```python
# Efficient computation ✔️
sb.minimize(matrix, agents=100)
# Slower cumbersome computation ❌
for _ in range(100):
sb.minimize(matrix, agents=1)
```
### GPU computation
This parallelization of the algorithm can also be utilized by performing calculations on GPUs to speed them up significantly. To do this, simply specify the calculation `device` argument to `cuda` when instantiating an Ising model:
```python
sb.minimize(matrix, device='cuda')
```
### Early stopping
The Simulated Bifurcation algorithm stops after a certain number of iterations, defined by the parameter `max_steps` of the `minimize` and `maximize` functions. However, this implementation comes with the possibility to perform early stopping and save computation time by defining convergence conditions.
At regular intervals, the energy of the agents is sampled and compared with its previous value to calculate their stability period. If an agent's stability period exceeds a convergence threshold, it is considered to have converged and its value is frozen. If all agents converge before the maximum number of iterations has been reached, the algorithm stops.
- The sampling period and the convergence threshold are respectively set using the `sampling_period` and `convergence_threshold` parameters of the `minimize` and `maximize` functions.
- To use early stopping in the SB algorithm, set the `use_window` parameter to `True`.
- If only some agents have converged when the maximum number of iterations is reached, the algorithm stops and only these agents are considered in the results.
```python
# Stop with maximal iterations
sb.minimize(matrix, max_steps=10000)
# Early stopping
sb.minimize(
matrix,
sampling_period=30,
convergence_threshold=50,
use_window=True,
)
```
### Optimization results
By default, SB returns the best vector and objective value found. However, it is also possible to configure it to so it returns all the vectors for each agent with the associated objective value. To do so, the `best_only` parameter of the `minimize` and `maximize` functions must be set to `False` (default is `True`).
```python
best_vector, best_value = sb.minimize(matrix, best_only=True)
vectors, values = sb.maximize(matrix, best_only=False)
```
## 💡 Advanced usages
This section deals with a more complex use of the SB algorithm, as it is closer to the quantum theory from which it is derived. To better understand the significance of the subjects at stake, we recommend reading the theory behind the SB algorithm by Goto _et al._.
- Goto, H., Tatsumura, K., & Dixon, A. R. (2019). Combinatorial optimization by simulating adiabatic bifurcations in nonlinear Hamiltonian systems. _Science advances, 5_(4), eaav2372.
- Kanao, T., & Goto, H. (2022). Simulated bifurcation assisted by thermal fluctuation. _Communications Physics, 5_(1), 153.
- Goto, H., Endo, K., Suzuki, M., Sakai, Y., Kanao, T., Hamakawa, Y., ... & Tatsumura, K. (2021). High-performance combinatorial optimization based on classical mechanics. _Science Advances, 7_(6), eabe7953.
### SB Algorithm modes
The SB algorithm is available in four different versions (Goto _et al._) that result in small variations in the algorithm general operation. The four modes are:
1. **Ballistic SB (bSB)**: uses the particles' position for the SB matrix computations; usually faster but less accurate.
2. **Discrete SB (dSB)**: uses the sign of the particles' position for the SB matrix computations; usually slower but more accurate.
3. **Heated ballistic SB (HbSB)**: uses the bSB algorithm with a supplementary non-symplectic term to allow a higher solution space exploration.
4. **Heated discrete SB (HdSB)**: uses the dSB algorithm with a supplementary non-symplectic term to allow a higher solution space exploration.
These mode can be selected setting the parameters `ballistic` and `heated` to either `True` or `False` in the `Ising.optimize` method or the `minimize`/`maximize` functions.
```python
sb.minimize(matrix, ballistic=True, heated=False) # bSB
sb.minimize(matrix, ballistic=False, heated=True) # HdSB
sb.maximize(matrix, ballistic=False, heated=False) # dSB
sb.maximize(matrix, ballistic=True, heated=True) # HbSB
```
### SB Algorithm's hyperparameters setting
The SB algorithm has a set of hyperparameters corresponding to physical constants derived from quantum theory, which have been fine-tuned (Goto _et al._) to give the best results most of the time. Nevertheless, the relevance of specific hyperparameters may vary depending on the properties of the instances. For this purpose, the `set_env` function can be used to modify their value.
```python
# Custom hyperparameters values
sb.set_env(time_step=.1, pressure_slope=.01, heat_coefficient=.06)
# Default hyperparameters values
sb.reset_env()
```
### Derived optimization models
A lot of mathematical problems (QUBO, Travelling Salesman Problem, MAXCUT, ...) can be written as order-two multivariate polynomials problems, and thus can be solved using the Simulated Bifurcation algorithm. Some of them are already implemented in the `models` module:
**🔬 Physics**
- Ising model
**📐 Mathematics**
- Quadratic Unconstrained Binary Optimization (QUBO)
- Number partitioning
**💸 Finance**
- Markowitz model
### Custom models
You are also free to create your own models using our API. Depending on the type of model you wish to implement, you cen create a subclass of one of the `SpinQuadraticPolynomial`, `BinaryQuadraticPolynomial` or `IntegerQuadraticPolynomial` APIs to quickly and efficiently link your custom model to an Ising problem and solve it using the SB algorithm.
The advantage of doing so is that your model can directly call the `optimize` method that it inherits from the `BaseMultivariateQuadraticPolynomial` interface without having to redefine it.
For instance, here is how the QUBO model was implemented:
> The QUBO problem consists, given an upper triangular matrix $Q$, in finding the binary vector that minimizes the value
> $$\sum_{i=1}^{N} \sum_{j=1}^{N} Q_{ij}x_{i}x_{j}$$
```python
from simulated_bifurcation import BinaryQuadraticPolynomial
class QUBO(BinaryQuadraticPolynomial):
def __init__(self, Q, dtype, device) -> None:
super().__init__(matrix=Q, vector=None, constant=None,
dtype=dtype, device=device)
self.Q = self.matrix
```
> You can check Andrew Lucas' paper on Ising formulations of NP-complete and NP-hard problems, including all of Karp's 21 NP-complete problems.
>
> [🔎 Lucas, A. (2014). Ising formulations of many NP problems. _Frontiers in physics, 2_, 5.](https://www.frontiersin.org/articles/10.3389/fphy.2014.00005/full)
## 🔗 Cite this work
If you are using this code for your own projects please cite our work:
[comment]: # (!MDC{begin}{BibTeX})
```bibtex
@software{Ageron_Simulated_Bifurcation_SB_2023,
author = {Ageron, Romain and Bouquet, Thomas and Pugliese, Lorenzo},
month = nov,
title = {{Simulated Bifurcation (SB) algorithm for Python}},
url = {https://github.com/bqth29/simulated-bifurcation-algorithm},
version = {1.2.1},
year = {2023},
}
```
[comment]: # (!MDC{end}{BibTeX})
Raw data
{
"_id": null,
"home_page": "https://github.com/bqth29/simulated-bifurcation-algorithm",
"name": "simulated-bifurcation",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "",
"keywords": "",
"author": "",
"author_email": "",
"download_url": "https://files.pythonhosted.org/packages/24/74/f3e565ce80e3d3761a6917b5ac2f8bbe1622693b6823f5b082fbde1c3849/simulated-bifurcation-1.2.1.tar.gz",
"platform": null,
"description": "# Simulated Bifurcation for Python\n\n[](https://pytorch.org/)\n[](https://pypi.org/project/simulated-bifurcation/)\n[](https://codecov.io/gh/bqth29/simulated-bifurcation-algorithm)\n\n\n\nThe **Simulated Bifurcation** (SB) algorithm is a fast and highly parallelizable state-of-the-art algorithm for combinatorial optimization inspired by quantum physics and spins dynamics. It relies on Hamiltonian quantum mechanics to find local minima of **Ising** problems. The last accuracy tests showed a median optimality gap of less than 1% on high-dimensional instances.\n\nThis open-source package utilizes **PyTorch** to leverage GPU computations, harnessing the high potential for parallelization offered by the SB algorithm.\n\nIt also provides an API to define Ising models or other NP-hard and NP-complete problems (QUBO, Karp problems, ...) that can be solved using the SB algorithm.\n\n## \u2699\ufe0f Install\n\n<table>\n<thead>\n<tr>\n<th>Compute Plateform</th>\n<th>CPU</th>\n<th>GPU</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<th>Instructions</th>\n<td>\n\n```console\npip install simulated-bifurcation \n```\n\n</td>\n<td>\n\n \nInstall [PyTorch](https://pytorch.org/get-started/locally/) with GPU support\n\n```console\npip install simulated-bifurcation \n```\n\n</td>\n</tr>\n</tbody>\n</table>\n\n## \ud83e\uddea The _Simulated Bifurcation_ (SB) algorithm\n\n### Ising model\n\nAn Ising problem, given a null-diagonal square symmetrical matrix $J$ of size $N \\times N$ and a vector $h$ of size $N$, consists in finding the spin vector $\\mathbf{s} = (s_{1}, ... s_{N})$ called the _ground state_, (each $s_{i}$ being equal to either 1 or -1) such that the following value, called _Ising energy_, is minimal:\n\n$$- \\frac{1}{2} \\sum_{i=1}^{N} \\sum_{j=1}^{N} J_{ij}s_{i}s_{j} + \\sum_{i=1}^{N} h_{i}s_{i}$$\n\nThis problem is known to be NP-hard but is very useful since it can be used in many sectors such as finance, transportation or chemistry or derived as other well-know optimization problems (QUBO, MAXCUT, Knapsack problem, etc.).\n\nThe Simulated Bifurcation algorithm was originally introduced to solve Ising problems by simulating the adiabatic evolution of spins in a quantum Hamiltonian system, but can also be generalized to a wider range of optimization problems.\n\n### Usage on polynomial instances\n\nThe SB algorithm can be written as the minimization or maximization of multivariable polynomials of degree two, i.e. written as\n\n$$\\sum_{i=1}^{N} \\sum_{j=1}^{N} M_{ij}x_{i}x_{j} + \\sum_{i=1}^{N} v_{i}x_{i} + c$$\n\nfor which the $x_{i}$'s can be spins, binary or non-negative integer.\n\nThis can also be seen as the sum of a quadratic form, a linear form and a constant term and such a formulation is the basis of many optimization problems.\n\nThe `minimize` and `maximize` functions allow to respectively minimize and maximize the value of such polynomials for a given type of input values, relying on the SB algorithm. They both return the optimal polynomial value found by the SB algorithm, along with its associated input vector.\n\nThe input types must be passed to the `domain` argument:\n\n- `spin` (default value) for a spin optimization: the optimal vector will only have \u00b11 values\n- `binary` for a binary optimization: the optimal vector will only have 0 or 1 values\n- `intX` for a `X`-bits encoded integer optimization: the optimal vector will only have integer value encoded with `X` bits or less, i.e. belonging to the range 0 to $2^{X} - 1$.\n\n> For instance, 9-bits integer correspond to the `int9` input type and the accepted values span from 0 to 511.\n\n```python\nimport simulated_bifurcation as sb\n```\n\n```python\nmatrix = torch.tensor([[0, 1, 2], [1, 0, -2], [2, -2, 0]])\nvector = torch.tensor([-1, 0, 2])\nconstant = 2.0\n```\n\n#### Minimization\n\n```python\n# Spin minimization\nspin_value, spin_vector = sb.minimize(matrix, vector, constant, domain='spin')\n\n# Binary minimization\nbinary_value, binary_vector = sb.minimize(matrix, vector, constant, domain='binary')\n\n# 3-bits integer minimization\nint_value, int_vector = sb.minimize(matrix, vector, constant, domain='int3')\n```\n\n#### Maximization\n\n```python\n# Spin maximization\nspin_value, spin_vector = sb.maximize(matrix, vector, constant, domain='spin')\n\n# Binary maximization\nbinary_value, binary_vector = sb.maximize(matrix, vector, constant, domain='binary')\n\n# 10-bits integer maximization\nint_value, int_vector = sb.maximize(matrix, vector, constant, domain='int10')\n```\n\n> For both functions, only the matrix is required, the vector and constant terms are optional.\n\n### Parallelization (multi-agent search)\n\nThe Simulated Bifurcation algorithm is highly parallelizable since it only relies on linear matrices equations. To take advantage of this property, this implementation offers the possibility to perform a multi-agent search of the optimal solution by evolving several spin vectors in parallel (each one being called an **agent**). The number of agents is set by the `agents` parameter in the `minimize` and `maximize` functions.\n\n> **\ud83d\udca1 Tip:** it is faster to run once the algorithm with N agents than to run N times the algorithm with only one agent.\n\n```python\n# Efficient computation \u2714\ufe0f\nsb.minimize(matrix, agents=100)\n\n# Slower cumbersome computation \u274c\nfor _ in range(100):\n sb.minimize(matrix, agents=1)\n```\n\n### GPU computation\n\nThis parallelization of the algorithm can also be utilized by performing calculations on GPUs to speed them up significantly. To do this, simply specify the calculation `device` argument to `cuda` when instantiating an Ising model:\n\n```python\nsb.minimize(matrix, device='cuda')\n```\n\n### Early stopping\n\nThe Simulated Bifurcation algorithm stops after a certain number of iterations, defined by the parameter `max_steps` of the `minimize` and `maximize` functions. However, this implementation comes with the possibility to perform early stopping and save computation time by defining convergence conditions.\n\nAt regular intervals, the energy of the agents is sampled and compared with its previous value to calculate their stability period. If an agent's stability period exceeds a convergence threshold, it is considered to have converged and its value is frozen. If all agents converge before the maximum number of iterations has been reached, the algorithm stops.\n\n- The sampling period and the convergence threshold are respectively set using the `sampling_period` and `convergence_threshold` parameters of the `minimize` and `maximize` functions.\n- To use early stopping in the SB algorithm, set the `use_window` parameter to `True`.\n- If only some agents have converged when the maximum number of iterations is reached, the algorithm stops and only these agents are considered in the results.\n\n```python\n# Stop with maximal iterations\nsb.minimize(matrix, max_steps=10000)\n\n# Early stopping\nsb.minimize(\n matrix,\n sampling_period=30,\n convergence_threshold=50,\n use_window=True,\n)\n```\n\n### Optimization results\n\nBy default, SB returns the best vector and objective value found. However, it is also possible to configure it to so it returns all the vectors for each agent with the associated objective value. To do so, the `best_only` parameter of the `minimize` and `maximize` functions must be set to `False` (default is `True`).\n\n```python\nbest_vector, best_value = sb.minimize(matrix, best_only=True)\nvectors, values = sb.maximize(matrix, best_only=False)\n```\n\n## \ud83d\udca1 Advanced usages\n\nThis section deals with a more complex use of the SB algorithm, as it is closer to the quantum theory from which it is derived. To better understand the significance of the subjects at stake, we recommend reading the theory behind the SB algorithm by Goto _et al._.\n\n- Goto, H., Tatsumura, K., & Dixon, A. R. (2019). Combinatorial optimization by simulating adiabatic bifurcations in nonlinear Hamiltonian systems. _Science advances, 5_(4), eaav2372.\n- Kanao, T., & Goto, H. (2022). Simulated bifurcation assisted by thermal fluctuation. _Communications Physics, 5_(1), 153.\n- Goto, H., Endo, K., Suzuki, M., Sakai, Y., Kanao, T., Hamakawa, Y., ... & Tatsumura, K. (2021). High-performance combinatorial optimization based on classical mechanics. _Science Advances, 7_(6), eabe7953.\n\n### SB Algorithm modes\n\nThe SB algorithm is available in four different versions (Goto _et al._) that result in small variations in the algorithm general operation. The four modes are:\n\n1. **Ballistic SB (bSB)**: uses the particles' position for the SB matrix computations; usually faster but less accurate.\n2. **Discrete SB (dSB)**: uses the sign of the particles' position for the SB matrix computations; usually slower but more accurate.\n3. **Heated ballistic SB (HbSB)**: uses the bSB algorithm with a supplementary non-symplectic term to allow a higher solution space exploration.\n4. **Heated discrete SB (HdSB)**: uses the dSB algorithm with a supplementary non-symplectic term to allow a higher solution space exploration.\n\nThese mode can be selected setting the parameters `ballistic` and `heated` to either `True` or `False` in the `Ising.optimize` method or the `minimize`/`maximize` functions.\n\n```python\nsb.minimize(matrix, ballistic=True, heated=False) # bSB\nsb.minimize(matrix, ballistic=False, heated=True) # HdSB\n\nsb.maximize(matrix, ballistic=False, heated=False) # dSB\nsb.maximize(matrix, ballistic=True, heated=True) # HbSB\n```\n\n### SB Algorithm's hyperparameters setting\n\nThe SB algorithm has a set of hyperparameters corresponding to physical constants derived from quantum theory, which have been fine-tuned (Goto _et al._) to give the best results most of the time. Nevertheless, the relevance of specific hyperparameters may vary depending on the properties of the instances. For this purpose, the `set_env` function can be used to modify their value.\n\n```python\n# Custom hyperparameters values\nsb.set_env(time_step=.1, pressure_slope=.01, heat_coefficient=.06)\n\n# Default hyperparameters values\nsb.reset_env()\n```\n\n### Derived optimization models\n\nA lot of mathematical problems (QUBO, Travelling Salesman Problem, MAXCUT, ...) can be written as order-two multivariate polynomials problems, and thus can be solved using the Simulated Bifurcation algorithm. Some of them are already implemented in the `models` module:\n\n**\ud83d\udd2c Physics**\n\n- Ising model\n\n**\ud83d\udcd0 Mathematics**\n\n- Quadratic Unconstrained Binary Optimization (QUBO)\n- Number partitioning\n\n**\ud83d\udcb8 Finance**\n\n- Markowitz model\n\n### Custom models\n\nYou are also free to create your own models using our API. Depending on the type of model you wish to implement, you cen create a subclass of one of the `SpinQuadraticPolynomial`, `BinaryQuadraticPolynomial` or `IntegerQuadraticPolynomial` APIs to quickly and efficiently link your custom model to an Ising problem and solve it using the SB algorithm.\n\nThe advantage of doing so is that your model can directly call the `optimize` method that it inherits from the `BaseMultivariateQuadraticPolynomial` interface without having to redefine it.\n\nFor instance, here is how the QUBO model was implemented:\n\n> The QUBO problem consists, given an upper triangular matrix $Q$, in finding the binary vector that minimizes the value\n> $$\\sum_{i=1}^{N} \\sum_{j=1}^{N} Q_{ij}x_{i}x_{j}$$\n\n```python\nfrom simulated_bifurcation import BinaryQuadraticPolynomial\n\n\nclass QUBO(BinaryQuadraticPolynomial):\n\n def __init__(self, Q, dtype, device) -> None:\n super().__init__(matrix=Q, vector=None, constant=None,\n dtype=dtype, device=device)\n self.Q = self.matrix\n```\n\n> You can check Andrew Lucas' paper on Ising formulations of NP-complete and NP-hard problems, including all of Karp's 21 NP-complete problems.\n> \n> [\ud83d\udd0e Lucas, A. (2014). Ising formulations of many NP problems. _Frontiers in physics, 2_, 5.](https://www.frontiersin.org/articles/10.3389/fphy.2014.00005/full)\n\n## \ud83d\udd17 Cite this work\n\nIf you are using this code for your own projects please cite our work:\n\n[comment]: # (!MDC{begin}{BibTeX})\n\n```bibtex\n@software{Ageron_Simulated_Bifurcation_SB_2023,\n author = {Ageron, Romain and Bouquet, Thomas and Pugliese, Lorenzo},\n month = nov,\n title = {{Simulated Bifurcation (SB) algorithm for Python}},\n url = {https://github.com/bqth29/simulated-bifurcation-algorithm},\n version = {1.2.1},\n year = {2023},\n}\n```\n\n[comment]: # (!MDC{end}{BibTeX})\n",
"bugtrack_url": null,
"license": "",
"summary": "Efficient implementation of the quantum-inspired Simulated Bifurcation (SB) algorithm to solve Ising-like problems.",
"version": "1.2.1",
"project_urls": {
"Homepage": "https://github.com/bqth29/simulated-bifurcation-algorithm"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "47ab3c4181ef340cd79c8e6e21679e77d311f857c4e37521b3c1c026720a9240",
"md5": "9d4173bb669b92de1e82bf49e78307bc",
"sha256": "db78520316666477d2bfdb16cb9b7cc632da59b4dd1461e871370f9e88447c53"
},
"downloads": -1,
"filename": "simulated_bifurcation-1.2.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "9d4173bb669b92de1e82bf49e78307bc",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 47525,
"upload_time": "2023-11-23T18:03:14",
"upload_time_iso_8601": "2023-11-23T18:03:14.000052Z",
"url": "https://files.pythonhosted.org/packages/47/ab/3c4181ef340cd79c8e6e21679e77d311f857c4e37521b3c1c026720a9240/simulated_bifurcation-1.2.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2474f3e565ce80e3d3761a6917b5ac2f8bbe1622693b6823f5b082fbde1c3849",
"md5": "040ecbd01ec28ba53f9c1d1e5834f6cc",
"sha256": "026cc7dc1262b3316475aeccfb6d3ef8614b32be8458f47c5a7a182fab91447f"
},
"downloads": -1,
"filename": "simulated-bifurcation-1.2.1.tar.gz",
"has_sig": false,
"md5_digest": "040ecbd01ec28ba53f9c1d1e5834f6cc",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 44036,
"upload_time": "2023-11-23T18:03:15",
"upload_time_iso_8601": "2023-11-23T18:03:15.773576Z",
"url": "https://files.pythonhosted.org/packages/24/74/f3e565ce80e3d3761a6917b5ac2f8bbe1622693b6823f5b082fbde1c3849/simulated-bifurcation-1.2.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-11-23 18:03:15",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "bqth29",
"github_project": "simulated-bifurcation-algorithm",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "black",
"specs": [
[
"==",
"23.7.0"
]
]
},
{
"name": "click",
"specs": [
[
"==",
"8.1.6"
]
]
},
{
"name": "colorama",
"specs": [
[
"==",
"0.4.6"
]
]
},
{
"name": "coverage",
"specs": [
[
"==",
"7.2.7"
]
]
},
{
"name": "exceptiongroup",
"specs": [
[
"==",
"1.1.2"
]
]
},
{
"name": "filelock",
"specs": [
[
"==",
"3.12.2"
]
]
},
{
"name": "flake8",
"specs": [
[
"==",
"6.1.0"
]
]
},
{
"name": "iniconfig",
"specs": [
[
"==",
"2.0.0"
]
]
},
{
"name": "isort",
"specs": [
[
"==",
"5.12.0"
]
]
},
{
"name": "Jinja2",
"specs": [
[
"==",
"3.1.2"
]
]
},
{
"name": "MarkupSafe",
"specs": [
[
"==",
"2.1.3"
]
]
},
{
"name": "mccabe",
"specs": [
[
"==",
"0.7.0"
]
]
},
{
"name": "mpmath",
"specs": [
[
"==",
"1.3.0"
]
]
},
{
"name": "mypy-extensions",
"specs": [
[
"==",
"1.0.0"
]
]
},
{
"name": "networkx",
"specs": [
[
"==",
"3.1"
]
]
},
{
"name": "numpy",
"specs": [
[
"==",
"1.25.2"
]
]
},
{
"name": "packaging",
"specs": [
[
"==",
"23.1"
]
]
},
{
"name": "pathspec",
"specs": [
[
"==",
"0.11.2"
]
]
},
{
"name": "platformdirs",
"specs": [
[
"==",
"3.10.0"
]
]
},
{
"name": "pluggy",
"specs": [
[
"==",
"1.2.0"
]
]
},
{
"name": "pycodestyle",
"specs": [
[
"==",
"2.11.0"
]
]
},
{
"name": "pyflakes",
"specs": [
[
"==",
"3.1.0"
]
]
},
{
"name": "pytest",
"specs": [
[
"==",
"7.4.0"
]
]
},
{
"name": "sympy",
"specs": [
[
"==",
"1.12"
]
]
},
{
"name": "tomli",
"specs": [
[
"==",
"2.0.1"
]
]
},
{
"name": "torch",
"specs": [
[
"==",
"2.0.1"
]
]
},
{
"name": "tqdm",
"specs": [
[
"==",
"4.66.1"
]
]
},
{
"name": "typing_extensions",
"specs": [
[
"==",
"4.7.1"
]
]
}
],
"lcname": "simulated-bifurcation"
}
JSON
