From d8e192a5c3a99bbe1c55ca3f72ddabb03b292e59 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Wed, 23 Aug 2023 13:52:52 +0200 Subject: [PATCH 01/12] Add tutorial `13_trotterQRTE.ipynb` --- docs/tutorials/13_trotterQRTE.ipynb | 983 ++++++++++++++++++++++++++++ 1 file changed, 983 insertions(+) create mode 100644 docs/tutorials/13_trotterQRTE.ipynb diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb new file mode 100644 index 00000000..4701af47 --- /dev/null +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -0,0 +1,983 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c8bf3f5f-1218-4890-8885-255d36cfdb0a", + "metadata": {}, + "source": [ + "# Quantum Real Time Evolution using Trotterization" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f52a038f-f875-48f2-8345-039933a1fa69", + "metadata": {}, + "source": [ + "As a real time evolution technique, the Trotterization or Trotterized Real Time Evolution (RTE) consists in the successive application of a quantum gate, assumed to approximate the time evolution of a system for a time slice [1]. Following from the Schrödinger equation, the time evolution of a system initially in the state $\\vert\\psi(0)\\rangle$ takes the form:\n", + "\n", + "$$\n", + "\\vert \\psi(t) \\rangle = e^{-i H t} \\vert \\psi(0) \\rangle \\text{,}\n", + "$$\n", + "\n", + "where $H$ is the time-independent Hamiltonian under which the system is submitted. We consider a Hamiltonian that can be written as a weighted sum of Pauli terms $H=\\sum_j a_j H_j$, with $h_j$ representing a tensor product of Pauli terms acting on $n$ qubits. Thus, the sequence of gates that approximate a single evolution step is found under the assumption that the product of matrix exponentials is a good approximation for the sum of matrix exponentials:\n", + "\n", + "$$\n", + "\\vert \\psi(t) \\rangle \\approx \\left(\\prod_j e^{-i a_j H_j t/r} \\right)^r \\vert\\psi(0) \\rangle \\text{,}\n", + "$$\n", + "\n", + "where $t/r$ is the time slice (evolution step) that we are choosing. As a result, a gate to be applied $r$ times is created. A smaller timestep leads to a more accurate approximation. However, this also leads to deeper circuits which, in practice, leads to more error accumulation, becoming a critical aspect especially on NISQ devices. For the purposes of this tutorial, all simulations are Statevector simulator, which doesn't include any shot or hardware noise.\n", + "\n", + "In this tutorial, we will implement real time evolutions using the Qiskit `TrotterQRTE` class. To illustrate this, we will study the time evolution of the [Ising model](https://en.wikipedia.org/wiki/Ising_model) on linear lattices of $L=2$ and $L=6$ sites. These lattices consist of an array of spins $\\sigma_i$ that interact only with their nearest neighbors. These spins can have two orientations: $\\uparrow$ and $\\downarrow$, which correspond to a magnetization of $+1$ and $-1$ respectively.\n", + "\n", + "$$\n", + "H = - J \\sum_{i=0}^{L-2} \\sigma_i \\sigma_{i+1} - h \\sum_{i=0}^{L-1} \\sigma_i \\text{,}\n", + "$$\n", + "\n", + "where $J$ describes the interaction energy, and $h$ the magnitude of an external field. Let us write this expression using Pauli matrices, and considering that the external field has an angle $\\alpha$ with respect to the transversal direction,\n", + "\n", + "$$\n", + "H = -J \\sum_{i=0}^{L-2} Z_i Z_{i+1} -h \\sum_{i=0}^{L-1} (\\sin\\alpha Z_i + \\cos\\alpha X_i) \\text{.}\n", + "$$\n", + "\n", + "In the computational basis, the system will be encoded as follows:\n", + "\n", + "| Quantum state | Spin representation |\n", + "|:------------------------:|:------------------------------------------:|\n", + "| $\\lvert 0 0 0 0 \\rangle$ | $\\uparrow\\uparrow\\uparrow\\uparrow$ |\n", + "| $\\lvert 1 0 0 0 \\rangle$ | $\\downarrow\\uparrow\\uparrow\\uparrow$ |\n", + "| $\\ldots$ | $\\ldots$ |\n", + "| $\\lvert 1 1 1 1 \\rangle$ | $\\downarrow\\downarrow\\downarrow\\downarrow$ |\n", + "\n", + "First, we will create a function that takes in the system parameters $L$, $J$, $h$ and $\\alpha$, and returns our Hamiltonian as a `SparsePauliOp`. A [`SparsePauliOp`](https://qiskit.org/documentation/stubs/qiskit.quantum_info.SparsePauliOp.html) is a sparse representation of an operator in terms of weighted [`Pauli`](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Pauli.html) terms." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f8978fad-2734-4d62-8de3-8acfdf6549cc", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.quantum_info import SparsePauliOp\n", + "from math import sin, cos\n", + "\n", + "def get_hamiltonian(L, J, h, alpha=0):\n", + " \n", + " # List of Hamiltonian terms as 3-tuples containing\n", + " # (1) the Pauli string,\n", + " # (2) the qubit indices corresponding to the Pauli string,\n", + " # (3) the coefficient.\n", + " ZZ_tuples = [('ZZ', [i, i + 1], -J) for i in range(0, L-1)]\n", + " Z_tuples = [('Z', [i], -h * sin(alpha)) for i in range(0, L)]\n", + " X_tuples = [('X', [i], -h * cos(alpha)) for i in range(0, L)]\n", + "\n", + " # We create the Hamiltonian as a SparsePauliOp, via the method\n", + " # `from_sparse_list`, and multiply by the interaction term.\n", + " hamiltonian = SparsePauliOp.from_sparse_list([*ZZ_tuples, *Z_tuples, *X_tuples], num_qubits=L)\n", + " return hamiltonian.simplify()" + ] + }, + { + "cell_type": "markdown", + "id": "c2cc25ca-a774-4b83-b1ad-28265caa06c8", + "metadata": {}, + "source": [ + "Let us get started, and create a Hamiltonian as an operator for $L=2$, and a choice of $J=0.2$, $h=1$ and $\\alpha=\\pi/8$:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8c8377c1-85e7-43da-ba29-4291ff58b66a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SparsePauliOp(['ZZ', 'IZ', 'ZI', 'IX', 'XI'],\n", + " coeffs=[-0.2 +0.j, -0.38268343+0.j, -0.38268343+0.j, -0.92387953+0.j,\n", + " -0.92387953+0.j])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from math import pi\n", + "\n", + "H = get_hamiltonian(L=2, J=.2, h=1., alpha=pi/8)\n", + "H" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "4fa41ff7", + "metadata": {}, + "source": [ + "Let us create an instance of `TimeEvolutionProblem`. Conceptually, it contains all the information relevant on the physical problem. In our case, we will pass it the our Hamiltonian, an initial state, a final time. As initial state, we will take a spin up and a spin down." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e9730206", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.quantum_info import Statevector\n", + "from qiskit_algorithms.time_evolvers.time_evolution_problem import TimeEvolutionProblem\n", + "\n", + "final_time = 1.6\n", + "\n", + "# First spin up, second spin down\n", + "# (remember that the labels are interpreted from right to left)\n", + "initial_state = Statevector.from_label('10')\n", + "\n", + "problem = TimeEvolutionProblem(H, initial_state=initial_state, time=final_time)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b1127eec", + "metadata": {}, + "source": [ + "We can now create an instance of `TrotterQRTE`. Conceptually, it contains the information relevant to solve a physical problem, which does by means of the method `evolve`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "46a9da20-f067-4cc0-9ddf-15a9652e9224", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_algorithms.time_evolvers.trotterization.trotter_qrte import TrotterQRTE\n", + "\n", + "trotter = TrotterQRTE()\n", + "result = trotter.evolve(problem)" + ] + }, + { + "cell_type": "markdown", + "id": "b55c625e-3144-40f2-9eea-2b8cfad51381", + "metadata": {}, + "source": [ + "Our evolved state is in the result's attribute `evolved_state`, which is a `QuantumCircuit`," + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4759ec1b-2444-4cf7-8eef-e2e1f8bb332f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.evolved_state" + ] + }, + { + "cell_type": "markdown", + "id": "a628e73b-b96e-44e1-8a25-4f43bf2ccb27", + "metadata": {}, + "source": [ + "The evolved state, like all `QuantumCircuit`s, can be turned into a `Statevector`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e338fd96-ff0d-4473-8ac1-3e8edb472f61", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statevector([ 0.02895926+0.08738739j, -0.9411211 +0.31187756j,\n", + " 0.00811432-0.002689j , 0.02895926+0.08738739j],\n", + " dims=(2, 2))\n" + ] + } + ], + "source": [ + "statevector = Statevector(result.evolved_state)\n", + "print(statevector)" + ] + }, + { + "cell_type": "markdown", + "id": "392f6fa4-64a6-4d9a-b845-7e902521b988", + "metadata": {}, + "source": [ + "Let us find out the effect of the field direction after a certain a certain time $t=1.6$. Note that the units of time are the inverse of the units of the Hamiltonian. For the purposes of this tutorial we leave all units dimensionless." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9adc5a51-e976-4b9b-9d19-8b3002cef4e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "bar_width = .1\n", + "# We prepare an initial state ↑↓ (01).\n", + "# Note that Statevector and SparsePauliOp interpret the qubits from right to left\n", + "initial_state = Statevector.from_label(\"10\")\n", + "trotter = TrotterQRTE()\n", + "final_time = 1.6\n", + "eps = 1e-5\n", + "\n", + "# We create the list of angles in radians, with a small epsilon\n", + "# the exactly longitudinal field, which would present no dynamics at all\n", + "alphas = np.linspace(-np.pi/2 + eps, np.pi/2 - eps, 5)\n", + "\n", + "for i, alpha in enumerate(alphas):\n", + " H_alpha = get_hamiltonian(L=2, J=.2, h=1., alpha=alpha)\n", + " problem = TimeEvolutionProblem(H_alpha, initial_state=initial_state, time=1.6)\n", + " result = trotter.evolve(problem)\n", + " evolved_state = Statevector(result.evolved_state)\n", + " # Dictionary of probabilities\n", + " amplitudes_dict = evolved_state.probabilities_dict()\n", + " labels = list(amplitudes_dict.keys())\n", + " values = list(amplitudes_dict.values())\n", + " # Convert angle to degrees\n", + " alpha_str = f\"$\\\\alpha={int(np.round(alpha * 180 / pi))}^\\\\circ$\"\n", + " plt.bar(np.arange(4) + i * bar_width, values, bar_width, label=alpha_str, alpha=.7)\n", + "\n", + "plt.xticks(np.arange(4) + 2 * bar_width, labels)\n", + "plt.xlabel(\"Measurement\")\n", + "plt.ylabel(\"Probability\")\n", + "plt.suptitle(\n", + " f\"Measurement probabilities at $t={final_time}$, for various field angles $\\\\alpha$\\n\"\n", + " f\"Initial state: 10, Linear lattice of size $L=2$\"\n", + ")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "7495e1d1-b5d5-402f-9854-10ea06a20eb3", + "metadata": {}, + "source": [ + "We have prepared a system initially with a sequence of spins $\\uparrow\\downarrow$, which corresponds to $\\vert\\psi(0)\\rangle = \\vert01\\rangle$. After letting it evolve for $t=1.6$ under a transversal field ($\\alpha=0^\\circ$), we are almost guaranteed to measure $\\downarrow\\uparrow$, i.e. have a spin swap. (Note that the labels are interpreted from right to left). If the field is longitudinal ($\\alpha=\\pm90^\\circ$), we will have no evolution, therefore we will measure the system as it was initially prepared, $\\uparrow\\downarrow$. With intermediate angles, at $\\alpha=\\pm45^\\circ$, we will be able to measure all combinations will different probabilities, being a spin swap the most likely with a probability of 67%." + ] + }, + { + "cell_type": "markdown", + "id": "916b2d7d-508a-4943-9a0d-7c56a3a1e32b", + "metadata": {}, + "source": [ + "### Auxiliary operators" + ] + }, + { + "cell_type": "markdown", + "id": "35842d79-e23b-4a09-bfce-7e01984ec8f6", + "metadata": {}, + "source": [ + "Let us look into another feature of `TrotterQRTE`. We will now explore its ability to perform time evolutions of a system, while keeping track of some observables. The system that we now consider has a size of $L=6$." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f771ffe3-66a6-425e-ad61-1a483888c67a", + "metadata": {}, + "outputs": [], + "source": [ + "from math import pi\n", + "\n", + "L = 6\n", + "H = get_hamiltonian(L=L, J=.2, h=1.2, alpha=pi/8)" + ] + }, + { + "cell_type": "markdown", + "id": "e22d0f96-cb0b-479f-b2ff-2b988d0bcf48", + "metadata": {}, + "source": [ + "The `TrotterQRTE` instance now will be created with a `num_timesteps` argument, and an `Estimator` primitive. The Qiskit's `Estimator` primitive estimates expectation values of observables, $\\langle\\psi\\vert\\hat{O}\\vert\\psi\\rangle$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5fa5bbd8-21a7-41ba-b79b-9b63717dc15d", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_algorithms.time_evolvers.trotterization.trotter_qrte import TrotterQRTE\n", + "from qiskit.primitives import Estimator\n", + "\n", + "num_timesteps = 60\n", + "trotter = TrotterQRTE(num_timesteps=num_timesteps, estimator=Estimator())" + ] + }, + { + "cell_type": "markdown", + "id": "8cc5320f-1ce0-4321-8cf7-4b3131b038de", + "metadata": {}, + "source": [ + "Let us define a *magnetization operator* $\\sum_i Z_i$, and a *mean spin correlation operator* $\\sum_i Z_i Z_{i+1} / (L - 1)$." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "196364a5-3bca-454d-ab50-38f74d3a305d", + "metadata": {}, + "outputs": [], + "source": [ + "magnetization_op = SparsePauliOp.from_sparse_list([('Z', [i], 1.) for i in range(0, L)], num_qubits=L)\n", + "correlation_op = SparsePauliOp.from_sparse_list([('ZZ', [i, i+1], 1.) for i in range(0, L-1)], num_qubits=L) / (L - 1)" + ] + }, + { + "cell_type": "markdown", + "id": "129f289e-c694-4eb1-8842-1248578a731f", + "metadata": {}, + "source": [ + "Our new initial state will have the two middle spins facing down, and the `TimeEvolutionProblem` will incorporate some observables that will be kept track of:\n", + "1. the energy, i.e. the expectation value of the Hamiltonian, $\\langle H\\rangle$\n", + "2. the magnetization, $\\langle \\sum_i Z_i \\rangle$\n", + "3. the mean spin correlation, $\\langle\\sum_i Z_i Z_{i+1}\\rangle/(L-1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "147f30af-ebd3-41ef-88fc-256d01e1ff3d", + "metadata": {}, + "outputs": [], + "source": [ + "final_time = 30.\n", + "initial_state = Statevector.from_label('001100')\n", + "problem = TimeEvolutionProblem(H, initial_state=initial_state, time=final_time, aux_operators=[H, magnetization_op, correlation_op])" + ] + }, + { + "cell_type": "markdown", + "id": "70a62b59-658b-4964-93e5-eaea21d6958e", + "metadata": {}, + "source": [ + "Again, we let our `TrotterQRTE` evolve our newly created problem instance." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "43e41a25-881b-4765-b933-0de40e57e139", + "metadata": {}, + "outputs": [], + "source": [ + "result = trotter.evolve(problem)" + ] + }, + { + "cell_type": "markdown", + "id": "b1dfabb2-76a7-4b12-b125-018af2655e96", + "metadata": {}, + "source": [ + "The new result also features an `observables` attribute. Let's extract the observables stored in it." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "25d7df68-89a1-4d63-92ad-e80def7b5330", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(61, 3)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "observables = np.array(np.array(result.observables)[:, :, 0])\n", + "observables.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b23392e1-6c14-4179-aeb6-392c829f5282", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Observable evolution')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axes = plt.subplots(3, sharex=True)\n", + "times = np.linspace(0, final_time, num_timesteps + 1) # includes initial state\n", + "axes[0].plot(times, observables[:, 0], label='First order', marker='x', c='darkmagenta', ls='-', lw=.8)\n", + "axes[1].plot(times, observables[:, 1], label='First order', marker='x', c='darkmagenta', ls='-', lw=.8)\n", + "axes[2].plot(times, observables[:, 2], label='First order', marker='x', c='darkmagenta', ls='-', lw=.8)\n", + "axes[0].set_ylabel(\"Energy\")\n", + "axes[1].set_ylabel(\"Magnetization\")\n", + "axes[2].set_ylabel(\"Mean spin correlation\")\n", + "axes[2].set_xlabel(\"Time\")\n", + "fig.suptitle(\"Observable evolution\")" + ] + }, + { + "cell_type": "markdown", + "id": "063a380f-be6e-4664-849b-55dff23153b6", + "metadata": {}, + "source": [ + "Let us verify these results by comparing these expected values using Trotter evolution with the exact ones. To that end, we evaluate directly the expression discussed in the introduction,\n", + "\n", + "$$\n", + "\\vert \\psi(t) \\rangle = e^{-i H t} \\vert \\psi(0) \\rangle \\text{,}\n", + "$$\n", + "\n", + "on each one of the timesteps used by Trotter. We compute this exponential using scipy's [`linalg.expm`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html) function, and then we let the initial system evolve using the `Statevector`'s [`evolve` method](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.evolve.html). This becomes too costly to be performed on larger systems very quickly." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3ccb7f8b-fe5f-4405-abd4-8cb0cd919916", + "metadata": {}, + "outputs": [], + "source": [ + "import scipy as sc\n", + "\n", + "H_array = H.to_matrix()\n", + "\n", + "# We define a slightly denser time mesh\n", + "exact_times = np.linspace(0, final_time, 101)\n", + "\n", + "# We compute the exact evolution using the exp\n", + "exact_evolution = [initial_state.evolve(sc.linalg.expm(-1j * time * H_array)) for time in exact_times]" + ] + }, + { + "cell_type": "markdown", + "id": "20da64a4-9211-44a9-9d1e-6b42ca87692c", + "metadata": {}, + "source": [ + "Having the exact state vectors, we compute the exact evolution of our operators' expectation values." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f3d29f74-55ea-4261-802a-a8346cbc231d", + "metadata": {}, + "outputs": [], + "source": [ + "exact_energy = np.real([sv.expectation_value(H) for sv in exact_evolution])\n", + "exact_magnetization = np.real([sv.expectation_value(magnetization_op) for sv in exact_evolution])\n", + "exact_correlation = np.real([sv.expectation_value(correlation_op) for sv in exact_evolution])" + ] + }, + { + "cell_type": "markdown", + "id": "6e3eea26-539e-4749-8dec-e8e3cc378830", + "metadata": {}, + "source": [ + "We incorporate the exact evolution of the operators alongside the expected values resulting from the Trotterization." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "386e3a68-ea28-499a-a5f9-797896ba3a9f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "axes[0].plot(exact_times, exact_energy, c='k', ls=':', label='Exact')\n", + "axes[1].plot(exact_times, exact_magnetization, c='k', ls=':', label='Exact')\n", + "axes[2].plot(exact_times, exact_correlation, c='k', ls=':', label='Exact')\n", + "# Select the labels of only the first axis\n", + "legend = fig.legend(*axes[0].get_legend_handles_labels(), bbox_to_anchor=(1., .5), loc='center left', framealpha=.5)\n", + "fig.tight_layout()\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "id": "0550c4c6-9744-4ab3-a2f4-dda166c29855", + "metadata": {}, + "source": [ + "We see that, as an approximation, a Pauli-Trotter evolution isn't too far from the exact solution, but the accuracy is limited. Let's see how to find higher order formulas to address this." + ] + }, + { + "cell_type": "markdown", + "id": "cf51369f-409e-4108-945e-cc985ec46974", + "metadata": {}, + "source": [ + "### Product formula overview\n", + "\n", + "If it isn't specified, the default product formula that `TrotterQRTE` uses is the Lie product formula [2], which is at first order. In Qiskit this is implemented in the [`LieTrotter` class](https://qiskit.org/documentation/stubs/qiskit.synthesis.LieTrotter.html). A first order formula consists of the approximation stated in the introduction, where the matrix exponential of a sum is approximated by a product of matrix exponentials:\n", + "\n", + "$$\n", + "e^{A+B} \\approx e^A e^B\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "40d87353-3e42-48cc-a193-0b4d8f1421c1", + "metadata": {}, + "source": [ + "Knowing this, we can have a look at the circuit that performs a single Trotter step." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ee8f1ba9-3c5d-41fe-9f93-1fe735216dd9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Trotter step with Lie-Trotter\n", + "-----------------------------\n", + "\n", + " Depth: 7\n", + " Gate count: 17\n", + " Nonlocal gate count: 5\n", + " Gate breakdown: RZ: 6, RX: 6, RZZ: 5\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit import QuantumCircuit\n", + "from qiskit.circuit.library import PauliEvolutionGate\n", + "from qiskit.synthesis import LieTrotter\n", + "\n", + "dt = final_time / num_timesteps\n", + "trotter_step_first_order = PauliEvolutionGate(H, dt, synthesis=LieTrotter())\n", + "\n", + "# We create an empty circuit\n", + "circuit = QuantumCircuit(H.num_qubits)\n", + "circuit.append(trotter_step_first_order, range(H.num_qubits))\n", + "circuit = circuit.decompose(reps=2)\n", + "\n", + "# Let us print some stats\n", + "print(f\"\"\"\n", + "Trotter step with Lie-Trotter\n", + "-----------------------------\n", + "\n", + " Depth: {circuit.depth()}\n", + " Gate count: {len(circuit)}\n", + " Nonlocal gate count: {circuit.num_nonlocal_gates()}\n", + " Gate breakdown: {\", \".join([f\"{k.upper()}: {v}\" for k, v in circuit.count_ops().items()])}\n", + "\"\"\")\n", + "\n", + "# And finally draw the circuit\n", + "circuit.draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "id": "ad8c6b98-eb15-497f-ba17-35402c0f8a22", + "metadata": {}, + "source": [ + "There exists a second-order formula, called the Suzuki-Trotter decomposition [3], and can be used in Qiskit by means of the [`SuzukiTrotter` class](https://qiskit.org/documentation/stubs/qiskit.synthesis.SuzukiTrotter.html). Using this formula, a second order decomposition is:\n", + "\n", + "$$\n", + "e^{A+B} \\approx e^{B/2}e^{A}e^{B/2}\n", + "$$\n", + "\n", + "By means of recursions, higher-order approximations can be found [1]." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9ef7b40c-cdcb-4e61-a4d9-b893af870821", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Trotter step with Suzuki Trotter (2nd order)\n", + "--------------------------------------------\n", + "\n", + " Depth: 14\n", + " Gate count: 33\n", + " Nonlocal gate count: 10\n", + " Gate breakdown: RZ: 12, RX: 11, RZZ: 10\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.synthesis import SuzukiTrotter\n", + "\n", + "second_order_formula = SuzukiTrotter() # if not passed, order defaults to 2\n", + "trotter_step_second_order = PauliEvolutionGate(H, dt, synthesis=second_order_formula)\n", + "circuit = QuantumCircuit(H.num_qubits)\n", + "circuit.append(trotter_step_second_order, range(H.num_qubits))\n", + "circuit = circuit.decompose(reps=2)\n", + "\n", + "# Let us print some stats\n", + "print(f\"\"\"\n", + "Trotter step with Suzuki Trotter (2nd order)\n", + "--------------------------------------------\n", + "\n", + " Depth: {circuit.depth()}\n", + " Gate count: {len(circuit)}\n", + " Nonlocal gate count: {circuit.num_nonlocal_gates()}\n", + " Gate breakdown: {\", \".join([f\"{k.upper()}: {v}\" for k, v in circuit.count_ops().items()])}\n", + "\n", + "\"\"\")\n", + "\n", + "# And finall\n", + "circuit.draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6c3befc4-9c10-4081-a245-d50e693dc195", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Trotter step with Suzuki Trotter (4th order)\n", + "--------------------------------------------\n", + "\n", + " Depth: 14\n", + " Gate count: 33\n", + " Nonlocal gate count: 10\n", + " Gate breakdown: RZ: 12, RX: 11, RZZ: 10\n", + "\n", + "\n" + ] + } + ], + "source": [ + "fourth_order_formula = SuzukiTrotter(order=4)\n", + "trotter_step_fourth_order = PauliEvolutionGate(H, dt, synthesis=second_order_formula)\n", + "circuit = QuantumCircuit(H.num_qubits)\n", + "circuit.append(trotter_step_fourth_order, range(H.num_qubits))\n", + "circuit = circuit.decompose(reps=2)\n", + "\n", + "# Let us print some stats\n", + "print(f\"\"\"\n", + "Trotter step with Suzuki Trotter (4th order)\n", + "--------------------------------------------\n", + "\n", + " Depth: {circuit.depth()}\n", + " Gate count: {len(circuit)}\n", + " Nonlocal gate count: {circuit.num_nonlocal_gates()}\n", + " Gate breakdown: {\", \".join([f\"{k.upper()}: {v}\" for k, v in circuit.count_ops().items()])}\n", + "\n", + "\"\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "ab5323ce-33f9-4fba-8cfd-5bdf72ecb9c2", + "metadata": {}, + "source": [ + "Finally, let us perform a simulation at fourth order." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "60beaab5-7b78-456b-8df4-097c14c7967c", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.synthesis import SuzukiTrotter\n", + "\n", + "trotter = TrotterQRTE(SuzukiTrotter(order=4), num_timesteps=num_timesteps, estimator=Estimator())\n", + "problem = TimeEvolutionProblem(H, initial_state=initial_state, time=final_time, aux_operators=[H, magnetization_op, correlation_op])\n", + "result = trotter.evolve(problem)\n", + "observables_order4 = np.array(np.array(result.observables)[:, :, 0], dtype=np.float64)" + ] + }, + { + "cell_type": "markdown", + "id": "6b1c5876-f313-4620-82dd-6ac51c1f8a76", + "metadata": {}, + "source": [ + "and plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "227b00c2-063e-4409-996e-5f8e48844ab8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "axes[0].plot(times, observables_order4[:, 0], label='Fourth Order', marker='x', c='limegreen', ls='-', lw=.8)\n", + "axes[1].plot(times, observables_order4[:, 1], label='Fourth Order', marker='x', c='limegreen', ls='-', lw=.8)\n", + "axes[2].plot(times, observables_order4[:, 2], label='Fourth Order', marker='x', c='limegreen', ls='-', lw=.8)\n", + "\n", + "# Replace the legend\n", + "legend.remove()\n", + "legend = fig.legend(*axes[0].get_legend_handles_labels(), bbox_to_anchor=(1., .5), loc='center left', framealpha=.5)\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "id": "5cd822d9-44ee-4391-8b47-ff861aa37451", + "metadata": {}, + "source": [ + "As it is to expect, we can directly see that a higher-order product formula leads to more accurate expectation values." + ] + }, + { + "cell_type": "markdown", + "id": "04063266-5c25-43b8-b2b8-62f343ddd012", + "metadata": {}, + "source": [ + "### Colorplot\n", + "\n", + "In this last step, we aim at visualizing the time evolution of each one of the sites of the lattice individually. Let us present the expected value of the magnetization of each one of the sites as a function of time in a color plot. As the initial state was $\\vert\\psi(0)\\rangle = \\vert001100\\rangle$ (spin sequence $\\uparrow\\uparrow\\downarrow\\downarrow\\uparrow\\uparrow$), at time $t=0$ we expect to see magnetization $-1$ in the two middle signs and $+1$ elsewhere. During the evolution, as the plot above suggests, we can expect to see oscillations which will eventually damp." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "cb194f62-1d36-45a4-9874-b937ffc76860", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import cm\n", + "\n", + "# An inner list comprehension loops over the terms of the SparsePauliOp magnetization_op,\n", + "# which corresponds to the magnetization of each one of the sites\n", + "magnetizations = np.real([[sv.expectation_value(term) for term in magnetization_op] for sv in exact_evolution])\n", + "# The shape of magnetizations is (101, 6), containing (t) for each site 0, 1, ..., 5\n", + "plt.figure(figsize=(14, 2))\n", + "# Create the 2-dim xx and yy arrays tiling the grid with the x and y values\n", + "xx, yy = np.meshgrid(exact_times, np.arange(L))\n", + "plt.pcolor(xx, yy, magnetizations.T, vmin=-1, vmax=+1, cmap='RdBu')\n", + "# Force the figure to have all y ticks from 0 to 5\n", + "plt.yticks(np.arange(L))\n", + "plt.ylabel('Site $i$')\n", + "plt.xlabel('Time')\n", + "plt.colorbar(label='$\\\\langle Z_i \\\\rangle$', aspect=1.8)" + ] + }, + { + "cell_type": "markdown", + "id": "f8f1d285-2f9d-404a-9fac-6b599760af7c", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "[1] Hatano, Naomichi, and Masuo Suzuki. \"Finding exponential product formulas of higher orders.\" _Quantum annealing and other optimization methods._ Berlin, Heidelberg: Springer Berlin Heidelberg, 2005. 37-68.\n", + "\n", + "[2] Varadarajan, Veeravalli S. _Lie groups, Lie algebras, and their representations._ Vol. 102. Springer Science & Business Media, 2013.\n", + "\n", + "[3] Magnus, Wilhelm. \"On the exponential solution of differential equations for a linear operator.\" _Communications on pure and applied mathematics_ 7.4 (1954): 649-673." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "61de877f-d783-48cf-bccf-deb99e2f4e4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Version Information

SoftwareVersion
qiskitNone
qiskit-terra0.25.1
qiskit_algorithms0.2.0
System information
Python version3.11.2
Python compilerGCC 8.5.0 20210514 (Red Hat 8.5.0-18)
Python buildmain, Jun 6 2023 07:39:01
OSLinux
CPUs4
Memory (Gb)15.27389907836914
Wed Aug 23 13:50:56 2023 CEST
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

This code is a part of Qiskit

© Copyright IBM 2017, 2023.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import qiskit.tools.jupyter\n", + "%qiskit_version_table\n", + "%qiskit_copyright" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From f6ed01c4b6eed193dba1118e1924b0582e51b963 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Wed, 23 Aug 2023 20:32:08 +0200 Subject: [PATCH 02/12] Apply suggestions from code review Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- docs/tutorials/13_trotterQRTE.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 4701af47..9cdfa407 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -28,7 +28,7 @@ "\n", "where $t/r$ is the time slice (evolution step) that we are choosing. As a result, a gate to be applied $r$ times is created. A smaller timestep leads to a more accurate approximation. However, this also leads to deeper circuits which, in practice, leads to more error accumulation, becoming a critical aspect especially on NISQ devices. For the purposes of this tutorial, all simulations are Statevector simulator, which doesn't include any shot or hardware noise.\n", "\n", - "In this tutorial, we will implement real time evolutions using the Qiskit `TrotterQRTE` class. To illustrate this, we will study the time evolution of the [Ising model](https://en.wikipedia.org/wiki/Ising_model) on linear lattices of $L=2$ and $L=6$ sites. These lattices consist of an array of spins $\\sigma_i$ that interact only with their nearest neighbors. These spins can have two orientations: $\\uparrow$ and $\\downarrow$, which correspond to a magnetization of $+1$ and $-1$ respectively.\n", + "In this tutorial, we will implement real time evolutions using the `TrotterQRTE` class. To illustrate this, we will study the time evolution of the [Ising model](https://en.wikipedia.org/wiki/Ising_model) on linear lattices of $L=2$ and $L=6$ sites. These lattices consist of an array of spins $\\sigma_i$ that interact only with their nearest neighbors. These spins can have two orientations: $\\uparrow$ and $\\downarrow$, which correspond to a magnetization of $+1$ and $-1$ respectively.\n", "\n", "$$\n", "H = - J \\sum_{i=0}^{L-2} \\sigma_i \\sigma_{i+1} - h \\sum_{i=0}^{L-1} \\sigma_i \\text{,}\n", @@ -129,7 +129,7 @@ "outputs": [], "source": [ "from qiskit.quantum_info import Statevector\n", - "from qiskit_algorithms.time_evolvers.time_evolution_problem import TimeEvolutionProblem\n", + "from qiskit_algorithms import TimeEvolutionProblem\n", "\n", "final_time = 1.6\n", "\n", @@ -156,7 +156,7 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit_algorithms.time_evolvers.trotterization.trotter_qrte import TrotterQRTE\n", + "from qiskit_algorithms import TrotterQRTE\n", "\n", "trotter = TrotterQRTE()\n", "result = trotter.evolve(problem)" From f0cb859370c1f04ffeda987299444c066fb0a0b1 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Wed, 23 Aug 2023 20:40:49 +0200 Subject: [PATCH 03/12] Remove backticks from link text Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- docs/tutorials/13_trotterQRTE.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 9cdfa407..9a2d5c39 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -590,7 +590,7 @@ "source": [ "### Product formula overview\n", "\n", - "If it isn't specified, the default product formula that `TrotterQRTE` uses is the Lie product formula [2], which is at first order. In Qiskit this is implemented in the [`LieTrotter` class](https://qiskit.org/documentation/stubs/qiskit.synthesis.LieTrotter.html). A first order formula consists of the approximation stated in the introduction, where the matrix exponential of a sum is approximated by a product of matrix exponentials:\n", + "If it isn't specified, the default product formula that `TrotterQRTE` uses is the Lie product formula [2], which is at first order. In Qiskit this is implemented in the [LieTrotter](https://qiskit.org/documentation/stubs/qiskit.synthesis.LieTrotter.html) class. A first order formula consists of the approximation stated in the introduction, where the matrix exponential of a sum is approximated by a product of matrix exponentials:\n", "\n", "$$\n", "e^{A+B} \\approx e^A e^B\n", From 06e198d2993623c4e6f3eca428d7bd0ec4d58e3e Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Wed, 23 Aug 2023 20:50:25 +0200 Subject: [PATCH 04/12] Change title name from "Colorplot" to "Magnetization evolution plot" --- docs/tutorials/13_trotterQRTE.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 9a2d5c39..1dcc7505 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -857,7 +857,7 @@ "id": "04063266-5c25-43b8-b2b8-62f343ddd012", "metadata": {}, "source": [ - "### Colorplot\n", + "### Magnetization evolution plot\n", "\n", "In this last step, we aim at visualizing the time evolution of each one of the sites of the lattice individually. Let us present the expected value of the magnetization of each one of the sites as a function of time in a color plot. As the initial state was $\\vert\\psi(0)\\rangle = \\vert001100\\rangle$ (spin sequence $\\uparrow\\uparrow\\downarrow\\downarrow\\uparrow\\uparrow$), at time $t=0$ we expect to see magnetization $-1$ in the two middle signs and $+1$ elsewhere. During the evolution, as the plot above suggests, we can expect to see oscillations which will eventually damp." ] From 4a085e393f7832ab2b66bca3d6708e3207f748e5 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Thu, 24 Aug 2023 00:56:07 +0200 Subject: [PATCH 05/12] Apply suggestions from code review Remove backticks from link text (2) Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- docs/tutorials/13_trotterQRTE.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 1dcc7505..d05b5c7f 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -49,7 +49,7 @@ "| $\\ldots$ | $\\ldots$ |\n", "| $\\lvert 1 1 1 1 \\rangle$ | $\\downarrow\\downarrow\\downarrow\\downarrow$ |\n", "\n", - "First, we will create a function that takes in the system parameters $L$, $J$, $h$ and $\\alpha$, and returns our Hamiltonian as a `SparsePauliOp`. A [`SparsePauliOp`](https://qiskit.org/documentation/stubs/qiskit.quantum_info.SparsePauliOp.html) is a sparse representation of an operator in terms of weighted [`Pauli`](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Pauli.html) terms." + "First, we will create a function that takes in the system parameters $L$, $J$, $h$ and $\\alpha$, and returns our Hamiltonian as a `SparsePauliOp`. A [SparsePauliOp](https://qiskit.org/documentation/stubs/qiskit.quantum_info.SparsePauliOp.html) is a sparse representation of an operator in terms of weighted [Pauli](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Pauli.html) terms." ] }, { @@ -498,7 +498,7 @@ "\\vert \\psi(t) \\rangle = e^{-i H t} \\vert \\psi(0) \\rangle \\text{,}\n", "$$\n", "\n", - "on each one of the timesteps used by Trotter. We compute this exponential using scipy's [`linalg.expm`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html) function, and then we let the initial system evolve using the `Statevector`'s [`evolve` method](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.evolve.html). This becomes too costly to be performed on larger systems very quickly." + "on each one of the timesteps used by Trotter. We compute this exponential using SciPy's [linalg.expm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.expm.html) function, and then we let the initial system evolve using the `Statevector`'s [evolve](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.evolve.html) method. This becomes too costly to be performed on larger systems very quickly." ] }, { From c75cf01bf8ad72c639cdbff012ef6376eee20384 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Thu, 24 Aug 2023 01:02:26 +0200 Subject: [PATCH 06/12] Remove backtick from link text --- docs/tutorials/13_trotterQRTE.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index d05b5c7f..4584a250 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -671,7 +671,7 @@ "id": "ad8c6b98-eb15-497f-ba17-35402c0f8a22", "metadata": {}, "source": [ - "There exists a second-order formula, called the Suzuki-Trotter decomposition [3], and can be used in Qiskit by means of the [`SuzukiTrotter` class](https://qiskit.org/documentation/stubs/qiskit.synthesis.SuzukiTrotter.html). Using this formula, a second order decomposition is:\n", + "There exists a second-order formula, called the Suzuki-Trotter decomposition [3], and can be used in Qiskit by means of the [SuzukiTrotter class](https://qiskit.org/documentation/stubs/qiskit.synthesis.SuzukiTrotter.html). Using this formula, a second order decomposition is:\n", "\n", "$$\n", "e^{A+B} \\approx e^{B/2}e^{A}e^{B/2}\n", From 9e9c27bc84c31a2039a29de99780ebb686f97cbf Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Thu, 24 Aug 2023 10:42:29 +0200 Subject: [PATCH 07/12] Update `.pylintdict` with terms from `13_trotterQRTE.ipynb` --- .pylintdict | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.pylintdict b/.pylintdict index 95fd821a..0d5af27b 100644 --- a/.pylintdict +++ b/.pylintdict @@ -88,6 +88,7 @@ evolutionsynthesis evolver evolvers excitations +exponentials exponentiated exponentiating fae @@ -132,7 +133,9 @@ hadamards hadfield hamiltonian hamiltonians +hatano havlíček +heidelberg hessians hilbert hopkins @@ -179,6 +182,7 @@ lov lr lsb lse +magnus marecek mathcal mathrm @@ -205,6 +209,7 @@ nakaji nakanishi nan nannicini +naomichi nathan nd ndarray @@ -353,7 +358,9 @@ univariate uno unscaled utils +varadarajan variational +veeravalli vec vectorized vicentini @@ -362,6 +369,7 @@ voilà vqd vqe wavefunction +wilhelm woerner wrt xatol From 0d31c9f90f9a87c4279068c60548aa6d432e9b37 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Thu, 24 Aug 2023 11:08:20 +0200 Subject: [PATCH 08/12] Replace instance name of `result.evolved_state` with circuit drawings --- docs/tutorials/13_trotterQRTE.ipynb | 95 +++++++++++++++++++---------- 1 file changed, 63 insertions(+), 32 deletions(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 4584a250..0d368a09 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -178,8 +178,9 @@ "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAACuCAYAAABdj4vWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh/ElEQVR4nO3deXxM5x4G8GeyyR5ZkI1ISBBZSFCxNmlCtaJoVWqtouVeRauJpbelvVUXob0parlVBKm1llCtXcQWEmuCWBKyDCKJyL7N/SM1NZ3JMtlmzuT5fj793Ou8Z/nleM08Oe857xFJJBIJiIiIiEiQtFRdABERERHVHsMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJGMMcERERkYAxzBEREREJmI6qC2jqJBKgvETVVVBD0dIFRCJVV/EX9jciIvX7bK4rhjkVKy8BjoepugpqKL7TAW09VVfxF/Y3IiL1+2yuKw6zEhEREQkYwxwRERGRgDHMEREREQkYwxwRERGRgDHMEREREQkYwxwRERGRgDHMEREREQkYwxwRERGRgDHMEREREQkYwxwRERGRgDHMEREREQkYwxwRERGRgDHMEREREQmYxoe5jIwMhISEoH379tDX10fr1q0xY8YM5OXlYeLEiRCJRFixYoWqyyQiIiKqFR1VF9CQLl++jEGDBkEsFsPIyAiurq5IS0tDWFgY7t69i8zMTABAly5dVFtoNcrLy/Hr6f/iwLk1EGcloblRC/TzfBfjB34NAz0jVZdHGoR9jYhIeDT2ylxGRgYCAwMhFosxa9YspKenIzY2FmKxGIsXL8aBAwcQExMDkUgEDw8PVZdbpR/3f4LV+z9Fm1aumDb0B/TzGIE9p8Pw5fpAlJeXq7o80iDsa0REwqOxV+amT5+OlJQUTJs2DaGhoTJtISEh2Lp1K65cuQJHR0eYmpqqqMrqJYlvYG/0D+jjNhzzx++SLre2cMTKvdNx4sov8Os6SoUVkqZgXyMiEiaNvDKXkJCAbdu2wcrKCosWLVK4jre3NwDA09NTZvn9+/cxZMgQmJiYwNzcHOPGjcPTp08bvObKHL8cAYlEguF9Z8osf+OVydDXNcSR2M2qKYw0DvsaEZEwaWSYi4iIQHl5OUaPHg1jY2OF6xgYGACQDXPPnz+Hr68vUlJSEBERgbVr1yIqKgqDBw9W2RDTrYcx0BJpoUObHjLL9XT14WTbBbcfxqikLtI87GtERMKkkcOsx44dAwD4+vpWuk5KSgoA2TC3du1apKam4tSpU2jTpg0AwN7eHr169cK+ffswdOjQhiu6Ek9z0mBqZAU9nWZybVZmdohPPoOS0mLo6ug1em2kWdjXiIiESSPDXHJyMgDAwcFBYXtpaSmio6MByIa5yMhI9OnTRxrkAMDHxwdOTk7Yv39/rcNct27dIBaLFbbp6Rhg7bTESrctKs6HroIv14pt9SvWKcnnF6yacnZxRnFpgarLkKqqv7GvEVFToW6fzQBgbW2Nixcv1mpbjQxzeXl5AICCAsV/Udu2bUNGRgZMTEzg6OgoXR4fH48RI0bIrd+5c2fEx8fXuh6xWIzU1FSFbfq6hlVu20zPEAW5jxW2FZcWVqxTzT5IddLT0lBYkq/qMqSq6m/sa0TUVKjbZ3NdaWSYs7a2RlZWFmJjY+Hj4yPTlp6ejuDgYACAh4cHRCKRtC0rKwvNmzeX25+FhQVu3bpVp3oqo6djUOW2lqa2ePAoHsWlRXLDXxnPUmFmZMUrJWrMxtZWrX77q6q/sa8RUVOhbp/NQNVZoToaGeb8/f2RkJCAxYsXIyAgAC4uLgCAmJgYjB07FhkZGQAab7Lgqi6blhUDx8Mq37ZD6+64dPsP3HpwAe5OfaXLi0sKcS/tMtyd+tVnqVTPEm8nQluN8k9V/Y19jYiaCnX7bK4rjXyaNSQkBJaWlnj48CE6d+4Md3d3ODs7o0ePHnBycoKfnx8A+WlJzM3NkZ2dLbe/zMxMWFhYNEbpcl71HAmRSITdUd/LLD94fh0KS/Lh13W0SuoizcO+RkQkTBp5Zc7e3h5RUVEIDg7GyZMnkZSUBFdXV6xZswaTJ09Gu3btAMiHuU6dOim8Ny4+Ph79+qnmqoSjjTuG9Pon9kavwIKNw9Gj4xt48DgBe06HwcOpPydxpXrDvkZEJEwaGeaAimAWGRkptzw3NxdJSUnQ0tKCm5ubTNvgwYMxb948pKSkwN7eHgBw/vx53L17F0uXLm2UuhWZOuR7tDJvi4Pn1+JCwgGYGllhaO+PMX7g19DS0siLq6Qi7GtERMIjkkgkElUX0ZjOnz+Pnj17okOHDrh586ZMW05ODtzd3WFlZYWvvvoKhYWFCAkJQYsWLXD27NkG+TKr7p45Ejbf6VCr+zLY34iI1O+zua6a3K/a165dAyA/xAoApqamOHbsGGxsbBAUFIRJkyahV69eiIyM5FUJIiIiUksaO8xamarCHAC0a9dO4fAsERERkTpqcpebqgtzRERERELS5K7MvXhvKxEREZEmaHJX5oiIiIg0CcMcERERkYAxzBGRxrtw8zcMnK2DB49vVr8ygDHftsWsH1+tl2MXlxRizLdtsf63z+tlf0RNwZnrezFojh5SniQq1dZUNbl75oioaSkrK8Wa/bPwWtfRaNOyY633szvqexjpN8fA7u8rtd3OU8uRW5CNEf0/ky6b9eOruHrvZLXbjg2Yj3EDFmDTHwsQfviratf3cOqPZVNPKFVffQgIFuGVTm/imw8qZgJQ53qVPfcvtrmdchH7F+Y2cHWK/f38ZuaIMWlZZzQ3aoEfP4lDM10DmfVjE49izroA+HZ5D3NHbWnUWu+Lr+Of33ujk4MPQqcch0gkkmn/7cJPWL5jEt7zm4cPBi0E8Fd/WTE9Bh1adwMA9HJ7C47W7vjfwdlYMH63zD6qamuqGOaISKOdvLoDDx4nYN7oiBpvsz7kFkSQ/RLaHVXxdgxlwlxRSQF2nFyKgd0nwMTQXLp81GufY1CPSQq3KSkrwur9n6Kg6DlcHXoBAPq4DYetZftKj7PjZCjupV+Bm2OfGtfWkNS5XmXPvTqyMLXGtKE/YNHW0fj5t88xZchyaVteYQ6Wbf8A5ibW+OfQHxq9NkdrN4wJmI+fD32OPdE/YFif6dK2R1nJWL3/Uzhau2NswPxq9zWszwws2TYeSeIbaGvducZtTRHDHBFptP1nV8HJxgPtbGs+HZGeTrN6OfaxuK3ILchGgPc4meXeLgGVbrNsxyTkF+Zg3ICv0K3DAACAk60HnGw9FK5/5NJm3Eu/Ai9nf4wbUP3VMEVeDCnX11Uyda5X2XNfH+r7/AKAX9dRiLq6C7+e/i/6uA+XBuNVe2fgcfYDfPNBJEwNLWq17yW/vI+r905g87ykWm0/0nc2ztzYg/UH56JHxzdgZ9UeEokEods/QHFJAUKCNkJXp/rXL/RxH46w3VMReW41pv0tmFbV1hTxnjkiajDFpUXYevRbTArtjDfm6mPoF83xxfpA3EmNk67zJDsFw+dbYnKoG4pKCmS2X7R1NAaEaCH29hHpsoBgEZb88j5ibx/Bxz/0xOB5hnj3K2us3DsDBUWyw2CZOWJcv38aPTq+oVTdf79nLiBYhEdZybh67yQCgkXS/8SZSVXu59SVHbAwsUZ7u641Ou7+Mz/i0IWf0NM1EGP8v6h2/Tupcfh+14doZe6Az0f/Am0t7RodR1XUuV5lz706mP72jzAxtMDS7RNQWJyPs/H78cfFDRjYfQJe6fSmyurS1tJG8MiNKJOUIXT7BJSXl2Nv9ApcvnMMo177V43/PRg0M4abY19EXd2pVFtTxDBHRA2itKwE8/73OjYf/gqdHHwwNfA7BPnOQfKjeMxc2Ru3Hl4EALRobo/P3v0ZSY9u4Me9M6XbH7qwHsfitmLkq7Ph5eIvs+87qbGYv3EoXB188OHgULg59cWe02H4csNbKC8vl6734t6oDq171OlnmR0UDjMjK7Ru2RGzg8Kl/5kZt6h0m7LyMtxIjq7xsa/fj8aqfTNg38IFc4LC5e41+rtneRlYsHEYAGDB+F9hamRZ8x9IBdS5XmXPvbowN26Jj4etQlrGHYTtnorvd36IFmb2mBr4napLg0OrTnh/4L9x/f5prNo3Az8dnANnOy+M8pun1H5cHXyQ+Vys8OGlqtqaGg6zElGD2Bu9AlfunsC3kw6he4eB0uWBvf6BycvcsDbyM+mwU6/OQzC098fYE/0DvFwC0NbaDSv3fIxObXri/YH/ltv3ffE1LBj/K3q7DQUADOn1D6zcOwN7Tofh5NXt8O0SBABIfhQPALC1bFenn8Xfeww2/P4vmBu3gr/3mBpt8zj7AQqKcmt07Ixnafh3+DvQ1WmGBeN/hZGBWZXrl5WX4Zvwd/EoKxkhQZtqfKVDVdS5XmXPvbrp7zkCUdfexeFLmwAAiyb9rjY/wzv9ZiH6+q/YG70Cutp6CA7aCG1t5WKHzZ//fpLFN+QeYKqqralhmCOiBnE0djNat+wIF3tvPMvLkGnzdg7AH5c2oqikQPok3uTBS3E96TS+2zkZVqZ20NbWxbzREQo//Fu36CANci8E+c7BntNhiL7+qzTMPct7AgAwqeW9Q3XxLLdmxy4pLcbXm95G5nMxvhy7Ew6tXKvd97rIYFy+exxDe3+MAO+xStVVUJSL4tJCmWWlZSUVNf/t70lPRx8GzYyV2r8i6lpvbc69KuutjJlRiz//1wquDj5KbVtYnI+iknyZZSVlRSiXlMvVq6Olq1RQ1NLSkvZ/W6v2aNOyk1K1AZBewc3OfaxUW1PDMEdEDeLB4wQUlRTgnQWVD0U+y8tAy+atAVQ8dDBvVAQmLeuMpEc3MHfUFlhbtFW4naIvBUtTGxgbNEf603svLa0YLpNAIrNuSWkxnudnyiwzaGZcL1+s0iP/OVQnkUiqXG/FnmlIeHAOQb5z0Nfj7Wr3eyxuK3ZFfQd3x774KHCZ0nX98Os0HL60UWHb3/+uArzHIyRog9LHeJk616vsua+Jxj6/cXeOYf/ZVWhn2wV30y5jbeRnmPnOmhpvv/3Ekkqnkfl7vcpOJXMo5mecTzggrW37iSV4z29ujbcHXvr3o2Dou6q2poZhjogahEQigaO1O6YELq90neZGsl8W5xMOoLy8DEDFzfJ+XUfVqYbmf97T9jw/UxoaASA++Qw+W+0rs+7L84rVhxdXS54XZFa6zoFza3Hw/Dp4uwzAhNcXVrvPu2lX8N2OybAys8MXY3dAR1tX6bpG+obA30t2qHhN5CwAwEeDZcOWpZmt0vt/mTrXq+y5r6nGPL/5hc8rpiExboUlHx3Fqj3TceD8WvTzGCF3n2llArzHwa2t7BQx208uxb20K5jz3maZ5cYvTa9TncfZD7F63ydoa+2GsGlnMWfdAIQf/gq9Or+l1BXQF790/f2zorq2poZhjogahJ2VM57lPUGX9n7Q0qr+WavbKZew/re58HIOgJmRFXaeWgYv5wCFU0Q8eJwgt+xpTjpyC7JhY+kkXdbW2g0AkJqRKDM1iZONJxZPPiyz/cvbKfL3eeeq06J5axjqmyI1Q/Es9fHJ57Byz8ewtnDEvNER1Z6jnPxMLNg4DGXlpfhi7E6Ym7RSqp4XHFq5yn2ZGhtUfEnXNADUhDrXq+y5V0ZjnV8AWL3/UzzKSsZX7++FqaEF/jE0DHF3jmL5zklY++k1GOqbVLsPG0snub5/JHYzUnRv1aneZdsnorA4DyEjN0JPVx+z3l2PKcs9sXTb+/jvtLM1fpI57ekdAH/9W65pW1PDp1mbsN9jNiAgWIQrd0+otI76fHUSqY8A73HIfC7GrlOKr8xlPX8k/f8FRblYuCUIxgbmmPNeOGa8vRrW5o5Y8ss4ZCm4H+bhk1uIvr5HZtm244sBAL06D5Uu83DqDwBISD4ns66JoTm8XPxl/qsuzOk3M5Ybmq2KtpY23B374uaD83JtmTlifL3pbWhpaWP+uN3VzgdWVl6GhZuDIM68j3+8FQZXh541rkMV1LleZc+9uoq5eQi/Xfgf/L3GolfnIQAAU0MLzBi+Go+ykrE28rNq9tBw9p9djdjEwwjymwtney8AgJ1Ve0wY9C1uPYzB9hNLaryvhORzMDduhdYtOyjV1tTwyhyppdq+Oini2CIkpsYiMeUSxJn30crcQeHEl8UlhTgSG45z8ZG4l34FWc8fwcLUBh3bvIIx/l/CoZX8PVkVc6YtxNFL4XiakwYrM3sM7D4BI31n12r4SNMN6zsDlxIPY+2BYMTdPYau7fxgqG+Kx9kPEJd4FHq6+gidchwA8N/dU5H+9C6+nXhIegVn3ugIfLKqD5b+Mh4LJx6UmS7C0dod/4kYgzdemQw7K2dcvnscUVd3wsOpP171HCldr7lxC3i2exUXbh7ER4Ghdfp5OrXpiUMxP2HDoS/QplUniERa6OkaCAM9o0q36ecxAucTDuDmgwvo2OavKUq+Dn8HT3PS0NttGJLE15Ekvq5we3OTVvB2CcCmP+YjNvEwWrfsCH09Ixy5tFnh+gBq/LRtQ1LnepU99+ootyAby3dOgqWpLf45NEymrZfbW3it62ilh1vrS3rmfaw7EAwnG0+5+fqG9ZmO09d21Xi4taAoF9fvR2Fgjw+UamuKGOaaMH/vsfDtEgQd7epn4m5I9fXqJABY/9s8mBhawNnOC3kF2ZWuJ85Kwnc7P4SbYx+83n0iLM1skf70HiLP/ojoa7vx7aRD6NJe9p6qhZtH4syNvXi9+wfo5OCDhOSz2PD7F0jNuFPnm5g1kY62LhZ+cAD7zq7CkUvh2PRHxet7LMxs0bF1DwR4jwcAHL64CUdjN+PdV0NkhlQ7tumBCa8vxLoDIdh5ajlG9J8lbWtv54Upgcvx86HPEXl2NQz1TfFW72n44PVv5YbMAn2m4pvNI3E75RJc7L1r/fNMGLQQz/Mzse/MSuQWZkMikSB87n0YWFQe5l71HInV+z/FkdhwmTB3IykaABB9/VdEX/+10u09nPrD2yUA1++fBgA8fHwTi3+p+mlQdQhz6lyvsudeHa3cMx0Zz1LxzQcHYGzQXK69NsOt9UEikSB02wSUlBYhJGij3C+5IpFIqeHWqGu7UFiSjzd7fqRUW1MkklT3qBU1qLJi4HhY9eupUll5GUpKi6CvZ9hoxxzzbVu0Mm+r9Otv0p/ekw6XTQ51Q0FxrsIrczl5T/E4+yHa23WRWZ78KB5Tv+uKtjbuWDXjonT5+YSD+Nf6N/F2v08x5aUn8lbvn4Vdp5bj+39Go3Nb+Xc5+k4HVJyVZQihv1UnIFik1FOAZeVlmLLcE+1su2DOqMqvEDWUX479BxHHFyF87n3BDukRqcLU773QyrwtFozfrVRbTajbZ3Nd8Z45DVVSWoxtx5fgo+VdMHieId76wgz/+G837IleIV1H0T1zL5bF3j6CzYf/jXGL2uHNufo4eWU7gIrfvA6eX4ePw15B4OfGCPzcGJOXuWPD719K97HpjwWVvupI0f1x9fXqJKD6m9hfMDWylAtyQMXNy22t3eSGXo7HbQUADO87U2b5iz8fjW38kEA1o62ljQ8Hh+L45QgkP5J/cKKhDe87EyYG5thxsm7DvERNSfT1PUgSX8ekNxYr1dZUcZhVA5WUFmPu/wbiyt0T8HYZAH+vMdDV1UdS+jVEX9uNob2nVbuPNZGfoay8BG+8MhmG+qZo3aLiBtPFEWNxNG4LOrZ5BaNe+xzG+s3x4MlNRF3difcHfl0v9c8OCsfq/Z/A1MgKo/w+ly6v6tVJ9aW8vBxPn6fD3Fj2ybtbKTGwMrOTmd4CAFo2bw1LU1vcehjT4LVR7XXv+Dp+X1KmkmPr6erX+oXlRE1Vb7eh+O0/xUq3NVUMcxpod9T3uHL3BIL85mLioG9l2l5+b2VViksL8OPMOJmh1ZNXtuNo3Ba85jUGISM3ytybVNP91kRtXp1UXyLPrUZmTjpG/+3G3ac5aXBoqfhmXSszOzx5ltIY5REREclhmNNAx+K2wMTAHGP9v5Rrq+l8SoE+U+XukTsauwUA8NHgULn91Oc8TapyI+kMVu//FE42nnIvgy4qzoeuTjOF2+np6KOoOF9hG9W/w0t5my8R0csY5jRQxQSpXaCnq1/rfdhZuSjcr4WpTa0n/6wPeQXPUFRSILPMzLhFjSegrMztlEv41/o3YWlqi4UTD8idu2Z6higpLVK4bXFpIZo14sMhREREL2OYI4Xq8uRqVTPll5WX1nq/ALBy7wy59x6Gz71f6Ts8ayIxJRZz1gbASN8MoVOOw8rMTm4dS1NbZOSkKtw+41kqrEzltyEiImoMDHMayM7KBQ8f30RxaRH0KhkarA37Fi44c2Mvsp4/qvLqnMmf0y88z8+UCVnFJYXIzEmHrWX7ao9VWSBU9N5DCxPrGlSvWGJKLGav9YdBMxMsnXIcrcwdFK7Xwb47jsZtwePshzIPQTzOfoinOWnwcR1S6xqIiIjqQvg3OpGc17xG43lBFrYe+UaurS7TCvp1HQ0AWHcgRO6Bh5f3a9eiYog2NvGIzDq7or5DuaRmD0pU9uokh1aucq9hqu1w8p3UOMxeFwD9ZsYInXIcNhaOla7r2/U9ABUPl7zsxZ9f8xpdqxqIiIjqilfmNNCwPjNwLn4/thz9BrcexsDbZQD0dPWRJL6BlCe3sOSjI9XvRIH+niNw+tpIHL60CakZifBxHQJjA3OkZNzGpVu/Y91nFXOzeTn7o3WLDtj4x5fIyX8KawtH3Lh/GgkPzsHMyKpGx6rNq5MA4PClcDzOSgYAZOc9QWlZMbb8GWpbmjsgwLtiNvpHWcmYvTYAuQVZGNZ7Om4kncGNpDMy++rtPkx6vFc6vYmenQZj16nlyCt8BlcHH8Qnn8WhCz/hNa8xcHPsU/MTSUREVI8Y5jSQro4e/jP5D+w4tQzH47Zi/aF50NPRh52VMwZ2n1Cnfc8dtRVujn1xKOYnbD7yNbS0tGFt7oh+HiOk62hraePrCfuwcs907I3+ATraevB2GYBlU09i5sreNTpObV6dBACHLvyEq/dOyizb8HvFNCMeTv2lYU6ceR85+U8BAJsOL1C4r3BH2eN9MXYHthz9BkdjN+PopXBYmtlh/ICvEeQ3p0Y/ExERUUPg67xUTBNer0SVU7dXxrC/ERGp32dzXfHKHBERNZqVe6bjbPw+PMpKxo8z4xS+Vg8A7qdfw4o9HyMr9xEAYMLrC9HXfXgjVkokHAxzRETUaPp6vIN3Xw3BJ6sqv8+0sDgfX254C7ODNsHNsQ/KyssUPhBFRBUY5oiIqNF4OPWrdp1jcVvRqU1P6YNF2lraaN4I72YmEiqGOSIiUisPHsVDV6cZ/rV+MJ5kp8DJxgMfBS5joCOqBOeZIyIitVJWXoq4xCOY+fYarP4kDlZmdgjbPVXVZRGpLYY5IiJSKy2bt4FnO19YmdlBJBLhNa8xSHhwTtVlEakthjkiIlIr/T3fxa2UGOQV5gAALtw8CCcbTxVXRaS+eM8cERE1mu93foTzNw8g87kYc/83EIbNTLBxzh0s2zEJPq5D0KvzELQ0b4P3/OZh5opeEIm0YGVmh5nvrFV16URqi5MGqxgncdVs6jYxJfsbEZH6fTbXFYdZiYiIiASMYY6IiIhIwBjmiIiIiASMYY6IiIhIwBjmiIiIiASMYY6IiIhIwBjmiIiIiASMYY6IiIhIwJpEmMvIyEBISAjat28PfX19tG7dGjNmzEBeXh4mTpwIkUiEFStWqLpMIiIiIqVp/Ou8Ll++jEGDBkEsFsPIyAiurq5IS0tDWFgY7t69i8zMTABAly5dVFtoFSKOLUJiaiwSUy5BnHkfrcwdsHlekqrLIg3EvkZEJDwaHeYyMjIQGBgIsViMWbNmYf78+TAxMQEALFmyBLNnz4aOjg5EIhE8PDxUXG3l1v82DyaGFnC280JeQbaqyyENxr5GRCQ8Gh3mpk+fjpSUFEybNg2hoaEybSEhIdi6dSuuXLkCR0dHmJqaqqjK6m2acxc2lk4AgMmhbigozlVxRaSp2NeIiIRHY++ZS0hIwLZt22BlZYVFixYpXMfb2xsA4OnpKV32Ivz16NEDzZo1g0gkapR6q/Liy5WoobGvEREJj8aGuYiICJSXl2P06NEwNjZWuI6BgQEA2TB3584d7Nq1C9bW1ujevXuj1EpERERUWxob5o4dOwYA8PX1rXSdlJQUALJhrl+/fkhPT8e+ffvg7+/fsEUSERER1ZHG3jOXnJwMAHBwcFDYXlpaiujoaACyYU5Lq/7zbbdu3SAWixW26ekYYO20xHo/JqkHZxdnFJcWqLoMKfY3IiL1+2wGAGtra1y8eLFW22psmMvLywMAFBQo/svatm0bMjIyYGJiAkdHxwatRSwWIzU1VWGbvq5hgx6bVCs9LQ2FJfmqLkOK/Y2ISP0+m+tKY8OctbU1srKyEBsbCx8fH5m29PR0BAcHAwA8PDwa/CEHa2vrStv0dAwa9NikWja2tmr12x/7GxGR+n02A1VnhepobJjz9/dHQkICFi9ejICAALi4uAAAYmJiMHbsWGRkZABonMmCq7psWlYMHA9r8BJIRRJvJ0JbT9VV/IX9jYhI/T6b60pjH4AICQmBpaUlHj58iM6dO8Pd3R3Ozs7o0aMHnJyc4OfnB0D2fjkiIiIiodHYK3P29vaIiopCcHAwTp48iaSkJLi6umLNmjWYPHky2rVrB0AYYe7wpXA8zqp4oCM77wlKy4qx5cg3AICW5g4I8B6ryvJIg7CvEREJj8aGOQDo1KkTIiMj5Zbn5uYiKSkJWlpacHNzU0Flyjl04SdcvXdSZtmG378AAHg49ecXLNUb9jUiIuHR6DBXmRs3bkAikcDFxQWGhvJP9+3cuRMAEB8fL/Pntm3bolu3bo1X6J+WTT3R6Mekpol9jYhIeJpkmLt27RqAyodYR4wYofDP48ePx4YNGxq0NiIiIiJlMMwpIJFIGrMcIiIiolrT2KdZq1JdmCMiIiISiiZ5Ze7Fe1uJiIiIhK5JXpkjIiIi0hQMc0REREQCxjBHREREJGAMc0REREQCxjBHREREJGAMc0REREQCxjBHREREJGAMc0REREQCxjBHREREJGAMc0REREQCxjBHREREJGAiiUQiUXURTZlEApSXqLoKaihauoBIpOoq/sL+RkSkfp/NdcUwR0RERCRgHGYlIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiEjCGOSIiIiIBY5gjIiIiErD/A3KLQy7OdfGoAAAAAElFTkSuQmCC", "text/plain": [ - "" + "
" ] }, "execution_count": 5, @@ -188,7 +189,37 @@ } ], "source": [ - "result.evolved_state" + "result.evolved_state.draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "id": "6b207d17-7633-40b6-b70e-3788966c4fb8", + "metadata": {}, + "source": [ + "By sequentially decomposing the circuit, we can show it in terms of the gates of the Qiskit's [Circuit Library](https://qiskit.org/documentation/apidoc/circuit_library.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a434781a-67be-41e9-b0df-c3c7e17d39b8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.evolved_state.decompose(reps=2).decompose('disentangler_dg').decompose('multiplex1_reverse_dg').draw('mpl')" ] }, { @@ -201,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "e338fd96-ff0d-4473-8ac1-3e8edb472f61", "metadata": {}, "outputs": [ @@ -230,17 +261,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "9adc5a51-e976-4b9b-9d19-8b3002cef4e1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -320,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "f771ffe3-66a6-425e-ad61-1a483888c67a", "metadata": {}, "outputs": [], @@ -341,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "5fa5bbd8-21a7-41ba-b79b-9b63717dc15d", "metadata": {}, "outputs": [], @@ -363,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "196364a5-3bca-454d-ab50-38f74d3a305d", "metadata": {}, "outputs": [], @@ -385,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "147f30af-ebd3-41ef-88fc-256d01e1ff3d", "metadata": {}, "outputs": [], @@ -405,7 +436,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "43e41a25-881b-4765-b933-0de40e57e139", "metadata": {}, "outputs": [], @@ -423,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "25d7df68-89a1-4d63-92ad-e80def7b5330", "metadata": {}, "outputs": [ @@ -433,7 +464,7 @@ "(61, 3)" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -447,7 +478,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "b23392e1-6c14-4179-aeb6-392c829f5282", "metadata": {}, "outputs": [ @@ -457,7 +488,7 @@ "Text(0.5, 0.98, 'Observable evolution')" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, @@ -503,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "3ccb7f8b-fe5f-4405-abd4-8cb0cd919916", "metadata": {}, "outputs": [], @@ -529,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "f3d29f74-55ea-4261-802a-a8346cbc231d", "metadata": {}, "outputs": [], @@ -549,7 +580,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "386e3a68-ea28-499a-a5f9-797896ba3a9f", "metadata": {}, "outputs": [ @@ -560,7 +591,7 @@ "
" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -607,7 +638,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "ee8f1ba9-3c5d-41fe-9f93-1fe735216dd9", "metadata": {}, "outputs": [ @@ -633,7 +664,7 @@ "
" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -682,7 +713,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "9ef7b40c-cdcb-4e61-a4d9-b893af870821", "metadata": {}, "outputs": [ @@ -709,7 +740,7 @@ "
" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -741,7 +772,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "6c3befc4-9c10-4081-a245-d50e693dc195", "metadata": { "scrolled": true @@ -794,7 +825,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "60beaab5-7b78-456b-8df4-097c14c7967c", "metadata": {}, "outputs": [], @@ -817,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "227b00c2-063e-4409-996e-5f8e48844ab8", "metadata": {}, "outputs": [ @@ -828,7 +859,7 @@ "
" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -864,17 +895,17 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "id": "cb194f62-1d36-45a4-9874-b937ffc76860", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, @@ -923,14 +954,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "61de877f-d783-48cf-bccf-deb99e2f4e4d", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "

Version Information

SoftwareVersion
qiskitNone
qiskit-terra0.25.1
qiskit_algorithms0.2.0
System information
Python version3.11.2
Python compilerGCC 8.5.0 20210514 (Red Hat 8.5.0-18)
Python buildmain, Jun 6 2023 07:39:01
OSLinux
CPUs4
Memory (Gb)15.27389907836914
Wed Aug 23 13:50:56 2023 CEST
" + "

Version Information

SoftwareVersion
qiskitNone
qiskit-terra0.25.1
qiskit_algorithms0.2.0
System information
Python version3.11.2
Python compilerGCC 8.5.0 20210514 (Red Hat 8.5.0-18)
Python buildmain, Jun 6 2023 07:39:01
OSLinux
CPUs4
Memory (Gb)15.27389907836914
Thu Aug 24 11:05:30 2023 CEST
" ], "text/plain": [ "" From 6e647213005d5bfcec230ba302f1e6a3fe146a6f Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Thu, 24 Aug 2023 11:12:59 +0200 Subject: [PATCH 09/12] Update .pylintdict MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Missing name "masuo" Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com> --- .pylintdict | 1 + 1 file changed, 1 insertion(+) diff --git a/.pylintdict b/.pylintdict index 0d5af27b..01062282 100644 --- a/.pylintdict +++ b/.pylintdict @@ -184,6 +184,7 @@ lsb lse magnus marecek +masuo mathcal mathrm maxcut From 612842b6dc7f5c5400c3c2243e0df78aa04bc827 Mon Sep 17 00:00:00 2001 From: Ivan Alsina-Ferrer <50876898+ialsina@users.noreply.github.com> Date: Thu, 24 Aug 2023 11:16:32 +0200 Subject: [PATCH 10/12] Update docs/tutorials/13_trotterQRTE.ipynb MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com> --- docs/tutorials/13_trotterQRTE.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 0d368a09..ad0a33de 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -197,7 +197,7 @@ "id": "6b207d17-7633-40b6-b70e-3788966c4fb8", "metadata": {}, "source": [ - "By sequentially decomposing the circuit, we can show it in terms of the gates of the Qiskit's [Circuit Library](https://qiskit.org/documentation/apidoc/circuit_library.html)." + "By sequentially decomposing the circuit, we can show it in terms of the gates of the Qiskit [Circuit Library](https://qiskit.org/documentation/apidoc/circuit_library.html)." ] }, { From 9db214fd00089ba97181fa1a719fb0da48418a19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elena=20Pe=C3=B1a=20Tapia?= <57907331+ElePT@users.noreply.github.com> Date: Thu, 24 Aug 2023 13:36:05 +0200 Subject: [PATCH 11/12] Update docs/tutorials/13_trotterQRTE.ipynb --- docs/tutorials/13_trotterQRTE.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index ad0a33de..5225bee9 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -197,7 +197,7 @@ "id": "6b207d17-7633-40b6-b70e-3788966c4fb8", "metadata": {}, "source": [ - "By sequentially decomposing the circuit, we can show it in terms of the gates of the Qiskit [Circuit Library](https://qiskit.org/documentation/apidoc/circuit_library.html)." + "By sequentially decomposing the circuit, we can show it in terms of Qiskit's [Circuit Library](https://qiskit.org/documentation/apidoc/circuit_library.html) standard gates." ] }, { From a4b7c8312fb527424ee6615cb2825eec78c8f88c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Elena=20Pe=C3=B1a=20Tapia?= <57907331+ElePT@users.noreply.github.com> Date: Thu, 24 Aug 2023 14:35:18 +0200 Subject: [PATCH 12/12] Update docs/tutorials/13_trotterQRTE.ipynb Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- docs/tutorials/13_trotterQRTE.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/13_trotterQRTE.ipynb b/docs/tutorials/13_trotterQRTE.ipynb index 5225bee9..2fc61b1e 100644 --- a/docs/tutorials/13_trotterQRTE.ipynb +++ b/docs/tutorials/13_trotterQRTE.ipynb @@ -377,7 +377,7 @@ "metadata": {}, "outputs": [], "source": [ - "from qiskit_algorithms.time_evolvers.trotterization.trotter_qrte import TrotterQRTE\n", + "from qiskit_algorithms import TrotterQRTE\n", "from qiskit.primitives import Estimator\n", "\n", "num_timesteps = 60\n",