%global _empty_manifest_terminate_build 0 Name: python-mthree Version: 2.5.1 Release: 1 Summary: M3: Matrix-free measurement mitigation License: Apache 2.0 URL: https://pypi.org/project/mthree/ Source0: https://mirrors.nju.edu.cn/pypi/web/packages/eb/a8/c63caea37476790a552698b867bb151734f9139406ef2dfb4ec2324e7aaf/mthree-2.5.1.tar.gz %description # mthree [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) [![PyPI version](https://badge.fury.io/py/mthree.svg)](https://badge.fury.io/py/mthree) [![pypi](https://img.shields.io/pypi/dm/mthree.svg)](https://pypi.org/project/mthree/) ![workflow](https://github.com/Qiskit-Partners/mthree/actions/workflows/python-package-conda.yml/badge.svg) Matrix-free Measurement Mitigation (M3). M3 is a measurement mitigation technique that solves for corrected measurement probabilities using a dimensionality reduction step followed by either direct LU factorization or a preconditioned iterative method that nominally converges in O(1) steps, and can be computed in parallel. For example, M3 can compute corrections on 42 qubit GHZ problems in under two seconds on a quad-core machine (depending on the number of unique bitstrings in the output). ## Documentation [Online Documentation @ Qiskit.org](https://qiskit.org/ecosystem/mthree/) ## Installation You can `pip` install M3 in serial mode using PyPi via: ```bash pip install mthree ``` Alternatively, one can install from source: ```bash python setup.py install ``` To enable openmp one must have an openmp 3.0+ enabled compiler and install with: ```bash python setup.py install --with-openmp ``` Optionally one can also set `-march=native` using: ```bash python setup.py install --with-native ``` The `openmp` and `native` flags can be used simultaneously using a comma. ### OpenMP on OSX On OSX one must install LLVM using homebrew (You cannot use GCC): ```bash brew install llvm ``` after which the following (or the like) must be executed in the terminal: ```bash export PATH="/usr/local/opt/llvm/bin:$PATH" ``` and ```bash export LDFLAGS="-L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib" export CPPFLAGS="-I/usr/local/opt/llvm/include" ``` Then installation with openmp can be accomplished using: ```bash CC=clang CXX=clang python setup.py install --with-openmp ``` ## Usage ### Basic usage M3 is simple to use: ```python import mthree # Specify a mitigator object targeting a given backend mit = mthree.M3Mitigation(backend) # Compute the 1Q calibration matrices for the given qubits and given number of shots # By default it is over all backend qubits at 10000 shots. mit.cals_from_system(qubits, shots) # Apply mitigation to a given dict of raw counts over the specified qubits m3_quasi = mit.apply_correction(raw_counts, qubits) ``` Note that here `qubits` is a list of which qubits are measured to yield the bits in the output. For example the list `[4,3,1,2,0]` indicates that a measurement on physical qubit 4 was written to classical bit zero in the output bit-strings, physical qubit 3 maps to classical bit 1, etc. The fact that the zeroth bit is right-most in the bitstring is handled internally. ### Error bounds It is possible to compute error bounds in a similarly efficient manner. This is not done by default, but rather turned on using: ```python m3_quasi = mit.apply_correction(raw_counts, qubits, return_mitigation_overhead=True) ``` Then the distribution itself can be called to return things like the expectation value and the standard deviation: ```python expval, stddev = quasi.expval_and_stddev() ``` ### Closest probability distribution The results of M3 mitigation are quasi-probabilities that nominally contain small negative values. This is suitable for use in computing corrected expectation values or sampling problems where one is interested in the highest probability bit-string. However, if one needs a true probability distribution then it is possible to convert from quasi-probabilites to the closest true probability distribution in L2-norm using: ```python closest_probs = m3_quasi.nearest_probability_distribution() ``` ## License [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) %package -n python3-mthree Summary: M3: Matrix-free measurement mitigation Provides: python-mthree BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip BuildRequires: python3-cffi BuildRequires: gcc BuildRequires: gdb %description -n python3-mthree # mthree [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) [![PyPI version](https://badge.fury.io/py/mthree.svg)](https://badge.fury.io/py/mthree) [![pypi](https://img.shields.io/pypi/dm/mthree.svg)](https://pypi.org/project/mthree/) ![workflow](https://github.com/Qiskit-Partners/mthree/actions/workflows/python-package-conda.yml/badge.svg) Matrix-free Measurement Mitigation (M3). M3 is a measurement mitigation technique that solves for corrected measurement probabilities using a dimensionality reduction step followed by either direct LU factorization or a preconditioned iterative method that nominally converges in O(1) steps, and can be computed in parallel. For example, M3 can compute corrections on 42 qubit GHZ problems in under two seconds on a quad-core machine (depending on the number of unique bitstrings in the output). ## Documentation [Online Documentation @ Qiskit.org](https://qiskit.org/ecosystem/mthree/) ## Installation You can `pip` install M3 in serial mode using PyPi via: ```bash pip install mthree ``` Alternatively, one can install from source: ```bash python setup.py install ``` To enable openmp one must have an openmp 3.0+ enabled compiler and install with: ```bash python setup.py install --with-openmp ``` Optionally one can also set `-march=native` using: ```bash python setup.py install --with-native ``` The `openmp` and `native` flags can be used simultaneously using a comma. ### OpenMP on OSX On OSX one must install LLVM using homebrew (You cannot use GCC): ```bash brew install llvm ``` after which the following (or the like) must be executed in the terminal: ```bash export PATH="/usr/local/opt/llvm/bin:$PATH" ``` and ```bash export LDFLAGS="-L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib" export CPPFLAGS="-I/usr/local/opt/llvm/include" ``` Then installation with openmp can be accomplished using: ```bash CC=clang CXX=clang python setup.py install --with-openmp ``` ## Usage ### Basic usage M3 is simple to use: ```python import mthree # Specify a mitigator object targeting a given backend mit = mthree.M3Mitigation(backend) # Compute the 1Q calibration matrices for the given qubits and given number of shots # By default it is over all backend qubits at 10000 shots. mit.cals_from_system(qubits, shots) # Apply mitigation to a given dict of raw counts over the specified qubits m3_quasi = mit.apply_correction(raw_counts, qubits) ``` Note that here `qubits` is a list of which qubits are measured to yield the bits in the output. For example the list `[4,3,1,2,0]` indicates that a measurement on physical qubit 4 was written to classical bit zero in the output bit-strings, physical qubit 3 maps to classical bit 1, etc. The fact that the zeroth bit is right-most in the bitstring is handled internally. ### Error bounds It is possible to compute error bounds in a similarly efficient manner. This is not done by default, but rather turned on using: ```python m3_quasi = mit.apply_correction(raw_counts, qubits, return_mitigation_overhead=True) ``` Then the distribution itself can be called to return things like the expectation value and the standard deviation: ```python expval, stddev = quasi.expval_and_stddev() ``` ### Closest probability distribution The results of M3 mitigation are quasi-probabilities that nominally contain small negative values. This is suitable for use in computing corrected expectation values or sampling problems where one is interested in the highest probability bit-string. However, if one needs a true probability distribution then it is possible to convert from quasi-probabilites to the closest true probability distribution in L2-norm using: ```python closest_probs = m3_quasi.nearest_probability_distribution() ``` ## License [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) %package help Summary: Development documents and examples for mthree Provides: python3-mthree-doc %description help # mthree [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) [![PyPI version](https://badge.fury.io/py/mthree.svg)](https://badge.fury.io/py/mthree) [![pypi](https://img.shields.io/pypi/dm/mthree.svg)](https://pypi.org/project/mthree/) ![workflow](https://github.com/Qiskit-Partners/mthree/actions/workflows/python-package-conda.yml/badge.svg) Matrix-free Measurement Mitigation (M3). M3 is a measurement mitigation technique that solves for corrected measurement probabilities using a dimensionality reduction step followed by either direct LU factorization or a preconditioned iterative method that nominally converges in O(1) steps, and can be computed in parallel. For example, M3 can compute corrections on 42 qubit GHZ problems in under two seconds on a quad-core machine (depending on the number of unique bitstrings in the output). ## Documentation [Online Documentation @ Qiskit.org](https://qiskit.org/ecosystem/mthree/) ## Installation You can `pip` install M3 in serial mode using PyPi via: ```bash pip install mthree ``` Alternatively, one can install from source: ```bash python setup.py install ``` To enable openmp one must have an openmp 3.0+ enabled compiler and install with: ```bash python setup.py install --with-openmp ``` Optionally one can also set `-march=native` using: ```bash python setup.py install --with-native ``` The `openmp` and `native` flags can be used simultaneously using a comma. ### OpenMP on OSX On OSX one must install LLVM using homebrew (You cannot use GCC): ```bash brew install llvm ``` after which the following (or the like) must be executed in the terminal: ```bash export PATH="/usr/local/opt/llvm/bin:$PATH" ``` and ```bash export LDFLAGS="-L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib" export CPPFLAGS="-I/usr/local/opt/llvm/include" ``` Then installation with openmp can be accomplished using: ```bash CC=clang CXX=clang python setup.py install --with-openmp ``` ## Usage ### Basic usage M3 is simple to use: ```python import mthree # Specify a mitigator object targeting a given backend mit = mthree.M3Mitigation(backend) # Compute the 1Q calibration matrices for the given qubits and given number of shots # By default it is over all backend qubits at 10000 shots. mit.cals_from_system(qubits, shots) # Apply mitigation to a given dict of raw counts over the specified qubits m3_quasi = mit.apply_correction(raw_counts, qubits) ``` Note that here `qubits` is a list of which qubits are measured to yield the bits in the output. For example the list `[4,3,1,2,0]` indicates that a measurement on physical qubit 4 was written to classical bit zero in the output bit-strings, physical qubit 3 maps to classical bit 1, etc. The fact that the zeroth bit is right-most in the bitstring is handled internally. ### Error bounds It is possible to compute error bounds in a similarly efficient manner. This is not done by default, but rather turned on using: ```python m3_quasi = mit.apply_correction(raw_counts, qubits, return_mitigation_overhead=True) ``` Then the distribution itself can be called to return things like the expectation value and the standard deviation: ```python expval, stddev = quasi.expval_and_stddev() ``` ### Closest probability distribution The results of M3 mitigation are quasi-probabilities that nominally contain small negative values. This is suitable for use in computing corrected expectation values or sampling problems where one is interested in the highest probability bit-string. However, if one needs a true probability distribution then it is possible to convert from quasi-probabilites to the closest true probability distribution in L2-norm using: ```python closest_probs = m3_quasi.nearest_probability_distribution() ``` ## License [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) %prep %autosetup -n mthree-2.5.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-mthree -f filelist.lst %dir %{python3_sitearch}/* %files help -f doclist.lst %{_docdir}/* %changelog * Fri May 05 2023 Python_Bot - 2.5.1-1 - Package Spec generated