Merge pull request #747 from unitaryfund/patch-release-0.9.1

Patch release 0.9.1

CHANGELOG.md

@@ -8,6 +8,18 @@
 % # " - [Bug Fix]"
 % # " - Fix the bug."
 
+## Version 0.9.1  (June 23rd, 2021)
+
+This is a patch release to fix two bugs (gh-736, gh-737) related to the integration with optional packages.
+It also fixes other minor problems (see the list of changes below).
+
+### All Changes
+
+- Patch 0.9.0 (@rmlarose, gh-739).
+- Make readthedocs succeed in building the pdf with pdflatex (@andreamari, gh-743).
+- Update energy landscape example in docs (@andreamari, gh-742).
+- Remove old deprecation warnings (@rmlarose, gh-744).
+
 ## Version 0.9.0 (June 17th, 2021)
 
 ### Summary

VERSION.txt

@@ -1 +1 @@
-0.9.0
+0.9.1

docs/source/examples/simple_landscape.myst

@@ -18,19 +18,19 @@ kernelspec:
 This tutorial shows an example in which the energy landscape for a two-qubit variational 
 circuit is explored with and without error mitigation.
 
-
 ```{code-cell} ipython3
 import matplotlib.pyplot as plt
 import numpy as np
-from cirq import Circuit, H, rx, CNOT, DensityMatrixSimulator, LineQubit, depolarize
-import mitiq
+from cirq import Circuit, rx, CNOT, DensityMatrixSimulator, LineQubit, depolarize
+
 from mitiq.zne import mitigate_executor
+from mitiq.zne.inference import RichardsonFactory
 
 SIMULATOR = DensityMatrixSimulator()
 ```
 
 ## Defining the ideal variational circuit
-We define a function which returns a two-qubit circuit at a specified variational angle $\gamma$.
+We define a function which returns a simple two-qubit variational circuit depending on a single parameter  $\gamma$.
 
 ```{code-cell} ipython3
 def variational_circuit(gamma: float) -> Circuit:
@@ -45,7 +45,7 @@ def variational_circuit(gamma: float) -> Circuit:
 
     q0, q1 = LineQubit.range(2)
 
-    return Circuit([CNOT(q0, q1), rx(gamma)(q1), CNOT(q0, q1)])
+    return Circuit([rx(gamma)(q0), CNOT(q0, q1), rx(gamma)(q1), CNOT(q0, q1), rx(gamma)(q0)])
 
 ```
 
@@ -66,7 +66,7 @@ z = np.diag([1, -1])
 hamiltonian = np.kron(z, z)
 
 # Strength of noise channel
-p = 0.1
+p = 0.04
 
 def executor(circ: Circuit) -> float:
     """Simulates the execution of a circuit with depolarizing noise.
@@ -99,7 +99,7 @@ We now compute the unmitigated energy landscape $\langle H \rangle(\gamma) =\lan
 in the following code block.
 
 ```{code-cell} ipython3
-gammas = np.linspace(-2 * np.pi, 2 * np.pi, 50)
+gammas = np.linspace(0, 2 * np.pi, 50)
 expectations = [executor(variational_circuit(g)) for g in gammas]
 ```
 
@@ -118,10 +118,11 @@ plt.show()
 
 ## Computing the mitigated landscape
 We now repeat the same task but use Mitiq to mitigate errors.
-We do so by first getting a mitigated executor as follows.
+We initialize a RichardsonFactory with scale factors `[1, 3, 5]` and we get a mitigated executor as follows.
 
 ```{code-cell} ipython3
-mitigated_executor = mitigate_executor(executor)
+fac = RichardsonFactory(scale_factors=[1, 3, 5])
+mitigated_executor = mitigate_executor(executor, factory=fac)
 ```
 
 We then run the same code above to compute the energy landscape, but this time use the ``mitigated_executor`` instead of just the executor.
@@ -151,6 +152,8 @@ which is required in most variational algorithms such as VQE or QAOA.
 We also observe that the minimum of mitigated energy approximates well the theoretical ground state which is equal to $-1$. Indeed:
 
 ```{code-cell} ipython3
+print(f"Minimum of the noisy landscape: {round(min(expectations), 3)}")
+print(f"Minimum of the mitigated landscape: {round(min(mitigated_expectations), 3)}")
 print(f"Theoretical groud state energy: {min(np.linalg.eigvals(hamiltonian))}")
 ```
 

mitiq/__init__.py

@@ -17,8 +17,3 @@
 from mitiq._typing import QPROGRAM
 from mitiq._version import __version__
 from mitiq.collector import generate_collected_executor
-from mitiq._deprecations import (
-    execute_with_zne,
-    mitigate_executor,
-    zne_decorator,
-)

mitiq/_about.py

@@ -44,13 +44,12 @@ def about() -> None:
         from qiskit import __qiskit_version__  # pragma: no cover
 
         qiskit_version = __qiskit_version__["qiskit"]  # pragma: no cover
-        terra_version = __qiskit_version__["qiskit-terra"]  # pragma: no cover
-        aer_version = __qiskit_version__["qiskit-aer"]  # pragma: no cover
-        ibmq_provider_version = __qiskit_version__[
-            "qiskit-ibmq-provider"
-        ]  # pragma: no cover
     except ImportError:
         qiskit_version = "Not installed"
+    try:
+        from braket._sdk import __version__ as braket_version
+    except ImportError:
+        braket_version = "Not installed"
 
     about_str = f"""
 Mitiq: A Python toolkit for implementing error mitigation on quantum computers
@@ -68,11 +67,8 @@ def about() -> None:
 Optional Dependencies
 ---------------------
 PyQuil Version:\t{pyquil_version}
-Qiskit Version: {qiskit_version}
-    Qiskit Elements:
-        Terra : {terra_version}
-        Aer : {aer_version}
-        IBMQ-Provider : {ibmq_provider_version}
+Qiskit Version:\t{qiskit_version}
+Braket Version:\t{braket_version}
 
 Python Version:\t{PYTHON_VERSION[0]}.{PYTHON_VERSION[1]}.{PYTHON_VERSION[2]}
 Platform Info:\t{platform.system()} ({platform.machine()})"""

mitiq/_typing.py

@@ -41,8 +41,8 @@
     _QuantumCircuit = _Circuit
 
 try:
-    from braket import Circuit as _BKCircuit
-except ImportError:
+    from braket.circuits import Circuit as _BKCircuit
+except ImportError:  # pragma: no cover
     _BKCircuit = _Circuit
 
 QPROGRAM = Union[_Circuit, _Program, _QuantumCircuit, _BKCircuit]

mitiq/interface/__init__.py

@@ -13,12 +13,6 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-from mitiq.interface import (
-    mitiq_braket,
-    mitiq_cirq,
-    mitiq_pyquil,
-    mitiq_qiskit,
-)
 from mitiq.interface.conversions import (
     accept_any_qprogram_as_input,
     atomic_converter,

mitiq/pec/representations/optimal.py

@@ -40,6 +40,8 @@ def minimize_one_norm(
     the following representation of the input ``ideal_matrix`` holds:
 
     .. math::
+        :nowrap:
+
         \text{ideal_matrix} = x_0 A_0 + x_1 A_1 + ...,
 
     where :math:`\{A_j\}` are the basis matrices, i.e., the elements of