%global _empty_manifest_terminate_build 0 Name: python-tweedledum Version: 1.1.1 Release: 1 Summary: A library for synthesizing and manipulating quantum circuits License: MIT URL: https://github.com/boschmitt/tweedledum Source0: https://mirrors.nju.edu.cn/pypi/web/packages/aa/b4/95e010aed16f5e35d43d8f16ae896c0f679c3a94b6a4a3dd410f273b5ab1/tweedledum-1.1.1.tar.gz %description

/!\ (Warning) If you have used tweedledum before: the master branch history is broken. /!\ The new master branch is a completely rewrite of the library. The old version can be found /!\ on **alpha** branch. (Sorry for the inconvenience!!---but it is for a great cause) **tweedledum** is a library for synthesis, compilation, and optimization of quantum circuits. The library is written to be scalable up to problem sizes in which quantum circuits outperform classical ones. Also, it is meant to be used both independently and alongside established tools. Its design is guided by three mantras: - __Gotta run fast__: execution-time performance is a priority. - __Your compiler, your rules__. You know better. At least, Tweedledum hopes so! The library provides a standard set of operators that can be easily extended (thanks to some type-erasure black magic). However, the library will leave your operators completely alone if you don't write passes that specifically manipulate them. Furthermore, Tweedledum will rarely take any decision in your behalf, i.e., it does not provide generic methods to optimize or synthesize circuits, you need to specifically call the algorithms you want. - __Opinionated, but not stubborn__. Many passes and synthesis algorithms have many configuration parameters. Tweedledum comes with reasonable defaults and curated opinions of what value such parameters should take. But in the end, it all up to you. __Corollary__: Because of it's flexibility, Tweedledum is capable of accepting gates/operators that are defined as python classes. Indeed, any pythonic framework can use the library as a circuit manager. Meaning that the library can be used to slowly transition the core and performance sensitive parts of a pythonic framework to C++, while maintaining the capability of users to develop passes in python. # Installation [Known issues](#known-issues) with _macOS High Sierra (10.13)_ and _macOS Mojave (10.14)_. `tweedledum` has two python packages that can be installed using `pip`. For both, you will at least __Python 3.6__. The `tweedledum` package contains the latest stable release. You can install it from PyPI using: * Latest stable release (Linux/Mac/Windows) ``` pip install tweedledum ``` For the developers, users or researchers who are comfortable living on the absolute bleeding edge, `tweedledum-dev` contains that latest developments merged into the master branch. * Latest (Linux/Mac/Windows) ``` pip install tweedledum-dev ``` __Warning__: The two packages cannot be installed together. # Installation from source (Development) Installing `tweedledum` from the source, instead of using the Python Package Index (PyPI) repository version, allows you to extend the latest version of the code. In the following, I will explain two workflows I personally use for development. Choose one that best suits your needs. Alright, both workflows start the same way. You clone the repository: ``` git clone https://github.com/boschmitt/tweedledum.git ``` ## C++ The first workflow is pure C++. We start by creating a directory to hold the build output: ``` mkdir build cd build ``` Note that the library has a directory named `examples/`. If we set the ``TWEEDLEDUM_EXAMPLES`` CMake variable to ``TRUE``. Any `.cpp` file in this directory will be compiled to its own executable. So, lets assume you have a file named `hello_world.cpp` in the `examples/`. First we configure our project and enable the examples: ``` cmake -DTWEEDLEDUM_EXAMPLES=TRUE .. ``` If you are on a \*nix system, you should now see a Makefile in the current directory. Now you can build the library by running `make`. At this point you can build the `hello_world` executable by calling ``` make hello_world ``` Once the examples have been built you can run it: ``` ./examples/hello_world ``` ## C++ and Python The second workflow is a bit of a hack. In Python we can install libraries in editable mode, meaning that code changes to the _Python code_ in the project don't require a reinstall to be applied. If you want to install it in editable mode, you can do this with: ``` pip install -e . ``` The only problem now, is that if we change the C++ code, we will need to reinstall the library. Fortunately, there is a way to circumvent this annoyance. After installing in editable mode, you will see that in `python/tweedledum/` there is a cpython shared library `_tweedledum.cpython-...` Remove this file: ```sh rm python/tweedledum/_tweedledum.cpython-... ``` Now, we create a build directory as we did with the C++ workflow: ```sh mkdir build cd build ``` We can manually build the cpython shared library using: ```sh make _tweedledum ``` This will create the library in the `build/` directory. Now, all we need to create a symbolic link in `python/tweedledum/` that points the library in `build/`: ```sh ln -s _tweedledum.cpython-39-darwin.so ../python/tweedledum/ ``` Now, whenever we change the C++ code and rebuild the python library, the changes won't require a reinstall of the library to be available. # Used third-party tools The library it is built, tested, bind to python, and whatnot using many third-party tools and services. Thanks a lot! - [**abc**](https://github.com/berkeley-abc/abc) - ABC: System for Sequential Logic Synthesis and Formal Verification - [**bill**](https://github.com/lsils/bill) - C++ header-only reasoning library - [**Catch2**](https://github.com/catchorg/Catch2) test framework for unit-tests, TDD and BDD - [**CMake**](https://cmake.org) for build automation - [**Eigen**](https://gitlab.com/libeigen/eigen) template library for linear algebra - [**{fmt}**](https://github.com/fmtlib/fmt) - A modern formatting library - [**kitty**](https://github.com/msoeken/kitty) - truth table library - [**lorina**](https://github.com/hriener/lorina) - C++ parsing library for simple formats used in logic synthesis and formal verification - [**mockturtle**](https://github.com/lsils/mockturtle) - C++ logic network library - [**nlohmann/json**](https://github.com/nlohmann/json) - JSON for Modern C++ - [**parallel_hashmap**](https://github.com/greg7mdp/parallel-hashmap) - A family of header-only, very fast and memory-friendly hashmap and btree containers. - [**percy**](https://github.com/lsils/percy) - C++ header-only exact synthesis library - [**pybind11**](https://github.com/pybind/pybind11) - Seamless operability between C++11 and Python - [**rang**](https://github.com/agauniyal/rang) - A Minimal, Header only Modern c++ library for terminal goodies ## Known issues These are issues that hopefully will be fixed, but currently are unsolved. If you know how to help with one of these issues, contributions are welcome! ### macOS: High Sierra (10.13) and Mojave (10.14) `tweedledum` offers limited support for both systems. While wheels might be available for some releases, it is strongly advised to install `tweedledum` or `tweedledum-dev` by building them directly from source. For example: ```sh CC=gcc-10 CXX=g++-10 CXXFLAGS="-static-libgcc -static-libstdc++" pip install tweedledum --no-binary :all: ``` Note that such command requires a working `gcc10` installation. (It also works with `gcc11`, but no further tests were made.) I recommend the use of [Homebrew](https://brew.sh) to install `gcc`. (Or maybe [Tigerbrew](https://github.com/mistydemeo/tigerbrew)) ## License This software is licensed under the MIT licence (see [LICENSE](https://github.com/boschmitt/tweedledum/blob/master/LICENSE)). ## EPFL logic synthesis libraries tweedledum is part of the [EPFL logic synthesis](https://lsi.epfl.ch/page-138455-en.html) libraries. The other libraries and several examples on how to use and integrate the libraries can be found in the [logic synthesis tool showcase](https://github.com/lsils/lstools-showcase). %package -n python3-tweedledum Summary: A library for synthesizing and manipulating quantum circuits Provides: python-tweedledum BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip BuildRequires: python3-cffi BuildRequires: gcc BuildRequires: gdb %description -n python3-tweedledum

/!\ (Warning) If you have used tweedledum before: the master branch history is broken. /!\ The new master branch is a completely rewrite of the library. The old version can be found /!\ on **alpha** branch. (Sorry for the inconvenience!!---but it is for a great cause) **tweedledum** is a library for synthesis, compilation, and optimization of quantum circuits. The library is written to be scalable up to problem sizes in which quantum circuits outperform classical ones. Also, it is meant to be used both independently and alongside established tools. Its design is guided by three mantras: - __Gotta run fast__: execution-time performance is a priority. - __Your compiler, your rules__. You know better. At least, Tweedledum hopes so! The library provides a standard set of operators that can be easily extended (thanks to some type-erasure black magic). However, the library will leave your operators completely alone if you don't write passes that specifically manipulate them. Furthermore, Tweedledum will rarely take any decision in your behalf, i.e., it does not provide generic methods to optimize or synthesize circuits, you need to specifically call the algorithms you want. - __Opinionated, but not stubborn__. Many passes and synthesis algorithms have many configuration parameters. Tweedledum comes with reasonable defaults and curated opinions of what value such parameters should take. But in the end, it all up to you. __Corollary__: Because of it's flexibility, Tweedledum is capable of accepting gates/operators that are defined as python classes. Indeed, any pythonic framework can use the library as a circuit manager. Meaning that the library can be used to slowly transition the core and performance sensitive parts of a pythonic framework to C++, while maintaining the capability of users to develop passes in python. # Installation [Known issues](#known-issues) with _macOS High Sierra (10.13)_ and _macOS Mojave (10.14)_. `tweedledum` has two python packages that can be installed using `pip`. For both, you will at least __Python 3.6__. The `tweedledum` package contains the latest stable release. You can install it from PyPI using: * Latest stable release (Linux/Mac/Windows) ``` pip install tweedledum ``` For the developers, users or researchers who are comfortable living on the absolute bleeding edge, `tweedledum-dev` contains that latest developments merged into the master branch. * Latest (Linux/Mac/Windows) ``` pip install tweedledum-dev ``` __Warning__: The two packages cannot be installed together. # Installation from source (Development) Installing `tweedledum` from the source, instead of using the Python Package Index (PyPI) repository version, allows you to extend the latest version of the code. In the following, I will explain two workflows I personally use for development. Choose one that best suits your needs. Alright, both workflows start the same way. You clone the repository: ``` git clone https://github.com/boschmitt/tweedledum.git ``` ## C++ The first workflow is pure C++. We start by creating a directory to hold the build output: ``` mkdir build cd build ``` Note that the library has a directory named `examples/`. If we set the ``TWEEDLEDUM_EXAMPLES`` CMake variable to ``TRUE``. Any `.cpp` file in this directory will be compiled to its own executable. So, lets assume you have a file named `hello_world.cpp` in the `examples/`. First we configure our project and enable the examples: ``` cmake -DTWEEDLEDUM_EXAMPLES=TRUE .. ``` If you are on a \*nix system, you should now see a Makefile in the current directory. Now you can build the library by running `make`. At this point you can build the `hello_world` executable by calling ``` make hello_world ``` Once the examples have been built you can run it: ``` ./examples/hello_world ``` ## C++ and Python The second workflow is a bit of a hack. In Python we can install libraries in editable mode, meaning that code changes to the _Python code_ in the project don't require a reinstall to be applied. If you want to install it in editable mode, you can do this with: ``` pip install -e . ``` The only problem now, is that if we change the C++ code, we will need to reinstall the library. Fortunately, there is a way to circumvent this annoyance. After installing in editable mode, you will see that in `python/tweedledum/` there is a cpython shared library `_tweedledum.cpython-...` Remove this file: ```sh rm python/tweedledum/_tweedledum.cpython-... ``` Now, we create a build directory as we did with the C++ workflow: ```sh mkdir build cd build ``` We can manually build the cpython shared library using: ```sh make _tweedledum ``` This will create the library in the `build/` directory. Now, all we need to create a symbolic link in `python/tweedledum/` that points the library in `build/`: ```sh ln -s _tweedledum.cpython-39-darwin.so ../python/tweedledum/ ``` Now, whenever we change the C++ code and rebuild the python library, the changes won't require a reinstall of the library to be available. # Used third-party tools The library it is built, tested, bind to python, and whatnot using many third-party tools and services. Thanks a lot! - [**abc**](https://github.com/berkeley-abc/abc) - ABC: System for Sequential Logic Synthesis and Formal Verification - [**bill**](https://github.com/lsils/bill) - C++ header-only reasoning library - [**Catch2**](https://github.com/catchorg/Catch2) test framework for unit-tests, TDD and BDD - [**CMake**](https://cmake.org) for build automation - [**Eigen**](https://gitlab.com/libeigen/eigen) template library for linear algebra - [**{fmt}**](https://github.com/fmtlib/fmt) - A modern formatting library - [**kitty**](https://github.com/msoeken/kitty) - truth table library - [**lorina**](https://github.com/hriener/lorina) - C++ parsing library for simple formats used in logic synthesis and formal verification - [**mockturtle**](https://github.com/lsils/mockturtle) - C++ logic network library - [**nlohmann/json**](https://github.com/nlohmann/json) - JSON for Modern C++ - [**parallel_hashmap**](https://github.com/greg7mdp/parallel-hashmap) - A family of header-only, very fast and memory-friendly hashmap and btree containers. - [**percy**](https://github.com/lsils/percy) - C++ header-only exact synthesis library - [**pybind11**](https://github.com/pybind/pybind11) - Seamless operability between C++11 and Python - [**rang**](https://github.com/agauniyal/rang) - A Minimal, Header only Modern c++ library for terminal goodies ## Known issues These are issues that hopefully will be fixed, but currently are unsolved. If you know how to help with one of these issues, contributions are welcome! ### macOS: High Sierra (10.13) and Mojave (10.14) `tweedledum` offers limited support for both systems. While wheels might be available for some releases, it is strongly advised to install `tweedledum` or `tweedledum-dev` by building them directly from source. For example: ```sh CC=gcc-10 CXX=g++-10 CXXFLAGS="-static-libgcc -static-libstdc++" pip install tweedledum --no-binary :all: ``` Note that such command requires a working `gcc10` installation. (It also works with `gcc11`, but no further tests were made.) I recommend the use of [Homebrew](https://brew.sh) to install `gcc`. (Or maybe [Tigerbrew](https://github.com/mistydemeo/tigerbrew)) ## License This software is licensed under the MIT licence (see [LICENSE](https://github.com/boschmitt/tweedledum/blob/master/LICENSE)). ## EPFL logic synthesis libraries tweedledum is part of the [EPFL logic synthesis](https://lsi.epfl.ch/page-138455-en.html) libraries. The other libraries and several examples on how to use and integrate the libraries can be found in the [logic synthesis tool showcase](https://github.com/lsils/lstools-showcase). %package help Summary: Development documents and examples for tweedledum Provides: python3-tweedledum-doc %description help

/!\ (Warning) If you have used tweedledum before: the master branch history is broken. /!\ The new master branch is a completely rewrite of the library. The old version can be found /!\ on **alpha** branch. (Sorry for the inconvenience!!---but it is for a great cause) **tweedledum** is a library for synthesis, compilation, and optimization of quantum circuits. The library is written to be scalable up to problem sizes in which quantum circuits outperform classical ones. Also, it is meant to be used both independently and alongside established tools. Its design is guided by three mantras: - __Gotta run fast__: execution-time performance is a priority. - __Your compiler, your rules__. You know better. At least, Tweedledum hopes so! The library provides a standard set of operators that can be easily extended (thanks to some type-erasure black magic). However, the library will leave your operators completely alone if you don't write passes that specifically manipulate them. Furthermore, Tweedledum will rarely take any decision in your behalf, i.e., it does not provide generic methods to optimize or synthesize circuits, you need to specifically call the algorithms you want. - __Opinionated, but not stubborn__. Many passes and synthesis algorithms have many configuration parameters. Tweedledum comes with reasonable defaults and curated opinions of what value such parameters should take. But in the end, it all up to you. __Corollary__: Because of it's flexibility, Tweedledum is capable of accepting gates/operators that are defined as python classes. Indeed, any pythonic framework can use the library as a circuit manager. Meaning that the library can be used to slowly transition the core and performance sensitive parts of a pythonic framework to C++, while maintaining the capability of users to develop passes in python. # Installation [Known issues](#known-issues) with _macOS High Sierra (10.13)_ and _macOS Mojave (10.14)_. `tweedledum` has two python packages that can be installed using `pip`. For both, you will at least __Python 3.6__. The `tweedledum` package contains the latest stable release. You can install it from PyPI using: * Latest stable release (Linux/Mac/Windows) ``` pip install tweedledum ``` For the developers, users or researchers who are comfortable living on the absolute bleeding edge, `tweedledum-dev` contains that latest developments merged into the master branch. * Latest (Linux/Mac/Windows) ``` pip install tweedledum-dev ``` __Warning__: The two packages cannot be installed together. # Installation from source (Development) Installing `tweedledum` from the source, instead of using the Python Package Index (PyPI) repository version, allows you to extend the latest version of the code. In the following, I will explain two workflows I personally use for development. Choose one that best suits your needs. Alright, both workflows start the same way. You clone the repository: ``` git clone https://github.com/boschmitt/tweedledum.git ``` ## C++ The first workflow is pure C++. We start by creating a directory to hold the build output: ``` mkdir build cd build ``` Note that the library has a directory named `examples/`. If we set the ``TWEEDLEDUM_EXAMPLES`` CMake variable to ``TRUE``. Any `.cpp` file in this directory will be compiled to its own executable. So, lets assume you have a file named `hello_world.cpp` in the `examples/`. First we configure our project and enable the examples: ``` cmake -DTWEEDLEDUM_EXAMPLES=TRUE .. ``` If you are on a \*nix system, you should now see a Makefile in the current directory. Now you can build the library by running `make`. At this point you can build the `hello_world` executable by calling ``` make hello_world ``` Once the examples have been built you can run it: ``` ./examples/hello_world ``` ## C++ and Python The second workflow is a bit of a hack. In Python we can install libraries in editable mode, meaning that code changes to the _Python code_ in the project don't require a reinstall to be applied. If you want to install it in editable mode, you can do this with: ``` pip install -e . ``` The only problem now, is that if we change the C++ code, we will need to reinstall the library. Fortunately, there is a way to circumvent this annoyance. After installing in editable mode, you will see that in `python/tweedledum/` there is a cpython shared library `_tweedledum.cpython-...` Remove this file: ```sh rm python/tweedledum/_tweedledum.cpython-... ``` Now, we create a build directory as we did with the C++ workflow: ```sh mkdir build cd build ``` We can manually build the cpython shared library using: ```sh make _tweedledum ``` This will create the library in the `build/` directory. Now, all we need to create a symbolic link in `python/tweedledum/` that points the library in `build/`: ```sh ln -s _tweedledum.cpython-39-darwin.so ../python/tweedledum/ ``` Now, whenever we change the C++ code and rebuild the python library, the changes won't require a reinstall of the library to be available. # Used third-party tools The library it is built, tested, bind to python, and whatnot using many third-party tools and services. Thanks a lot! - [**abc**](https://github.com/berkeley-abc/abc) - ABC: System for Sequential Logic Synthesis and Formal Verification - [**bill**](https://github.com/lsils/bill) - C++ header-only reasoning library - [**Catch2**](https://github.com/catchorg/Catch2) test framework for unit-tests, TDD and BDD - [**CMake**](https://cmake.org) for build automation - [**Eigen**](https://gitlab.com/libeigen/eigen) template library for linear algebra - [**{fmt}**](https://github.com/fmtlib/fmt) - A modern formatting library - [**kitty**](https://github.com/msoeken/kitty) - truth table library - [**lorina**](https://github.com/hriener/lorina) - C++ parsing library for simple formats used in logic synthesis and formal verification - [**mockturtle**](https://github.com/lsils/mockturtle) - C++ logic network library - [**nlohmann/json**](https://github.com/nlohmann/json) - JSON for Modern C++ - [**parallel_hashmap**](https://github.com/greg7mdp/parallel-hashmap) - A family of header-only, very fast and memory-friendly hashmap and btree containers. - [**percy**](https://github.com/lsils/percy) - C++ header-only exact synthesis library - [**pybind11**](https://github.com/pybind/pybind11) - Seamless operability between C++11 and Python - [**rang**](https://github.com/agauniyal/rang) - A Minimal, Header only Modern c++ library for terminal goodies ## Known issues These are issues that hopefully will be fixed, but currently are unsolved. If you know how to help with one of these issues, contributions are welcome! ### macOS: High Sierra (10.13) and Mojave (10.14) `tweedledum` offers limited support for both systems. While wheels might be available for some releases, it is strongly advised to install `tweedledum` or `tweedledum-dev` by building them directly from source. For example: ```sh CC=gcc-10 CXX=g++-10 CXXFLAGS="-static-libgcc -static-libstdc++" pip install tweedledum --no-binary :all: ``` Note that such command requires a working `gcc10` installation. (It also works with `gcc11`, but no further tests were made.) I recommend the use of [Homebrew](https://brew.sh) to install `gcc`. (Or maybe [Tigerbrew](https://github.com/mistydemeo/tigerbrew)) ## License This software is licensed under the MIT licence (see [LICENSE](https://github.com/boschmitt/tweedledum/blob/master/LICENSE)). ## EPFL logic synthesis libraries tweedledum is part of the [EPFL logic synthesis](https://lsi.epfl.ch/page-138455-en.html) libraries. The other libraries and several examples on how to use and integrate the libraries can be found in the [logic synthesis tool showcase](https://github.com/lsils/lstools-showcase). %prep %autosetup -n tweedledum-1.1.1 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-tweedledum -f filelist.lst %dir %{python3_sitearch}/* %files help -f doclist.lst %{_docdir}/* %changelog * Sun Apr 23 2023 Python_Bot - 1.1.1-1 - Package Spec generated