mqt.problemsolver 0.3.0__tar.gz → 0.4__tar.gz

{mqt.problemsolver-0.3.0 → mqt_problemsolver-0.4}/.github/codecov.yml

@@ -1,5 +1,6 @@
 ignore:
   - "tests/**/*"
+  - "resource_estimation/**/*"
 
 coverage:
   range: 60..90

{mqt.problemsolver-0.3.0 → mqt_problemsolver-0.4}/.github/workflows/coverage.yml

@@ -17,11 +17,11 @@ jobs:
         with:
           python-version: "3.9"
       - name: Install MQT ProblemSolver
-        run: pip install .[coverage]
+        run: pip install .[coverage,tweedledum]
       - name: Generate Report
         run: pytest -v --cov --cov-config=pyproject.toml --cov-report=xml
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}

{mqt.problemsolver-0.3.0 → mqt_problemsolver-0.4}/.github/workflows/deploy.yml

@@ -4,64 +4,68 @@ on:
   release:
     types: [published]
   push:
-    branches: [main, master]
+    branches: [main]
   pull_request:
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
 jobs:
   build_wheel:
     name: Build wheel
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@v4
-        name: Install Python
+      - uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
-      - name: Install dependencies
-        run: python -m pip install build
+          python-version: "3.10"
+        name: Install Python
       - name: Build wheel
-        run: python -m build --wheel
+        run: pipx run build --wheel
       - name: Install wheel
         run: python -m pip install --verbose dist/*.whl
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
+          name: cibw-wheel
           path: dist/*.whl
 
   build_sdist:
     name: Build src distribution
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: actions/setup-python@v4
-        name: Install Python
+      - uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
-      - name: Install dependencies
-        run: python -m pip install build
+          python-version: "3.10"
+        name: Install Python
       - name: Build sdist
-        run: python -m build --sdist
+        run: pipx run build --sdist
       - name: Install sdist
         run: python -m pip install --verbose dist/*.tar.gz
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
+          name: cibw-sdist
           path: dist/*.tar.gz
 
   upload_pypi:
     needs: [build_wheel, build_sdist]
     runs-on: ubuntu-latest
     if: github.event_name == 'release' && github.event.action == 'published'
+    environment:
+      name: pypi
+      url: https://pypi.org/p/mqt.problemsolver
+    permissions:
+      id-token: write
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: artifact
+          pattern: cibw-*
           path: dist
+          merge-multiple: true
       - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          password: ${{ secrets.pypi_password }}
-          skip-existing: true
-          verbose: true

{mqt.problemsolver-0.3.0 → mqt_problemsolver-0.4}/.pre-commit-config.yaml

@@ -15,7 +15,7 @@ ci:
 repos:
   # Standard hooks
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: "v4.5.0"
+    rev: "v4.6.0"
     hooks:
       - id: check-added-large-files
       - id: check-case-conflict
@@ -32,14 +32,14 @@ repos:
 
   # Handling unwanted unicode characters
   - repo: https://github.com/sirosen/texthooks
-    rev: "0.6.3"
+    rev: "0.6.7"
     hooks:
       - id: fix-ligatures
       - id: fix-smartquotes
 
   # Check for spelling
   - repo: https://github.com/codespell-project/codespell
-    rev: "v2.2.6"
+    rev: "v2.3.0"
     hooks:
       - id: codespell
         args: ["-L", "wille,linz"]
@@ -56,7 +56,7 @@ repos:
         types_or: [yaml, markdown, html, css, javascript, json]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.13
+    rev: v0.6.2
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]
@@ -66,19 +66,19 @@ repos:
 
   # Also run Black on examples in the documentation
   - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.16.0
+    rev: 1.18.0
     hooks:
       - id: blacken-docs
-        additional_dependencies: [black==23.*]
+        additional_dependencies: [black==24.*]
 
   # Clean jupyter notebooks
   - repo: https://github.com/srstevenson/nb-clean
-    rev: "3.2.0"
+    rev: "3.3.0"
     hooks:
       - id: nb-clean
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.8.0
+    rev: v1.11.2
     hooks:
       - id: mypy
         files: ^(src|tests|setup.py)
@@ -89,3 +89,4 @@ repos:
           - networkx
           - mqt.ddsim
           - pytest
+          - pandas-stubs

mqt_problemsolver-0.4/PKG-INFO

@@ -0,0 +1,298 @@
+Metadata-Version: 2.1
+Name: mqt.problemsolver
+Version: 0.4
+Summary: MQT ProblemSolver - A MQT tool for Solving Problems Using Quantum Computing
+Author-email: Nils Quetschlich <nils.quetschlich@tum.de>, Lukas Burgholzer <lukas.burgholzer@jku.at>
+Project-URL: Homepage, https://github.com/cda-tum/mqtproblemsolver
+Project-URL: Bug Tracker, https://github.com/cda-tum/mqtproblemsolver/issues
+Project-URL: Discussions, https://github.com/cda-tum/mqtproblemsolver/discussions
+Project-URL: Research, https://www.cda.cit.tum.de/research/quantum/
+Keywords: MQT,quantum computing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: qiskit<0.42.0,>=0.36.0
+Requires-Dist: joblib
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: mqt.ddsim
+Requires-Dist: networkx
+Requires-Dist: python_tsp
+Requires-Dist: docplex
+Requires-Dist: qiskit_optimization
+Requires-Dist: qiskit_aer
+Requires-Dist: pandas
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: coverage
+Requires-Dist: mqt.problemsolver[test]; extra == "coverage"
+Requires-Dist: coverage[toml]~=6.5.0; extra == "coverage"
+Requires-Dist: pytest-cov~=4.0.0; extra == "coverage"
+Provides-Extra: dev
+Requires-Dist: mqt.problemsolver[coverage]; extra == "dev"
+Provides-Extra: tweedledum
+Requires-Dist: tweedledum==1.0.0; extra == "tweedledum"
+
+[![CodeCov](https://github.com/cda-tum/MQTProblemSolver/actions/workflows/coverage.yml/badge.svg)](https://github.com/cda-tum/MQTProblemSolver/actions/workflows/coverage.yml)
+[![Deploy to PyPI](https://github.com/cda-tum/MQTProblemSolver/actions/workflows/deploy.yml/badge.svg)](https://github.com/cda-tum/MQTProblemSolver/actions/workflows/deploy.yml)
+
+<p align="center">
+  <a href="https://mqt.readthedocs.io">
+   <picture>
+     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/mqt_light.png" width="60%">
+     <img src="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/mqt_dark.png" width="60%">
+   </picture>
+  </a>
+</p>
+
+# MQT ProblemSolver
+
+This repository covers the implementations of multiple research papers in the domain of quantum computing:
+
+1. [Towards an Automated Framework for Realizing Quantum Computing Solutions](#towards-an-automated-framework-for-realizing-quantum-computing-solutions)
+2. [A Hybrid Classical Quantum Computing Approach to the Satellite Mission Planning Problem](#a-hybrid-classical-quantum-computing-approach-to-the-satellite-mission-planning-problem)
+3. [Reducing the Compilation Time of Quantum Circuits Using Pre-Compilation on the Gate Level](#reducing-the-compilation-time-of-quantum-circuits-using-pre-compilation-on-the-gate-level)
+4. [Utilizing Resource Estimation for the Development of Quantum Computing Applications](#utilizing-resource-estimation-for-the-development-of-quantum-computing-applications)
+5. [Towards Equivalence Checking of Classical Circuits Using Quantum Computing](#towards-equivalence-checking-of-classical-circuits-using-quantum-computing)
+
+In the following, each implementation is briefly introduced.
+
+# Towards an Automated Framework for Realizing Quantum Computing Solutions
+
+MQT ProblemSolver provides a framework to utilize quantum computing as a technology for users with little to no
+quantum computing knowledge that is part of the Munich Quantum Toolkit (MQT) developed by the [Chair for Design Automation](https://www.cda.cit.tum.de/) at the [Technical University of Munich](https://www.tum.de/).
+All necessary quantum parts are embedded by domain experts while the interfaces provided are similar to the ones
+classical solver provide:
+
+<p align="center">
+<img src="img/framework.png" height=300px>
+</p>
+
+When provided with a problem description, MQT ProblemSolver offers a selection of implemented quantum algorithms.
+The user just has to chose one and all further (quantum) calculation steps are encapsulated within MQT ProblemSolver.
+After the calculation finished, the respective solution is returned - again in the same format as classical
+solvers use.
+
+In the current implementation, two case studies are conducted:
+
+1. A SAT Problem: Constraint Satisfaction Problem
+2. A Graph-based Optimization Problem: Travelling Salesman Problem
+
+## A SAT Problem: Constraint Satisfaction Problem
+
+This exemplary implementation can be found in the [CSP_example.ipynb](notebooks/csp_example.ipynb) Jupyter notebook.
+Here, the solution to a Kakuro riddle with a 2x2 grid can be solved for arbitrary sums `s0` to `s3`:
+
+<p align="center">
+<img src="img/kakuro.png" height=100px>
+</p>
+
+MQT ProblemSolver will return valid values to `a`, `b`, `c`, and `d` if a solution exists.
+
+## A Graph-based Optimization Problem: Travelling Salesman Problem
+
+This exemplary implementation can be found in the [TSP_example.ipynb](notebooks/tsp_example.ipynb) Jupyter notebook.
+Here, the solution to a Travelling Salesman Problem with 4 cities can be solved for arbitrary distances `dist_1_2` to `dist_3_4`between the cities.
+
+<p align="center">
+<img src="img/tsp.png" height=200px>
+</p>
+
+MQT ProblemSolver will return the shortest path visiting all cities as a list.
+
+# A Hybrid Classical Quantum Computing Approach to the Satellite Mission Planning Problem
+
+Additional to the two case studies, we provide a more complex example for the satellite mission planning problem.
+The goal is to maximize the accumulated values of all images taken by the satellite while it is often not possible
+to take all images since the satellite must rotate and adjust its optics.
+
+In the following example, there are five to-be-captured locations which their assigned value.
+
+<p align="center">
+<img src="img/satellite_mission_planning_problem.png" height=200px>
+</p>
+
+# Reducing the Compilation Time of Quantum Circuits Using Pre-Compilation on the Gate Level
+
+Every quantum computing application must be encoded into a quantum circuit and then compiled for a specific device.
+This lengthy compilation process is a key bottleneck and intensifies for recurring problems---each of which requires
+a new compilation run thus far.
+
+<p align="center">
+<img src="img/workflow_old.png">
+</p>
+
+Pre-compilation is a promising approach to overcome this bottleneck.
+Beginning with a problem class and suitable quantum algorithm, a **predictive encoding** scheme is applied to encode a
+representative problem instance into a general-purpose quantum circuit for that problem class.
+Once the real problem instance is known, the previously constructed circuit only needs to be
+**adjusted**—with (nearly) no compilation necessary:
+
+<p align="center">
+<img src="img/workflow_new.png">
+</p>
+Following this approach, we provide a pre-compilation module that can be used to precompile QAOA circuits
+for the MaxCut problem.
+
+# Utilizing Resource Estimation for the Development of Quantum Computing Applications
+
+Resource estimation is a promising alternative to actually execute quantum circuits on real quantum hardware which is
+currently restricted by the number of qubits and the error rates. By estimating the resources needed for a quantum circuit,
+the development of quantum computing applications can be accelerated without the need to wait for the availability of
+large-enough quantum hardware.
+
+In `resource_estimation/RE_experiments.py`, we evaluate the resources to calculate the ground state energy of a
+Hamiltonian to chemical accuracy of 1 mHartree using the qubitization quantum simulation algorithm. The Hamiltonian
+describes the 64 electron and 56 orbital active space of one of the stable intermediates in the ruthenium-catalyzed
+carbon fixation cycle
+
+In this evaluation, we investigate
+
+- different qubit technologies,
+- the impact of the maximal number of T factories,
+- different design trade-offs, and
+- hypothesis on how quantum hardware might improve and how it affects the required resources.
+
+# Towards Equivalence Checking of Classical Circuits Using Quantum Computing
+
+Equivalence checking, i.e., verifying whether two circuits realize the same functionality or not, is a typical task in the semiconductor industry. Due to the fact, that the designs grow faster than the ability to efficiently verify them, all alternative directions to close the resulting verification gap should be considered. In this work, we consider the problem through the miter structure. Here, two circuits to be checked are applied with the same primary inputs. Then, for each pair of to-be-equal output bits, an exclusive-OR (XOR) gate is applied-evaluating to 1 if the two outputs generate different values (which only happens in the case of non-equivalence). By OR-ing the outputs of all these XOR gates, eventually an indicator results that shows whether both circuits are equivalent. Then, the goal is to determine an input assignment so that this indicator evaluates to 1 (providing a counter example that shows non-equivalence) or to prove that no such assignment exists (proving equivalence).
+
+<p align="center">
+<img src="img/miter_structure.png" height=250px>
+</p>
+
+In the `equivalence_checking` module, our approach to this problem by utilizing quantum computing is implemented. There are two different ways to run this code.
+
+- One to test, how well certain parameter combinations work. The parameters consist of the number of bits of the circuits to be verified, the threshold parameter delta (which is explained in detail in the paper), the fraction of input combinations that induce non-equivalence of the circuits (further called "counter examples"), the number of shots to run the quantum circuit for and the number of individual runs of the experiment. Multiple parameter combinations can be tested and exported as a .csv-file at a provided location.
+- A second one to actually input a miter expression (in form of a string) together with some parameters independent from the miter (shots and delta) and use our approach to find the counter examples (if the circuits are non-equivalent).
+
+These two implementations are provided by the functions `try_parameter_combinations()` and `find_counter_examples()`, respectively. Examples for their usages are shown in `notebooks/equivalence_checking/example.ipynb`.
+
+# Usage
+
+MQT ProblemSolver is available via [PyPI](https://pypi.org/project/mqt.problemsolver/):
+
+```console
+(venv) $ pip install mqt.problemsolver
+```
+
+# References
+
+In case you are using MQT ProblemSolver in your work, we would be thankful if you referred to it by citing the following publication:
+
+```bibtex
+@INPROCEEDINGS{quetschlich2023mqtproblemsolver,
+    title           = {{Towards an Automated Framework for Realizing Quantum Computing Solutions}},
+    author          = {N. Quetschlich and L. Burgholzer and R. Wille},
+    eprint          = {2210.14928},
+    archivePrefix   = {arXiv},
+    year            = {2023},
+    booktitle       = {International Symposium on Multiple-Valued Logic (ISMVL)},
+}
+```
+
+which is also available on arXiv:
+[![a](https://img.shields.io/static/v1?label=arXiv&message=2210.14928&color=inactive&style=flat-square)](https://arxiv.org/abs/2210.14928)
+
+In case you are using our Satellite Mission Planning Problem approach, we would be thankful if you referred to it by citing the following publication:
+
+```bibtex
+@INPROCEEDINGS{quetschlich2023satellite,
+    title           = {{A Hybrid Classical Quantum Computing Approach to the Satellite Mission Planning Problem}},
+    author          = {N. Quetschlich and V. Koch and L. Burgholzer and R. Wille},
+    eprint          = {2308.00029},
+    archivePrefix   = {arXiv},
+    year            = {2023},
+    booktitle       = {IEEE International Conference on Quantum Computing and Engineering (QCE)},
+}
+```
+
+which is also available on arXiv:
+[![a](https://img.shields.io/static/v1?label=arXiv&message=2308.00029&color=inactive&style=flat-square)](https://arxiv.org/abs/2308.00029)
+
+In case you are using our Pre-Compilation approach, we would be thankful if you referred to it by citing the following publication:
+
+```bibtex
+@INPROCEEDINGS{quetschlich2023precompilation,
+    title           = {{Reducing the Compilation Time of Quantum Circuits Using Pre-Compilation on the Gate Level}},
+    author          = {N. Quetschlich and L. Burgholzer and R. Wille},
+    eprint          = {2305.04941},
+    archivePrefix   = {arXiv},
+    year            = {2023},
+    booktitle       = {IEEE International Conference on Quantum Computing and Engineering (QCE)},
+}
+```
+
+which is also available on arXiv:
+[![a](https://img.shields.io/static/v1?label=arXiv&message=2305.04941&color=inactive&style=flat-square)](https://arxiv.org/abs/2305.04941)
+
+In case you are using our Resources Estimation approach, we would be thankful if you referred to it by citing the following publication:
+
+```bibtex
+@misc{quetschlich2024resource_estimation,
+    title           = {{Utilizing Resource Estimation for the Development of Quantum Computing Applications}},
+    author          = {N. Quetschlich and M. Soeken and P. Murali and R. Wille},
+    eprint          = {2402.12434},
+    archivePrefix   = {arXiv},
+    year            = {2024},
+    booktitle       = {IEEE International Conference on Quantum Computing and Engineering (QCE)},
+}
+```
+
+which is also available on arXiv:
+[![a](https://img.shields.io/static/v1?label=arXiv&message=2402.12434&color=inactive&style=flat-square)](https://arxiv.org/abs/2402.12434)
+
+In case you are using our Equivalence-Checking approach, we would be thankful if you referred to it by citing the following publication:
+
+```bibtex
+@INPROCEEDINGS{quetschlich2024equivalence_checking,
+    title           = {{Towards Equivalence Checking of Classical Circuits Using Quantum Computing}},
+    author          = {N. Quetschlich and T. Forster and A. Osterwind and D. Helms and R. Wille},
+    eprint          = {2408.14539},
+    archivePrefix   = {arXiv},
+    year            = {2024},
+    booktitle       = {IEEE International Conference on Quantum Computing and Engineering (QCE)},
+}
+```
+
+which is also available on arXiv:
+[![a](https://img.shields.io/static/v1?label=arXiv&message=2408.14539&color=inactive&style=flat-square)](https://arxiv.org/abs/2408.14539)
+
+## Acknowledgements
+
+This project received funding from the European Research Council (ERC) under the European Union's Horizon 2020 research
+and innovation program (DA QC, grant agreement No. 101001318 and MILLENION, grant agreement No. 101114305), was part
+of the Munich Quantum Valley, which is supported by the Bavarian state government with funds from the Hightech Agenda
+Bayern Plus, and has been supported by the BMWK on the basis of a decision by the German Bundestag through project
+QuaST, as well as by the BMK, BMDW, the State of Upper Austria in the frame of the COMET program, and the QuantumReady
+project within Quantum Austria (managed by the FFG).
+
+<p align="center">
+<picture>
+<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/tum_dark.svg" width="28%">
+<img src="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/tum_light.svg" width="28%" alt="TUM Logo">
+</picture>
+<picture>
+<img src="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/logo-bavaria.svg" width="16%" alt="Coat of Arms of Bavaria">
+</picture>
+<picture>
+<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/erc_dark.svg" width="24%">
+<img src="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/erc_light.svg" width="24%" alt="ERC Logo">
+</picture>
+<picture>
+<img src="https://raw.githubusercontent.com/cda-tum/mqt/main/docs/_static/logo-mqv.svg" width="28%" alt="MQV Logo">
+</picture>
+</p>