diff --git a/.github/workflows/test_dev.yml b/.github/workflows/test_dev.yml index f2c7b3d84..da339fd64 100644 --- a/.github/workflows/test_dev.yml +++ b/.github/workflows/test_dev.yml @@ -63,7 +63,7 @@ jobs: run: | source env/bin/activate ipython kernel install --name "env" --user - pytest tests/ src/*/tests -m 'not (qpu or sim)' --cov -n auto + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or sim)' --cov -n auto - name: Upload coverage reports to Codecov with GitHub Action uses: codecov/codecov-action@v3 with: diff --git a/.github/workflows/test_main_linux.yml b/.github/workflows/test_main_linux.yml index 65b39c541..158947692 100644 --- a/.github/workflows/test_main_linux.yml +++ b/.github/workflows/test_main_linux.yml @@ -67,7 +67,7 @@ jobs: run: | source env/bin/activate ipython kernel install --name "env" --user - pytest tests/ src/*/tests -m 'not (qpu or sim)' --cov --cov-report=xml:coverage.xml + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or sim)' --cov --cov-report=xml:coverage.xml - name: Upload coverage reports to Codecov with GitHub Action uses: codecov/codecov-action@v3 diff --git a/.github/workflows/test_main_macos.yml b/.github/workflows/test_main_macos.yml index f1a3fc0fd..c60dd7d9b 100644 --- a/.github/workflows/test_main_macos.yml +++ b/.github/workflows/test_main_macos.yml @@ -56,4 +56,4 @@ jobs: run: | source env/bin/activate ipython kernel install --user --name "env" - pytest tests/ src/*/tests -m 'not (qpu or api or docker_aws or braket_api or sim)' + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or api or docker_aws or braket_api or sim)' diff --git a/.github/workflows/test_main_windows.yml b/.github/workflows/test_main_windows.yml index 3fcd9d93e..061e1929e 100644 --- a/.github/workflows/test_main_windows.yml +++ b/.github/workflows/test_main_windows.yml @@ -63,5 +63,5 @@ jobs: run: | .\env\Scripts\Activate.ps1 ipython kernel install --name "env" --user - pytest \tests -m 'not (qpu or api or docker_aws or braket_api or sim)' + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or api or docker_aws or braket_api or sim)' Get-ChildItem -Directory | ForEach-Object { pytest $_.FullName -m 'not (qpu or api or docker_aws or braket_api or sim)'} diff --git a/Makefile b/Makefile index e144f4486..72305c260 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,7 @@ local-install: pip install ./src/openqaoa-core pip install ./src/openqaoa-qiskit - pip install ./src/openqaoa-pyquil +# pip install ./src/openqaoa-pyquil pip install ./src/openqaoa-braket pip install ./src/openqaoa-azure pip install . @@ -14,7 +14,7 @@ local-install: dev-install: pip install -e ./src/openqaoa-core pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . @@ -23,7 +23,7 @@ dev-install: dev-install-tests: pip install -e ./src/openqaoa-core[tests] pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . @@ -32,7 +32,7 @@ dev-install-tests: dev-install-docs: pip install -e ./src/openqaoa-core[docs] pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . @@ -41,7 +41,7 @@ dev-install-docs: dev-install-all: pip install -e ./src/openqaoa-core[all] pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . diff --git a/docs/source/changelog.md b/docs/source/changelog.md new file mode 100644 index 000000000..28b04b845 --- /dev/null +++ b/docs/source/changelog.md @@ -0,0 +1,4 @@ +# CHANGELOG + +```{include} ../../CHANGELOG.md +``` \ No newline at end of file diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst deleted file mode 100644 index 7ac20a342..000000000 --- a/docs/source/changelog.rst +++ /dev/null @@ -1,7 +0,0 @@ -Changelog -========= - -`v0.0.1-beta `__ (July 11, 2022) ------------------------------------------------------------------------------------------------------ - -- Initial beta release \ No newline at end of file diff --git a/docs/source/conf.py b/docs/source/conf.py index 9bc69cb66..892317a6e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -56,6 +56,8 @@ "IPython.sphinxext.ipython_console_highlighting", "nbsphinx", "sphinx.ext.intersphinx", + "myst_parser", + # "myst_nb", ] autodoc_mock_imports = [ @@ -124,3 +126,6 @@ # def setup(app): # app.connect(skip) + +# pygments_style = 'sphinx' +# suppress_warnings = ["myst_header"] \ No newline at end of file diff --git a/docs/source/openqaoa_azure/openqaoa_azure_install.rst b/docs/source/openqaoa_azure/openqaoa_azure_install.rst index d5af9b0fc..3e7c6b63c 100644 --- a/docs/source/openqaoa_azure/openqaoa_azure_install.rst +++ b/docs/source/openqaoa_azure/openqaoa_azure_install.rst @@ -14,6 +14,6 @@ You can install the latest version of openqaoa-azure directly from PyPi. We reco Installation instructions for Developers ---------------------------------------- -OpenQAOA-Azure does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Azure does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/docs/source/openqaoa_braket/openqaoa_braket_install.rst b/docs/source/openqaoa_braket/openqaoa_braket_install.rst index 42f1a24b3..e940bb179 100644 --- a/docs/source/openqaoa_braket/openqaoa_braket_install.rst +++ b/docs/source/openqaoa_braket/openqaoa_braket_install.rst @@ -3,7 +3,7 @@ OpenQAOA Braket Installation Install via PyPI ---------------- -You can install the latest version of openqaoa-braket directly from PyPi. We recommend creating a virtual environment with `python>=3.8` first and then simply pip install openqaoa-braket with the following command. +You can install the latest version of openqaoa-braket directly from PyPi. We recommend creating a virtual environment with ``python>=3.8`` first and then simply pip install openqaoa-braket with the following command. **NOTE:** Installing ``openqaoa-braket`` installs ``openqaoa-core`` by default @@ -14,6 +14,6 @@ You can install the latest version of openqaoa-braket directly from PyPi. We rec Installation instructions for Developers ---------------------------------------- -OpenQAOA-Braket does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Braket does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/docs/source/openqaoa_core/openqaoa_core_install.rst b/docs/source/openqaoa_core/openqaoa_core_install.rst index 352b37ad9..dd98ba1ac 100644 --- a/docs/source/openqaoa_core/openqaoa_core_install.rst +++ b/docs/source/openqaoa_core/openqaoa_core_install.rst @@ -16,6 +16,6 @@ You can install the latest version of openqaoa-core directly from PyPi. We recom Installation instructions for Developers ---------------------------------------- -OpenQAOA-Core does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Core does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/docs/source/openqaoa_metapackage_install.rst b/docs/source/openqaoa_metapackage_install.rst index 80d95cfe0..c9e797acc 100644 --- a/docs/source/openqaoa_metapackage_install.rst +++ b/docs/source/openqaoa_metapackage_install.rst @@ -1,49 +1,64 @@ OpenQAOA Metapackage Installation ================================= +.. _openqaoa: The following instructions install OpenQAOA along with all optional plugins -OpenQAOA is divided into separately installable plugins based on the requirements of the user. The core elements of the package are placed in `openqaoa-core` which comes pre-installed with each flavour of OpenQAOA. +OpenQAOA is divided into separately installable plugins based on the requirements of the user. The core elements of the package are placed in ``openqaoa-core`` which comes pre-installed with each flavour of OpenQAOA. -Currently, OpenQAOA supports the following backends and each can be installed exclusively with the exception of `openqaoa-azure` which installs `openqaoa-qiskit` as an additional requirement because Azure backends support circuit submissions via `qiskit`. -- `openqaoa-braket` for AWS Braket -- `openqaoa-azure` for Microsoft Azure Quantum -- `openqaoa-pyquil` for Rigetti Pyquil -- `openqaoa-qiskit` for IBM Qiskit +Currently, OpenQAOA supports the following backends and each can be installed exclusively with the exception of ``openqaoa-azure`` which installs ``openqaoa-qiskit`` as an additional requirement because Azure backends support circuit submissions via `qiskit`. + +- ``openqaoa-braket`` for AWS Braket +- ``openqaoa-azure`` for Microsoft Azure Quantum +- ``openqaoa-pyquil`` for Rigetti Pyquil +- ``openqaoa-qiskit`` for IBM Qiskit The OpenQAOA metapackage allows you to install all OpenQAOA plug-ins together. Install via PyPI ---------------- You can install the latest version of OpenQAOA directly from PyPI. First, create a virtual environment with python3.8, 3.9, 3.10 and then pip install openqaoa with the following command -``` +.. code-block:: bash + pip install openqaoa -``` + Install via git clone --------------------- Alternatively, you can install OpenQAOA manually from the GitHub repository by following the instructions below. -**NOTE:** We recommend creating a python virtual environment for this project using a python environment manager, for instance Anaconda. Instructions can be found [here](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-with-commands). Make sure to use **python 3.8** (or newer) for the environment. +**NOTE:** We recommend creating a python virtual environment for this project using a python environment manager, for instance Anaconda. Instructions can be found `here `_. Make sure to use **python 3.8** (or newer) for the environment. + 1. Clone the git repository: -``` -git clone https://github.com/entropicalabs/openqaoa.git -``` -2. After cloning the repository `cd openqaoa` and pip install the package with instructions from the Makefile as follows -``` -make local-install -``` + +.. code-block:: bash + + git clone https://github.com/entropicalabs/openqaoa.git + + +2. After cloning the repository ``cd openqaoa`` and pip install the package with instructions from the Makefile as follows + +.. code-block:: bash + + make local-install + Installation instructions for Developers ---------------------------------------- -Users can install OpenQAOA in the developer mode via the Makefile. For a clean editable install of the package run the following command from the `openqaoa` folder. -``` -make dev-install -``` -The package can be installed as an editable with extra requirements defined in the `setup.py`. If you would like to install the extra requirements to be able run the tests module or generate the docs, you can run the following +Users can install OpenQAOA in the developer mode via the Makefile. For a clean editable install of the package run the following command from the ``openqaoa`` folder. + +.. code-block:: bash + + make dev-install + + +The package can be installed as an editable with extra requirements defined in the ``setup.py``. If you would like to install the extra requirements to be able run the tests module or generate the docs, you can run the following + +.. code-block:: bash + + make dev-install-x + -``` -make dev-install-x, with x = {tests, docs, all} -``` +with x = {tests, docs, all} -Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file +Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! diff --git a/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst b/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst index 484f67ece..a7b8f3c12 100644 --- a/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst +++ b/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst @@ -4,7 +4,7 @@ OpenQAOA Pyquil Installation Install via PyPI ---------------- -You can install the latest version of openqaoa-pyquil directly from PyPi. We recommend creating a virtual environment with `python>=3.8` first and then simply pip install openqaoa-pyquil with the following command. +You can install the latest version of openqaoa-pyquil directly from PyPi. We recommend creating a virtual environment with ``python>=3.8`` first and then simply pip install openqaoa-pyquil with the following command. **NOTE:** Installing ``openqaoa-pyquil`` installs ``openqaoa-core`` by default @@ -15,6 +15,6 @@ You can install the latest version of openqaoa-pyquil directly from PyPi. We rec Installation instructions for Developers ---------------------------------------- -OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! diff --git a/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst b/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst index cebb0328b..af822b7c8 100644 --- a/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst +++ b/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst @@ -4,7 +4,7 @@ OpenQAOA Qiskit Installation Install via PyPI ---------------- -You can install the latest version of openqaoa-qiskit directly from PyPi. We recommend creating a virtual environment with `python>=3.8` first and then simply pip install openqaoa-qiskit with the following command. +You can install the latest version of openqaoa-qiskit directly from PyPi. We recommend creating a virtual environment with ``python>=3.8`` first and then simply pip install openqaoa-qiskit with the following command. **NOTE:** Installing ``openqaoa-qiskit`` installs ``openqaoa-core`` by default @@ -15,6 +15,6 @@ You can install the latest version of openqaoa-qiskit directly from PyPi. We rec Installation instructions for Developers ---------------------------------------- -OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/examples/community_tutorials/02_docplex_example.ipynb b/examples/community_tutorials/02_docplex_example.ipynb index 6264780cd..955abcf8c 100644 --- a/examples/community_tutorials/02_docplex_example.ipynb +++ b/examples/community_tutorials/02_docplex_example.ipynb @@ -1082,8 +1082,8 @@ } ], "source": [ - "#Specific local device usign qiskit backend\n", - "device = create_device(\"local\", 'pyquil.statevector_simulator')\n", + "#Specific local device usign local vectorized backend\n", + "device = create_device(\"local\", 'vectorized')\n", "\n", "#Is possible check the devices using qaoa.local_simulators, qaoa.cloud_provider\n", "qaoa = QAOA(device)\n", diff --git a/examples/community_tutorials/04_binpacking.ipynb b/examples/community_tutorials/04_binpacking.ipynb index 66e2bc8ca..764f46cfc 100644 --- a/examples/community_tutorials/04_binpacking.ipynb +++ b/examples/community_tutorials/04_binpacking.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "91900971", + "metadata": {}, + "source": [ + "This notebook was written by Alejandro Montañez-Barrera [@alejomonbar](https://github.com/alejomonbar)." + ] + }, { "cell_type": "markdown", "id": "71151440", @@ -15,21 +23,33 @@ "\n", "### Problem statement\n", "\n", - "minimize $$K = \\sum_{j=1}^m y_j$$\n", + "$$\\begin{equation}\n", + "\\min \\sum_{j=0}^{m-1} y_j\\tag{1},\n", + "\\end{equation}$$\n", + "\n", + "subject to the following constraints. Each bin's weight capacity should not be exceeded\n", "\n", - "subject to:\n", + "$$\\begin{equation}\n", + "\\sum_{i=0}^{n-1} w_i x_{ij} \\le B y_j \\quad \\forall j=0,...,m-1\\tag{2},\n", + "\\end{equation}$$\n", "\n", - "$$\\sum_{i=1}^n s(i) x_{ij} \\le B y_j \\qquad \\forall \\ j=1,...,m$$\n", - "$$\\sum_{j=1}^m x_{ij} = 1 \\qquad \\forall \\ i = 1, ..., n$$\n", - "$$x_{ij}\\in \\{0,1\\} \\qquad \\forall \\ i=1,..,n \\qquad j=1,..,m$$\n", - "$$y_{j}\\in \\{0,1\\} \\qquad \\forall \\ j=1,..,m $$\n", + "and each item can only be assigned to one bin\n", "\n", - "- n is the number of items\n", - "- m is the number of bins\n", - "- $s(i)$ is the i-th item weight\n", - "- B is the maximum weight of the bin\n", - "- $x_{ij}$ is the variable that represent if the item i is in the bin j.\n", - "- $y_j$ is the variable that represent if bin j is used" + "$$\\begin{equation}\n", + "\\sum_{j=0}^{m-1} x_{ij} = 1 \\quad \\forall i = 0, ..., n-1.\\tag{3}\n", + "\\end{equation}$$\n", + "\n", + "Binary variables indicating item-bin assignments and bin utilization\n", + "\n", + "$$\\begin{equation}\n", + "x_{ij} \\in {0,1} \\quad \\forall i=0,..,n-1 \\quad \\forall j=0,..,m-1,\\tag{4}\n", + "\\end{equation}$$\n", + "\n", + "$$\\begin{equation}\n", + "y_j \\in {0,1} \\quad \\forall j=0,..,m-1\\tag{5}\n", + "\\end{equation}$$\n", + "\n", + "In the above equations, $n$ represents the number of items (nodes), $m$ represents the number of bins, $w_{i}$ is the weight of the $i$-th item, $B$ denotes the maximum weight capacity of each bin, and $x_{ij}$ and $y_j$ are binary variables representing the presence of item $i$ in bin $j$ and the utilization of bin $j$, respectively. The objective function in Eq.(1) aims to minimize the number of bins used, while Eq.(2) enforces the constraint on bin weight capacity. Eq.(3) ensures that each item is assigned to only one bin, and Eqs.(4) and (5) define the binary nature of variables $x_{ij}$ and $y_j$." ] }, { @@ -39,424 +59,317 @@ "metadata": {}, "outputs": [], "source": [ - "%matplotlib notebook\n", - "\n", - "# Import external libraries to present an manipulate the data\n", + "# Import external libraries\n", + "from openqaoa.problems import BinPacking\n", + "from openqaoa.problems import FromDocplex2IsingModel\n", + "from openqaoa import QAOA, QUBO\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "\n", - "# Import docplex model to generate the problem to optimize\n", - "from docplex.mp.model import Model\n", - "\n", - "# Import the libraries needed to employ the QAOA quantum algorithm using OpenQAOA\n", - "from openqaoa import QAOA\n", "\n", - "# method to covnert a docplex model to a qubo problem\n", - "from openqaoa.problems.converters import FromDocplex2IsingModel\n", - "from openqaoa.backends import create_device\n", + "font_size = 16\n", + "plt.rcParams['font.size'] = font_size\n", "\n", - "# method to find the corrects states for the QAOA boject \n", - "from openqaoa.utilities import ground_state_hamiltonian" + "%matplotlib inline" ] }, { "cell_type": "markdown", - "id": "92daf6ae", + "id": "904f4713", "metadata": {}, "source": [ - "## Generate the data\n", + "## Setting the problem\n", "\n", - "It generates the data necessary to create the BinPacking problem, i.e. to consider number of items, macimum number of bins, max weight of a bin, and the weight of each item." + "It generates the data necessary to create the BinPacking problem, i.e. to consider number of items, maximum number of bins, max weight of a bin, and the weight of each item." ] }, { "cell_type": "code", "execution_count": 2, - "id": "904f4713", + "id": "d7276ddf", "metadata": {}, "outputs": [], "source": [ - "# For the case of reproducibility this seed is configured\n", - "np.random.seed(1)\n", - "\n", - "# Number of items\n", - "num_items = 2 \n", - "\n", - "# Limit the maximum number of bins\n", - "num_bins = num_items\n", - "\n", - "# Limit the max weight of a bin\n", - "max_weight = 7 \n", - "\n", - "# Randomly picking the item weight\n", - "weights = np.random.randint(1, max_weight, num_items)" + "np.random.seed(1234)\n", + "#setting the problem\n", + "n_items = 3 # number of items\n", + "n_bins = 2 # maximum number of bins the solution will be explored on \n", + "min_weight = 1 # minimum weight of the items\n", + "max_weight = 3 # maximum weight of the items\n", + "weight_capacity = 5 # weight capacity of the bins\n", + "weights = np.random.randint(min_weight, max_weight, n_items) # random instance of the problem" ] }, { "cell_type": "markdown", - "id": "06fb9665", + "id": "1afa067b", "metadata": {}, "source": [ - "## Obtain the Quadratic problem from DOCPLEX\n", - "\n", - "Once it is obtained the values for the binpacking problem, the next step is to translate it into a docplex model. Considering the above data the docplex model to solve it is given by " + "## Classical solution and visualizaiton using CPLEX\n", + "This solution is based on the python based library of `CPLEX`, [docplex](https://pypi.org/project/docplex/)." ] }, { "cell_type": "code", "execution_count": 3, - "id": "6a5aab82", + "id": "f15612c4", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "// This file has been generated by DOcplex\n", - "// model name is: BinPacking\n", - "// var contrainer section\n", - "dvar bool y[2];\n", - "dvar bool x[2][2];\n", - "\n", - "minimize\n", - " y_0 + y_1;\n", - " \n", - "subject to {\n", - " x_0_0 + x_0_1 == 1;\n", - " x_1_0 + x_1_1 == 1;\n", - " 6 x_0_0 + 4 x_1_0 <= 7 y_0;\n", - " 6 x_0_1 + 4 x_1_1 <= 7 y_1;\n", - "\n", - "}\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Construct model using docplex starting with the name of the Model object\n", - "mdl = Model(\"BinPacking\")\n", - "\n", - "# List of binary variables that represent the bins\n", - "y = mdl.binary_var_list(num_bins, name=\"y\")\n", - "\n", - "# List of binary variables that represent the items on the specific bin\n", - "x = mdl.binary_var_matrix(num_items, num_bins, \"x\") \n", - "\n", - "# Design the objective function\n", - "objective = mdl.sum(y)\n", - "\n", - "# This problem is minize the objective function\n", - "mdl.minimize(objective)\n", - "\n", - "# Indicate the equality constraints\n", - "for i in range(num_items):\n", - " # First set of constraints: the items must be in any bin\n", - " mdl.add_constraint(mdl.sum(x[i, j] for j in range(num_bins)) == 1)\n", - "\n", - "# Indicate the inequality constraints\n", - "for j in range(num_bins):\n", - " # Second set of constraints: weight constraints\n", - " mdl.add_constraint(mdl.sum(weights[i] * x[i, j] for i in range(num_items)) <= max_weight * y[j])\n", - "\n", - "# Print a summary of the Docplex model\n", - "mdl.prettyprint()" + "bpp = BinPacking(weights, weight_capacity, n_bins=n_bins, simplifications=False) #setting the problem using a openqaoa class\n", + "sol_cplex = bpp.classical_solution(string=True) # getting the optimal solution using DocPLEX \n", + "fig, ax = plt.subplots()\n", + "bpp.plot_solution(sol_cplex, ax)# Plotting the optimal solution" ] }, { "cell_type": "markdown", - "id": "fc3a73be", + "id": "46c864ea", "metadata": {}, "source": [ - "## Solving the problem using QAOA\n", + "## Solving using QAOA\n", "\n", + "We define a convenience function to solve the problem using QAOA, the steps abstracted here are:\n", "\n", - "The class `FromDocplex2IsingModel` from OpenQAOA converts the docplex representation of the problem to its QUBO representation in Ising encoding (-1, 1). From there, it is only required setting the QAOA model and solve the QUBO." + "* Setting the problem up and normalizing the weights\n", + "* Defining the QAOA properties, including parameter initialization, classical optimizer, etc...\n", + "* Compilation of the QAOA object\n", + "* Optimization" ] }, { "cell_type": "code", "execution_count": 4, - "id": "ffcc1361", + "id": "2551ac28", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "// This file has been generated by DOcplex\n", - "// model name is: Copy of Copy of BinPacking\n", - "// var contrainer section\n", - "dvar bool y[2];\n", - "dvar bool x[2][2];\n", - "dvar bool slack_C2[3];\n", - "dvar bool slack_C3[3];\n", - "\n", - "// single vars section\n", - "dvar bool y_0;\n", - "dvar bool y_1;\n", - "dvar bool x_0_0;\n", - "dvar bool x_0_1;\n", - "dvar bool x_1_0;\n", - "dvar bool x_1_1;\n", - "dvar bool slack_C2_0;\n", - "dvar bool slack_C2_1;\n", - "dvar bool slack_C2_2;\n", - "dvar bool slack_C3_0;\n", - "dvar bool slack_C3_1;\n", - "dvar bool slack_C3_2;\n", - "\n", - "minimize\n", - " y_0 + y_1 - 6 x_0_0 - 6 x_0_1 - 6 x_1_0 - 6 x_1_1 [ 147 y_0^2 - 252 y_0*x_0_0\n", - " - 168 y_0*x_1_0 - 42 y_0*slack_C2_0 - 84 y_0*slack_C2_1 - 168 y_0*slack_C2_2\n", - " + 147 y_1^2 - 252 y_1*x_0_1 - 168 y_1*x_1_1 - 42 y_1*slack_C3_0\n", - " - 84 y_1*slack_C3_1 - 168 y_1*slack_C3_2 + 111 x_0_0^2 + 6 x_0_0*x_0_1\n", - " + 144 x_0_0*x_1_0 + 36 x_0_0*slack_C2_0 + 72 x_0_0*slack_C2_1\n", - " + 144 x_0_0*slack_C2_2 + 111 x_0_1^2 + 144 x_0_1*x_1_1 + 36 x_0_1*slack_C3_0\n", - " + 72 x_0_1*slack_C3_1 + 144 x_0_1*slack_C3_2 + 51 x_1_0^2 + 6 x_1_0*x_1_1\n", - " + 24 x_1_0*slack_C2_0 + 48 x_1_0*slack_C2_1 + 96 x_1_0*slack_C2_2\n", - " + 51 x_1_1^2 + 24 x_1_1*slack_C3_0 + 48 x_1_1*slack_C3_1\n", - " + 96 x_1_1*slack_C3_2 + 3 slack_C2_0^2 + 12 slack_C2_0*slack_C2_1\n", - " + 24 slack_C2_0*slack_C2_2 + 12 slack_C2_1^2 + 48 slack_C2_1*slack_C2_2\n", - " + 48 slack_C2_2^2 + 3 slack_C3_0^2 + 12 slack_C3_0*slack_C3_1\n", - " + 24 slack_C3_0*slack_C3_2 + 12 slack_C3_1^2 + 48 slack_C3_1*slack_C3_2\n", - " + 48 slack_C3_2^2 ] + 6;\n", - " \n", - "subject to {\n", - "\n", - "}\n" - ] - } - ], + "outputs": [], "source": [ - "# Converting the Docplex model of binpacking into its qubo representation\n", - "qubo_bin = FromDocplex2IsingModel(mdl) \n", - "\n", - "# Ising encoding of the QUBO problem for binpacking problem\n", - "ising_encoding_bin = qubo_bin.ising_model \n", - "\n", - "# Docplex encoding of the QUBO problem for binpacking problem\n", - "mdl_qubo_docplex_bin = qubo_bin.qubo_docplex\n", - "mdl_qubo_docplex_bin.prettyprint()" + "def qaoa_result(qubo, p=5, maxiter=100):\n", + " \"\"\"\n", + " qubo (openqaoa.QUBO): Ising Hamiltonian of the problem\n", + " p (int): Number of layers of the QAOA circuit\n", + " maxiter (int): Maximum number of iterations\n", + " \"\"\"\n", + " max_weight = np.max(qubo.weights)\n", + " qubo_weights = [w/max_weight for w in qubo.weights]\n", + " qubo_normal = QUBO(qubo.n, qubo.terms, qubo_weights) # Normalizing the QUBO weights, (it can help sometimes to improve the results)\n", + "\n", + " qaoa = QAOA()\n", + " qaoa.set_circuit_properties(p=p, init_type=\"ramp\", linear_ramp_time=0.1) # initialization betas and gammas with a ramp technique\n", + " qaoa.set_classical_optimizer(maxiter=maxiter) \n", + " qaoa.compile(qubo_normal)\n", + " qaoa.optimize()\n", + " return qaoa" ] }, { "cell_type": "markdown", - "id": "246cbebf", + "id": "debfb6b3", "metadata": {}, "source": [ - "Using the pyquil backend and 1024 shots with a p value equals to 3, with betas and gammas of $0.01 * \\pi$ " + "### 1 - Solve using slack variable encoding" ] }, { "cell_type": "code", "execution_count": 5, - "id": "efd1a6b0", + "id": "2c8c796d", "metadata": {}, "outputs": [], "source": [ - "# Indicate the device, this case is a local simulator\n", - "device = create_device(\"local\", 'pyquil.statevector_simulator')\n", - "\n", - "# Initilize the QAOA object\n", - "qaoa_bin = QAOA(device)\n", - "\n", - "# Set the parameters to work the QAOA algorithm\n", - "qaoa_bin.set_backend_properties(n_shots=1024, seed_simulator=1)\n", - "rep = 3\n", - "qaoa_bin.set_circuit_properties(p=rep, init_type=\"custom\", variational_params_dict={\"betas\":rep*[0.01*np.pi],\"gammas\":rep*[0.01*np.pi]})\n", - "qaoa_bin.compile(ising_encoding_bin)\n", - "\n", - "# Run the QAOA algorithm\n", - "qaoa_bin.optimize()" + "penalty = [10, 10] # [Equality, Inequality] constraints\n", + "bpp_slack = BinPacking(weights, weight_capacity, n_bins=n_bins, penalty=penalty, simplifications=False, method=\"slack\")\n", + "qubo = bpp_slack.qubo # Ising Hamiltonian of the BPP using the slack variables encoding \n", + "results_slack = qaoa_result(qubo, p=5, maxiter=100)" ] }, { "cell_type": "markdown", - "id": "c8621ecf", + "id": "52bfe520", "metadata": {}, "source": [ - "show the best 5 states for this binpacking problem" + "We can now analyze the solution generated by the QAOA optimization and visualize the result and cost" ] }, { "cell_type": "code", "execution_count": 6, - "id": "fc3ec364", + "id": "5a2b720f", "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
solutions_bitstringsbitstrings_energiesprobabilities
01110011001102.06.772599e-07
11101101101002.06.772599e-07
21000101100004.02.518399e-06
30101000001004.01.779673e-05
41010001000004.01.779673e-05
\n", - "
" - ], - "text/plain": [ - " solutions_bitstrings bitstrings_energies probabilities\n", - "0 111001100110 2.0 6.772599e-07\n", - "1 110110110100 2.0 6.772599e-07\n", - "2 100010110000 4.0 2.518399e-06\n", - "3 010100000100 4.0 1.779673e-05\n", - "4 101000100000 4.0 1.779673e-05" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "The probability of finding the optimal solution using the slack approach is: 0.2%\n" + ] } ], "source": [ - "qaoa_bin_dict = qaoa_bin.result.lowest_cost_bitstrings(5)\n", - "pd.DataFrame(qaoa_bin_dict)" - ] - }, - { - "cell_type": "markdown", - "id": "f6a5f3cc", - "metadata": {}, - "source": [ - "Chek the correct answer using the ground_state_hamiltonian and the 2 correct answer are in the best 5 best states." + "nstates = 10\n", + "results = results_slack.result.lowest_cost_bitstrings(nstates)\n", + "idx_opt = 0\n", + "p = 0\n", + "for n in range(nstates): # There are multiple optimal solutions, \n", + " # Let's check which states share the same enegry with the ground state\n", + " if results[\"bitstrings_energies\"][n] == results[\"bitstrings_energies\"][idx_opt]:\n", + " p += results[\"probabilities\"][n]\n", + "print(f\"The probability of finding the optimal solution using the slack approach is: {round(100*p,1)}%\")" ] }, { "cell_type": "code", "execution_count": 7, - "id": "a0bbc68b", + "id": "052f14d4", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states kept: 10\n" + ] + }, { "data": { + "image/png": "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", "text/plain": [ - "(2.0, ['110110110100', '111001100110'])" + "
" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "# Check the exactly solution\n", - "sol = ground_state_hamiltonian(qaoa_bin.cost_hamil)\n", - "sol" + "fig, ax = plt.subplots(1,3, figsize=(30,5))\n", + "bpp_slack.plot_solution(results[\"solutions_bitstrings\"][0], ax=ax[0])\n", + "results_slack.result.plot_cost(ax=ax[1])\n", + "results_slack.result.plot_probabilities(n_states_to_keep=nstates, ax=ax[2])\n", + "t = ax[0].set_title(\"Optimal solution\")" ] }, { "cell_type": "markdown", - "id": "70ed22ec", + "id": "da6c04f3", "metadata": {}, "source": [ - "### 2.2 Solution using DOCPLEX\n", - "\n", - "The QUBO problem can be solved classically using DOCPLEX. This is a good comparision between QAOA against classical optimizers.\n", + "### 2 - Solve using unbalanced penalization\n", "\n", - "**Note: For the next cell you will need to install cplex with the command** `pip install cplex>=22.1.0.0` " + "For the penalty terms, we can use the tuned parameters presented in the original [unbalanced penalization paper](https://arxiv.org/abs/2211.13914)" ] }, { "cell_type": "code", "execution_count": 8, - "id": "ec103334", + "id": "90a4f75c", + "metadata": {}, + "outputs": [], + "source": [ + "penalty = [10, 2, 1] # [Equality, Inequality] constraints got from the unbalanced penalization paper\n", + "bpp_unbalanced = BinPacking(weights, weight_capacity, n_bins=n_bins, penalty=penalty, simplifications=False, method=\"unbalanced\")\n", + "qubo = bpp_unbalanced.qubo # Ising Hamiltonian of the BPP using the slack variables encoding \n", + "results_unbalanced = qaoa_result(qubo, p=5, maxiter=100)" + ] + }, + { + "cell_type": "markdown", + "id": "0aca51e4", + "metadata": {}, + "source": [ + "Once again let's analywe the results of the QAOA optimization:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0401841a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "objective: 2.000\n", - " y_0=1\n", - " y_1=1\n", - " x_0_0=0\n", - " x_0_1=1\n", - " x_1_0=1\n", - " x_1_1=0\n", - " slack_C2_0=1\n", - " slack_C2_1=1\n", - " slack_C2_2=0\n", - " slack_C3_0=1\n", - " slack_C3_1=0\n", - " slack_C3_2=0\n" + "The probability of finding the optimal solution using unbalanced penalization is: 12.0%\n" ] } ], "source": [ - "# docplex QUBO model\n", - "mdl_qubo_bin = qubo_bin.qubo_docplex \n", - "\n", - "# Obtain the docplex solution\n", - "sol_bin_docplex = mdl_qubo_bin.solve()\n", - "sol_bin = {i.name: int(sol_bin_docplex.get_value(i)) for i in mdl_qubo_bin.iter_binary_vars()}\n", - "mdl_qubo_bin.print_solution(print_zeros=True)" + "nstates = 20\n", + "results = results_unbalanced.result.lowest_cost_bitstrings(nstates)\n", + "indx_opt = results[\"solutions_bitstrings\"].index(sol_cplex)\n", + "p = 0\n", + "for n in range(nstates): # There are multiple optimal solutions, \n", + " # Let's check which states share the same enegry with the ground state\n", + " if results[\"bitstrings_energies\"][n] == results[\"bitstrings_energies\"][0]:\n", + " p += results[\"probabilities\"][n]\n", + "print(f\"The probability of finding the optimal solution using unbalanced penalization is: {round(100*p,1)}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "661b6312", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states kept: 20\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,3, figsize=(30,5))\n", + "bpp_unbalanced.plot_solution(results[\"solutions_bitstrings\"][0], ax=ax[0])\n", + "results_unbalanced.result.plot_cost(ax=ax[1])\n", + "results_unbalanced.result.plot_probabilities(n_states_to_keep=nstates, ax=ax[2])\n", + "title=ax[0].set_title(\"Optimal solution\")" ] }, { "cell_type": "markdown", - "id": "0535b083", + "id": "ee9c120e", "metadata": {}, "source": [ - "The solution is `110110110100`, being one state as in the quantum algorithm" + "# Conclusion \n", + "\n", + "In this notebook, we tested the BPP using `openqaoa` for a three items problem with QAOA $p=5$. The results are presented for the unbalanced penalization and slack encodings. The unbalanced penalization reduces the number of qubit needed to represent the problems and therefore improves considerably the probability of obtaining the optimal solution compared to the slack variables approach." ] + }, + { + "cell_type": "markdown", + "id": "8b3c4264", + "metadata": {}, + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "docplex", + "display_name": "oq_latest", "language": "python", - "name": "docplex" + "name": "oq_latest" }, "language_info": { "codemirror_mode": { @@ -468,7 +381,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.10.0" } }, "nbformat": 4, diff --git a/setup.py b/setup.py index fba7e87db..fd9bc2f68 100644 --- a/setup.py +++ b/setup.py @@ -13,7 +13,7 @@ requirements = [ f"{each_folder_name}=={version}" for each_folder_name in os.listdir("src") - if "openqaoa-" in each_folder_name + if ("openqaoa-" in each_folder_name and "openqaoa-pyquil" not in each_folder_name) ] setup( diff --git a/src/openqaoa-core/openqaoa/problems/__init__.py b/src/openqaoa-core/openqaoa/problems/__init__.py index adaafb6ef..eabe523e7 100644 --- a/src/openqaoa-core/openqaoa/problems/__init__.py +++ b/src/openqaoa-core/openqaoa/problems/__init__.py @@ -9,6 +9,7 @@ from .binpacking import BinPacking from .vehiclerouting import VRP from .sherrington_kirkpatrick import SK +from .bpsp import BPSP from .kcolor import KColor from .converters import FromDocplex2IsingModel from .qubo import QUBO diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py new file mode 100644 index 000000000..644a086fe --- /dev/null +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -0,0 +1,619 @@ +""" +bpsp.py + +This module provides an implementation for the Binary Paint Shop Problem (BPSP), a combinatorial optimization problem arising from automotive paint shops. +Given a fixed sequence of cars, each requiring two distinct colors, the objective is to determine the order of painting such that color changes between +adjacent cars are minimized. The problem is NP-hard, and approximating it is also challenging. The module offers various solution strategies, including +greedy and quantum approximate optimization approaches. + +This implementation is based on the following works: + - "Beating classical heuristics for the binary paint shop problem with the + quantum approximate optimization algorithm" + (https://journals.aps.org/pra/abstract/10.1103/PhysRevA.104.012403) + - "Some heuristics for the binary paint shop problem and their expected number + of colour changes" + (https://www.sciencedirect.com/science/article/pii/S1570866710000559) + - Upcoming/unpublished work by V Vijendran et al from A*STAR and CQC2T. + +Author: V Vijendran (Vijey) +GitHub: https://github.com/vijeycreative +Email: v.vijendran@anu.edu.au +""" + + +import numpy as np +import networkx as nx +import matplotlib.pyplot as plt +from docplex.mp.model import Model +from collections import defaultdict + +from .problem import Problem +from .qubo import QUBO + + +class BPSP(Problem): + """ + Binary Paint Shop Problem (BPSP) + + This class is dedicated to solving the Binary Paint Shop Problem (BPSP), a combinatorial + optimization challenge drawn from an automotive paint shop context. In this problem, there + exists a specific sequence of cars, with each car making two appearances in the sequence. + The primary objective is to find the best coloring sequence such that consecutive cars in the + sequence necessitate the fewest color switches. + + When initializing, the solver accepts a list of car numbers indicative of a valid BPSP instance + and subsequently establishes a Binary Paint Shop Problem instance based on this. + + To elaborate on the problem: + + Imagine we have 'n' distinct cars, labeled as c_1, c_2, ..., c_n. These cars are presented + in a sequence of length '2n', such that each car c_i makes two appearances. This sequence + is represented as w_1, w_2, ..., w_2n, with every w_i being one of the cars from the set. + + The challenge further presents two paint colors, represented as 1 and 2. For every car + in the sequence, a decision must be made on which color to paint it first, resulting in a + color assignment sequence like f_1, f_2, ..., f_2n. It's crucial to ensure that if two + occurrences in the sequence pertain to the same car, their color designations differ. + + The main goal is to choose a sequence of colors such that we minimize the instances where + consecutive cars require different paint colors. This is quantified by computing the difference + between color assignments for consecutive cars and aggregating this difference for the entire sequence. + """ + + __name__ = "binary_paint_shop_problem" + + def __init__(self, car_sequence): + """ + Initialize the Binary Paint Shop Problem (BPSP) instance. + + Parameters: + - car_sequence : list[int] + A list of integers representing car numbers, denoting the sequence + in which cars appear in the BPSP. Each car number appears exactly + twice, symbolizing the two distinct color coatings each car requires. + + Attributes Set: + - self.car_sequence : list[int] + Stores the sequence of car numbers. + + - self.car_positions : dict[int, tuple] + Maps each car number to a tuple of its two positions in the car_sequence. + Determined by the `car_pos` property. + + - self.bpsp_graph : networkx.Graph + Represents the BPSP as a graph where nodes are car positions and edges + indicate adjacent car positions in the sequence. Constructed by the + `bpsp_graph` method. + + Returns: + ------- + The initialized BPSP object. + """ + + self.car_sequence = car_sequence + self.car_positions = self.car_pos + self.bpsp_graph = self.graph + + @property + def problem_instance(self): + instance = super().problem_instance # Get the original problem_instance + return self.convert_ndarrays(instance) + + @staticmethod + def convert_ndarrays(obj): + """ + Recursively convert numpy objects in the given object to their Python counterparts. + Converts numpy.ndarrays to Python lists and numpy.int64 to Python int. + """ + if isinstance(obj, np.ndarray): + return obj.tolist() + elif isinstance(obj, np.int64): + return int(obj) + elif isinstance(obj, dict): + return {k: BPSP.convert_ndarrays(v) for k, v in obj.items()} + elif isinstance(obj, list): + return [BPSP.convert_ndarrays(item) for item in obj] + else: + return obj + + + @property + def car_sequence(self): + """ + Getter for the 'car_sequence' property. + + This method retrieves the current value of the `_car_sequence` attribute, which represents + the sequence of cars to be painted. Each car is identified by a unique integer ID, + and each ID must appear exactly twice in the sequence, indicating the two times the car + is painted. + + Returns: + ------- + list[int] + The current sequence of car IDs. Each ID appears exactly twice in the sequence. + """ + return self._car_sequence + + @car_sequence.setter + def car_sequence(self, sequence): + """ + Setter for the 'car_sequence' property. + + This method validates and sets a new value for the `_car_sequence` attribute. + The validation ensures: + 1. Each car ID appears exactly twice in the sequence. + 2. The range of car IDs is continuous (e.g., for IDs 0, 1, 2, both 0 and 2 cannot appear without 1). + + Parameters: + ---------- + sequence : list[int] + A new sequence of car IDs to be assigned to `_car_sequence`. + + Raises: + ------ + ValueError: + If any of the validation checks fail, a ValueError is raised with an appropriate error message. + + """ + # Check if each car ID appears exactly twice + unique_ids, counts = np.unique(sequence, return_counts=True) + if not all(count == 2 for count in counts): + raise ValueError("Each car ID must appear exactly twice in the sequence.") + + # Check if range of car IDs is continuous + if len(unique_ids) != (max(unique_ids) + 1): + raise ValueError("The range of car IDs must be continuous.") + + # If all checks pass, assign the sequence to the private attribute + self._car_sequence = sequence + + @staticmethod + def random_instance(**kwargs): + """ + Generates a random instance of the BPSP problem, based on the specified number of cars. + + The function creates a list with two occurrences of each car ID, then applies the Fisher-Yates shuffle + to randomize the order of the cars. The shuffled sequence of cars is then used to create a BPSP instance. + + Parameters + ---------- + **kwargs: + num_cars: int + The number of distinct cars to be considered in the sequence. Each car will appear twice in the + final sequence. + seed: int, optional + The seed for the random number generator. If provided, the output will be deterministic based on this seed. + + Returns + ------- + BPSP + A random instance of the BPSP problem, based on the shuffled sequence of cars. + """ + + # Extract the number of cars and the seed from the provided keyword arguments. + num_cars = kwargs.get("num_cars") + seed = kwargs.get("seed", None) # Default value is None if not provided. + + # Assert that the number of cars is greater than 0. + assert num_cars > 0, "The number of cars must be greater than 0." + + # Generate a list with two occurrences of each car ID, i.e., [0, 1, ..., n, 0, 1, ..., n]. + car_sequence = np.array(list(range(num_cars)) + list(range(num_cars))) + + # Create a new instance of the default random number generator. + rng = np.random.default_rng(seed) + + # Apply the Fisher-Yates shuffle to the car_sequence. + # Start from the end of the list and swap the current element with a randomly chosen earlier element. + for i in range(len(car_sequence) - 1, 0, -1): + # Select a random index between 0 and i (inclusive) using the rng instance. + j = rng.integers(0, i + 1) + # Swap the elements at indices i and j. + car_sequence[i], car_sequence[j] = car_sequence[j], car_sequence[i] + + # Return a BPSP instance using the shuffled car_sequence. + return BPSP(car_sequence) + + + @property + def car_pos(self): + """ + Retrieve the positions of each car ID in the car sequence. + + This method tracks the occurrences of each car ID in the car sequence. + Since each car ID is expected to appear twice in the sequence, the method + returns a dictionary where keys are car IDs and values are tuples with the + positions of the two occurrences. + + Returns + ------- + dict + A dictionary where keys are car IDs and values are tuples with the positions + of the two occurrences. For example, for a sequence [0, 1, 0, 1], the + output would be {0: (0, 2), 1: (1, 3)}. + """ + + # Initialize an empty dictionary to store car positions. + car_pos = {} + + # Enumerate through each car ID in the sequence to track its positions. + for idx, car in enumerate(self.car_sequence): + # Convert the car to int type (assuming it's of type np.int64 or similar) + car_key = int(car) + + # If the car ID is already in the dictionary, append the new position. + if car_key in car_pos: + car_pos[car_key].append(idx) + # If this is the first occurrence of the car ID, initialize a list with the position. + else: + car_pos[car_key] = [idx] + + # Convert the lists of positions to tuples for a consistent output format. + for car_key, positions in car_pos.items(): + car_pos[car_key] = tuple(positions) + + return car_pos + + + @property + def graph(self): + """ + Construct a graph to represent the Binary Paint Shop Problem (BPSP) using the Ising model. + + This function takes a car sequence from the instance and translates it to an Ising graph. + In the graph, nodes represent cars, and edges represent the interaction between two consecutive + cars in the sequence. The weight on each edge indicates the interaction strength and sign. + + Returns + ------- + ising_graph : nx.Graph + A graph representing the Ising model for the BPSP based on the car sequence of the instance. + + Notes + ----- + The interaction strength is determined based on how many times the cars appeared + in the sequence before the current pair. + """ + + # Number of distinct cars in the sequence. + num_cars = int(len(self.car_sequence) / 2) + + # A list to count occurrences of each car as the sequence is processed. + car_occurrences = [0] * num_cars + + # Dictionary to hold edges and their weights. + graph = {} + + # Helper function to add or update an edge in the graph. + def add_edge(u, v, weight): + # Sort the vertices to maintain a consistent edge representation. + edge = (u, v) #if u < v else (v, u) + # Add the weight or update the existing weight of the edge. + graph[edge] = graph.get(edge, 0) + weight + + # Process each pair of cars in the sequence. + for i in range(len(self.car_sequence) - 1): + # Get the current car pair. + car1, car2 = self.car_sequence[i], self.car_sequence[i+1] + + # Get the occurrences of the cars in the sequence so far. + occ_car1, occ_car2 = car_occurrences[car1], car_occurrences[car2] + + # Calculate the interaction weight based on car occurrences. + weight = (-1)**(occ_car1 + occ_car2 + 1) + + # Add or update the graph with the edge and its weight. + add_edge(car1, car2, weight) + + # Update the occurrence count for the first car of the current pair. + car_occurrences[car1] += 1 + + # Construct the final Ising graph with non-zero weights. + ising_graph = nx.Graph() + + # Add edges without self-loops to the graph. + for (u, v), weight in graph.items(): + if u != v: + ising_graph.add_edge(u, v, weight=weight) + + # Ensure all car nodes are in the graph, even if they don't have any edges. + ising_graph.add_nodes_from(range(num_cars)) + + return ising_graph + + @property + def docplex_bpsp_model(self): + """ + Construct a CPLEX model for the Binary Paint Shop Problem (BPSP). + + This method encodes the BPSP into a linear optimization problem. + The BPSP seeks to determine a painting sequence for cars such that adjacent cars + in the sequence don't receive the same color if they are the same car type. + The sequence length is twice the number of cars as each car passes the painting station twice. + + The decision variables represent the paint color (binary: 0 or 1) for each car at each position in the sequence. + The objective function aims to minimize the absolute difference between adjacent paint values in the sequence. + + Attributes + ---------- + car_sequence : list + A list representing the sequence of cars as they pass the paint shop. + Each car is represented by its identifier (e.g., integer), and appears twice in the sequence. + + car_positions : dict + A dictionary mapping each car to its two positions in the car_sequence. + For example, if car 'a' appears in positions 2 and 5 in car_sequence, then + car_positions['a'] = [2, 5]. + + Returns + ------- + Model + A CPLEX model instance representing the BPSP, ready to be solved. + """ + + mdl = Model("BPSP_Problem") + sequence = self.car_sequence + car_pos = self.car_positions + + # Dictionary for storing the paint value for car 'x' at position 'j'. + w_vars = {f"{w}_{i}": mdl.binary_var(name=f"w_{w}_{i}") for i, w in enumerate(sequence)} + + # This loop adds the constraint that a particular car cannot have the same paint + # at both occurrences in the paint sequence. If the first occurrence is 0, the other has to + # be 1 and vice-versa. + for car, positions in car_pos.items(): + w_key1, w_key2 = f"{car}_{positions[0]}", f"{car}_{positions[1]}" + mdl.add_constraint(w_vars[w_key1] + w_vars[w_key2] == 1) + + # Encode the objective function: sum_i^2n-1 |paint[i] - paint[i+1]|. Since docplex accepts abs operator, + # you can directly utilize it for the objective. This makes the model simpler than in Gurobi. + w_keys = list(w_vars.keys()) + objective_function = mdl.sum(mdl.abs(w_vars[w_keys[i]] - w_vars[w_keys[i + 1]]) for i in range(len(w_keys) - 1)) + + # Set the objective to minimize. + mdl.minimize(objective_function) + + return mdl + + @property + def qubo(self): + """ + Returns the QUBO encoding of the Binary Paint Shop Problem. + + This function provides a QUBO representation of the BPSP, where the objective is to minimize the + total weight of violations. The violations here refer to two adjacent cars in the sequence receiving + the same color. + + Returns + ------- + QUBO + The QUBO encoding of the BPSP. This is a representation that describes + the quadratic objective function over binary variables. + """ + + # Iterate over edges (with weight) and store accordingly + terms = [] + weights = [] + + # Here, we use self.bpsp_graph to gather terms and weights. + for u, v, edge_weight in self.bpsp_graph.edges(data="weight"): + terms.append([u, v]) + + weights.append(edge_weight) + + return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights, self.problem_instance,) + + def solve_cplex(self): + """ + Solves the BPSP using the CPLEX solver and returns the solution and its objective value. + + The Binary Paintshop Problem (BPSP) solution represents a sequence of paint choices + where a value of 0 represents blue paint and a value of 1 represents red paint. + + Returns + ------- + tuple + A tuple where the first element is a list containing the paint choices + (0 for blue, 1 for red) and the second element is the objective value. + """ + + # Retrieve the model for BPSP + model = self.docplex_bpsp_model + + # Solve the BPSP using CPLEX + model.solve() + + # Check the status of the solution + status = model.solve_details.status + if status != "integer optimal solution": + print(status) + + # Extract the solution values representing paint choices + solution = [int(np.round(model.solution.get_value(var))) for var in model.iter_binary_vars()] + + # Get the objective value of the solution + diff_sum = lambda lst: sum(abs(lst[i] - lst[i+1]) for i in range(len(lst)-1)) + objective_value = diff_sum(solution) + # Return the paint choices and their corresponding objective value + return solution, objective_value + + def paintseq_from_bits(self, bitstring): + """ + Transforms a sequence of initial car colors to a paint sequence and computes the number of paint swaps. + + Given a bitstring sequence of car colors ('0' or '1'), this function transforms it into + a paint sequence. Each car's colors are determined by two consecutive positions in + the sequence. The function also computes the number of times the paint changes (swaps) + between consecutive positions in the paint sequence. + + Parameters + ---------- + colors : str + A string of car colors where each character is either '0' or '1'. + + Returns + ------- + tuple + A tuple where the first element is a list representing the paint sequence + (0 for blue, 1 for red) and the second element is the number of paint swaps. + """ + + # Convert the input string colors to a list of integers + colors = [int(color) for color in bitstring] + + # Initialize the paint sequence with zeros + paint_sequence = [0 for _ in range(2 * len(colors))] + + # Fill the paint sequence based on the input colors and car positions + for car, color in enumerate(colors): + pos1, pos2 = self.car_positions[car] + + paint_sequence[pos1] = color + paint_sequence[pos2] = 1 - color # The opposite color + + # Compute the number of paint swaps in the sequence + color_swaps = sum(abs(paint_sequence[i] - paint_sequence[i + 1]) for i in range(len(paint_sequence) - 1)) + + return paint_sequence, color_swaps + + def solve_redfirst(self): + """ + The `red_first_solution` method applies a heuristic to generate a paint sequence for cars. + Specifically, it colors the first occurrence of each car as Red (1) and the second + occurrence as Blue (0). On average, this heuristic may not be as efficient as the greedy + algorithm. + + Attributes: + ---------- + self.car_sequence : list[int] + A list containing the sequence of cars that need to be painted. + + Returns: + ------- + tuple + A tuple containing two elements: + 1. A list representing the paint sequence with '1' indicating Red and '0' indicating Blue. + 2. An integer representing the total number of paint swaps in the sequence. + """ + + # Dictionary to keep track of whether a car has been painted or not + cars_painted = defaultdict(bool) + + # Create the paint sequence + paint_sequence = [] + for car in self.car_sequence: + if not cars_painted[car]: + paint_sequence.append(1) + cars_painted[car] = True + else: + paint_sequence.append(0) + + # Compute the number of color swaps in the sequence + color_swaps = sum(abs(paint_sequence[i] - paint_sequence[i + 1]) for i in range(len(self.car_sequence) - 1)) + + return paint_sequence, color_swaps + + def solve_greedy(self): + """ + The `greedy_solution` method determines a feasible paint sequence for cars using a + greedy approach. It processes the car sequence from left to right, coloring the + first occurrence of each car based on its predecessor and the second occurrence + with the opposite color. + + Attributes: + ---------- + self.car_sequence : list[int] + A list containing the sequence of cars that need to be painted. + self.car_positions : dict[int, tuple] + A dictionary mapping each car to a tuple containing the + first and second position of the car's occurrence in `car_sequence`. + + Returns: + ------- + tuple + A tuple containing two elements: + 1. A list representing the paint sequence with '1' indicating Red and '0' indicating Blue. + 2. An integer representing the total number of paint swaps in the sequence. + """ + + # Dictionary to keep track of whether a car has been painted or not + cars_painted = defaultdict(bool) + + # List to store the paint sequence + paint_sequence = [] + + # Variable to keep track of the last used color + last_color = 0 + + # Create the paint sequence + for car in self.car_sequence: + if not cars_painted[car]: + if paint_sequence: # if paint_sequence is not empty + last_color = paint_sequence[-1] + paint_sequence.append(last_color) + cars_painted[car] = True + else: + paint_sequence.append(1 - paint_sequence[self.car_positions[car][0]]) + + # Compute the number of color swaps in the sequence + color_swaps = sum(abs(paint_sequence[i] - paint_sequence[i + 1]) for i in range(len(self.car_sequence) - 1)) + + return paint_sequence, color_swaps + + def plot_paint_sequence(self, paint_sequence, ax=None): + """ + Plot a bar chart showing the colors assigned to cars based on the given paint_sequence. + + Parameters: + ---------- + self.car_sequence : numpy.ndarray[int] + Numpy array containing the order of cars to be painted. + + paint_sequence : list[int] or numpy.ndarray[int] + List or numpy array containing 0 or 1 for each car in `self.car_sequence`. + A 0 indicates the car is painted Blue, while a 1 indicates it's painted Red. + + ax : matplotlib.axes.Axes, optional + Axes object to plot on. If not provided, a new figure is created. + + Returns: + ------- + None + + Note: + ----- + This function uses a blue-red color mapping and plots bars without any gaps to visually + represent the paint sequence of cars. The plot's size is dynamically adjusted based on + the number of cars. + """ + + # Define color mapping for 0s and 1s in the paint_sequence to 'blue' and 'red' respectively + color_map = {0: '#48cae4', 1: '#f25c54'} # shades of blue and red + plot_colors = [color_map[color] for color in paint_sequence] + + # Dynamically determine the width of the figure based on the number of cars in self.car_sequence + fig_width = self.car_sequence.size * 0.8 # This provides each bar approximately 0.8 inch width + + # If no ax (subplot) is provided, create a new figure with the determined width + if ax is None: + fig, ax = plt.subplots(figsize=(fig_width, 2)) + + # Plot bars for each car, colored based on the paint_sequence + ax.bar(range(len(self.car_sequence)), np.ones_like(self.car_sequence), color=plot_colors, width=1, align='center') + ax.set_xlim(-0.5, len(self.car_sequence) - 0.5) # Set x limits to tightly fit bars + ax.set_ylim(0, 1) # Set y limits from 0 to 1 as the bars have a fixed height of 1 + ax.yaxis.set_visible(False) # Hide the y-axis as it's not relevant + + # Set x-ticks to indicate car numbers and label them as "Car 3", "Car 2", "Car 2", etc. + ax.set_xticks(range(len(self.car_sequence))) + ax.set_xticklabels([f"Car {int(car)}" for car in self.car_sequence]) + + # Hide the top, right, and left spines for cleaner visuals + ax.spines['top'].set_visible(False) + ax.spines['right'].set_visible(False) + ax.spines['left'].set_visible(False) + + # If no ax is provided, show the plot directly + if ax is None: + plt.tight_layout() + plt.show() \ No newline at end of file diff --git a/src/openqaoa-core/openqaoa/problems/helper_functions.py b/src/openqaoa-core/openqaoa/problems/helper_functions.py index 0d7b1d1ea..a077f1c0b 100644 --- a/src/openqaoa-core/openqaoa/problems/helper_functions.py +++ b/src/openqaoa-core/openqaoa/problems/helper_functions.py @@ -14,6 +14,7 @@ from .binpacking import BinPacking from .portfoliooptimization import PortfolioOptimization from .sherrington_kirkpatrick import SK +from .bpsp import BPSP from .qubo import QUBO @@ -52,6 +53,7 @@ def create_problem_from_dict(problem_instance: dict) -> Problem: "k_color": KColor, "portfolio_optimization": PortfolioOptimization, "sherrington_kirkpatrick": SK, + "binary_paint_shop_problem": BPSP, } # check if the problem type is in the mapper diff --git a/src/openqaoa-core/openqaoa/problems/tsp.py b/src/openqaoa-core/openqaoa/problems/tsp.py index dabdd4e0b..349355900 100644 --- a/src/openqaoa-core/openqaoa/problems/tsp.py +++ b/src/openqaoa-core/openqaoa/problems/tsp.py @@ -179,7 +179,6 @@ def validate_graph(G): """ # Set edge weights to be the distances between corresponding cities for u, v, weight in G.edges(data="weight"): - print(weight) if not isinstance(weight, float) and not isinstance(weight, int): raise TypeError("The edge weights must be of type float or int") diff --git a/src/openqaoa-core/requirements_docs.txt b/src/openqaoa-core/requirements_docs.txt index 53ae73e39..fd7c6ca0f 100644 --- a/src/openqaoa-core/requirements_docs.txt +++ b/src/openqaoa-core/requirements_docs.txt @@ -3,4 +3,5 @@ sphinx-autodoc-typehints>=1.18.1 sphinx-rtd-theme>=1.0.0 nbsphinx>=0.8.9 ipython>=8.10.0 -nbconvert>=6.5.1 \ No newline at end of file +nbconvert>=6.5.1 +myst_parser>=2.0.0 \ No newline at end of file diff --git a/src/openqaoa-core/tests/test_bpsp.py b/src/openqaoa-core/tests/test_bpsp.py new file mode 100644 index 000000000..a8b083462 --- /dev/null +++ b/src/openqaoa-core/tests/test_bpsp.py @@ -0,0 +1,213 @@ +import unittest +import numpy as np +import networkx as nx +from docplex.mp.model import Model +from openqaoa.problems import BPSP +from docplex.mp.constants import ObjectiveSense + + +def terms_list_equality(terms_list1, terms_list2): + """ + Check the terms equality between two terms list + where the order of edges do not matter. + """ + if len(terms_list1) != len(terms_list2): + bool = False + else: + for term1, term2 in zip(terms_list1, terms_list2): + bool = True if (term1 == term2 or term1 == term2[::-1]) else False + + return bool + +def fisher_yates_shuffle(arr, rng): + """ + Perform an in-place shuffle of a list using the Fisher-Yates shuffle algorithm. + + This algorithm runs in O(n) time and ensures that every permutation of the array is equally likely. + The shuffle is performed in-place, meaning that the input array `arr` is modified directly. + + Parameters: + ----------- + arr : list + A list of elements to be shuffled. This list will be modified in place. + rng : numpy.random.Generator + A random number generator instance from NumPy for generating random numbers. + This allows for reproducibility and control over the random number generation. + + Returns: + -------- + list + The shuffled list. Note that the input list is shuffled in place, and the same list is returned. + + Example: + -------- + >>> from numpy.random import default_rng + >>> rng = default_rng(seed=42) + >>> arr = [1, 2, 3, 4, 5] + >>> fisher_yates_shuffle(arr, rng) + [3, 4, 1, 5, 2] # Output can vary based on the RNG seed and state. + """ + + # Iterate over the array from the last element down to the second element + for i in range(len(arr) - 1, 0, -1): + # Generate a random index to swap with the current element + j = rng.integers(0, i + 1) + + # Swap the current element with the randomly chosen element + arr[i], arr[j] = arr[j], arr[i] + + # Return the shuffled array + return arr + +class TestBPSP(unittest.TestCase): + """ + Test suite for the BPSP problem. + + This test suite checks the functionality of methods related to the BPSP problem, + including QUBO creation, car sequencing, solution methods, and more. + """ + + def test_bpsp_qubo(self): + """ + Test the correct QUBO formation from a provided graph. + + This method validates that BPSP creates the expected QUBO by comparing + its terms and weights with predefined expected values. + """ + car_sequence = [3, 1, 0, 0, 2, 2, 4, 4, 3, 1] + G = nx.Graph() + G.add_weighted_edges_from([[3, 1, -2], [3, 4, -1], [1, 0, -1], [0, 2, 1], [2, 4, 1]]) + + gr_edges = [[3, 1], [3, 4], [1, 0], [0, 2], [2, 4]] + gr_weights = [-2, -1, -1, 1, 1] + + bpsp_prob_qubo = BPSP(car_sequence).qubo + self.assertTrue(terms_list_equality(gr_edges, bpsp_prob_qubo.terms)) + self.assertEqual(gr_weights, bpsp_prob_qubo.weights) + self.assertEqual(0.0, bpsp_prob_qubo.constant) + + def test_bpsp_car_sequence(self): + """ + Test if ValueErrors are raised for invalid car sequences. + + Certain car sequences are expected to be invalid based on their content. + This method checks if setting such sequences raises a ValueError. + """ + bpsp = BPSP(np.array([0, 1, 0, 1])) + with self.assertRaises(ValueError): + bpsp.car_sequence = np.array([0, 1, 0]) + with self.assertRaises(ValueError): + bpsp.car_sequence = np.array([0, 0, 1, 2, 2, 3, 3, 3]) + + def test_bpsp_random_instance(self): + """ + Test the random instance generation of the Binary Paint Shop Problem (BPSP). + + This test verifies whether the `random_instance` method of the BPSP class + correctly creates a randomized car sequence based on a given number of cars and seed. + The car sequence should be a list containing two occurrences of each car ID, + randomly shuffled using the Fisher-Yates shuffle algorithm. + + The function asserts that the sequence generated by the BPSP class's method + is identical to the sequence produced by an explicitly defined Fisher-Yates shuffle process, + ensuring both consistency and correctness in the shuffling method based on a fixed seed. + """ + + # Seed and number of cars for generating the instance + seed = 1234 + num_cars = 10 + + # Lambda function to create and shuffle car sequence using Fisher-Yates algorithm + # The lambda function first duplicates each car ID using np.tile, then applies the shuffle. + create_car_seq = lambda num_cars, seed: fisher_yates_shuffle( + np.tile(np.arange(num_cars), 2), np.random.default_rng(seed)) + + # Generating a random BPSP instance using the class method + bpsp = BPSP.random_instance(num_cars=num_cars, seed=seed) + + # Asserting if the generated car sequence in BPSP instance is identical + # to the sequence produced by our lambda function. + # This confirms the random instance generation works as expected. + self.assertTrue(all(bpsp.car_sequence == create_car_seq(num_cars, seed)), + "The generated car sequence does not match the expected shuffled sequence.") + + def test_bpsp_car_pos(self): + """Test the retrieval of car positions.""" + bpsp = BPSP(np.array([0, 1, 0, 1])) + self.assertEqual(bpsp.car_positions, {0: (0, 2), 1: (1, 3)}) + + def test_bpsp_graph(self): + """Test the generation of a graph representation of the BPSP instance.""" + car_sequence = [3, 1, 0, 0, 2, 2, 4, 4, 3, 1] + G = nx.Graph() + G.add_weighted_edges_from([[3, 1, -2], [3, 4, -1], [1, 0, -1], [0, 2, 1], [2, 4, 1]]) + + bpsp_graph = BPSP(car_sequence).graph + + assert nx.is_isomorphic(G, bpsp_graph), "The created graph and BPSP graph are not identical," + + def test_bpsp_docplex_bpsp_model(self): + """Test if the docplex model representation of BPSP is generated.""" + bpsp = BPSP.random_instance(num_cars=2, seed=1234) + + # Obtain the model + mdl = bpsp.docplex_bpsp_model # Access as attribute due to @property decorator + + # Verify that the function returns a valid model instance + self.assertIsInstance(mdl, Model, "Model is not an instance of DOcplex Model") + + # Manually retrieve binary variables based on their expected names + sequence = bpsp.car_sequence + expected_var_names = [f"w_{w}_{i}" for i, w in enumerate(sequence)] + binary_vars = [mdl.get_var_by_name(name) for name in expected_var_names] + + # Check that all variables are present and are binary + self.assertEqual(len(binary_vars), 4, "Unexpected number of binary variables") + for var in binary_vars: + self.assertTrue(var is not None, f"Variable {var} not found in model") + self.assertTrue(var.is_binary(), f"Variable {var} is not binary") + + # Check number of constraints + self.assertEqual(mdl.number_of_constraints, 11, "Unexpected number of constraints") + + # Check if objective function exists + self.assertIsNotNone(mdl.objective_expr, "Objective function is missing") + + # Check if the objective is to minimize + self.assertEqual(mdl.objective_sense, ObjectiveSense.Minimize, "Objective should be of type 'minimize'") + + def test_bpsp_solve_cplex(self): + """ + Test the solution of the BPSP problem using CPLEX. + + This test assumes that CPLEX is installed and functional. It checks + the length of the solution and the objective value. + """ + bpsp = BPSP(np.array([0, 1, 0, 1])) + solution, objective_value = bpsp.solve_cplex() + self.assertEqual(solution, [1, 1, 0, 0]) + self.assertEqual(objective_value, 1) + + def test_bpsp_paintseq_from_bits(self): + """Test the solution of the BPSP problem using QAOA.""" + bpsp = BPSP(np.array([0, 1, 0, 1])) + sequence, color_swaps = bpsp.paintseq_from_bits('10') + self.assertEqual(sequence, [1, 0, 0, 1]) + self.assertEqual(color_swaps, 2) + + def test_bpsp_solve_redfirst(self): + """Test the solution of the BPSP problem using the Red-First method.""" + bpsp = BPSP(np.array([0, 1, 0, 1])) + sequence, color_swaps = bpsp.solve_redfirst() + self.assertEqual(sequence, [1, 1, 0, 0]) + self.assertEqual(color_swaps, 1) + + def test_bpsp_solve_greedy(self): + """Test the solution of the BPSP problem using the Greedy method.""" + bpsp = BPSP(np.array([0, 1, 0, 1])) + sequence, color_swaps = bpsp.solve_greedy() + self.assertEqual(sequence, [0, 0, 1, 1]) + self.assertEqual(color_swaps, 1) + +if __name__ == "__main__": + unittest.main() diff --git a/src/openqaoa-core/tests/test_qubo.py b/src/openqaoa-core/tests/test_qubo.py index 4b024e876..b1c14c598 100644 --- a/src/openqaoa-core/tests/test_qubo.py +++ b/src/openqaoa-core/tests/test_qubo.py @@ -17,6 +17,7 @@ BinPacking, SK, KColor, + BPSP, ) from openqaoa.utilities import convert2serialize from openqaoa.problems.helper_functions import create_problem_from_dict @@ -71,6 +72,7 @@ def __generate_random_problems(self): "k_color": KColor.random_instance( n_nodes=int(rng.integers(3, 8)), k=int(rng.integers(2, 5)), seed=seed ), + "binary_paint_shop_problem": BPSP.random_instance(num_cars=10, seed=seed), } qubo_random_instances = { k: v.qubo for k, v in problems_random_instances.items() @@ -157,6 +159,7 @@ def test_problem_instance(self): ], "sherrington_kirkpatrick": ["problem_type", "G"], "k_color": ["problem_type", "G", "k", "penalty"], + "binary_paint_shop_problem": ["problem_type", "car_sequence", "car_positions", "bpsp_graph"], "generic_qubo": ["problem_type"], } diff --git a/tests/test_imports.py b/tests/test_imports.py index 1928d0430..2fdaf5de0 100644 --- a/tests/test_imports.py +++ b/tests/test_imports.py @@ -17,7 +17,7 @@ def test_all_module_import(self): """ folder_names = [ - each_file for each_file in os.listdir("src") if "openqaoa-" in each_file + each_file for each_file in os.listdir("src") if ("openqaoa-" in each_file and not "openqaoa-pyquil") ] packages_import = []