diff --git a/docs/notebooks/krylov.ipynb b/docs/notebooks/krylov.ipynb new file mode 100644 index 0000000..3b7133e --- /dev/null +++ b/docs/notebooks/krylov.ipynb @@ -0,0 +1,965 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculating ground states on large scale systems: Quantum Krylov Subspaces" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Map problem to quantum native format\n", + "\n", + "Across disciplines, we're interested in learning ground state properties of quantum systems. Examples include understanding the fundamental nature of particles and forces, predicting and undestanding the behavior of complex materials and understanding bio-chemical interactions and reactions. Because of the exponential growth of the Hilbert space and the correlation that arise in entangled systems, classical algorithm struggle to solve this problem for quantum systems of increasing size. At one end of the spectrum, existing approach that take advantage of the quantum hardware focus on variational quantum methods (e. g. [variational quantum eigen-solver](https://learning.quantum.ibm.com/tutorial/variational-quantum-eigensolver)). These techniques face challenges with current devices because of the high number of function calls required in the optimization process, which is incompatible with advanced error mitigation techniques, thus limiting their efficacy to small systems. At the other end of the spectrum, there are fault-tolerant quantum methods with performance guarantees (e.g. [quantum phase estimation](https://arxiv.org/pdf/quant-ph/0604193.pdf)) which require deep circuits that can be executed only on a fault-tolerant device. For these reasons, we introduce here a quantum algorithm based on subspace methods (as reviewed [here](https://arxiv.org/pdf/2312.00178.pdf)), the quantum Krylov algorithm. This algorithm performs well at large scale on existing quantum hardware, shares similar [performance guarantees](https://arxiv.org/pdf/2110.07492.pdf) as phase estimation, are compatible with advanced error mitigation techniques and could provide results that are classically inaccessible.\n", + "\n", + "Let us now go into more details of how subspace methods, and the quantum Krylov algorithm in particular, work. Given a matrix $H$ for which we want to know its lowest eigenvalue, subspace methods construct of a smaller representation $\\tilde{H}$ of $H$, which captures its properties of interest. In the case of the quantum Krylov algorithm, the Krylov subspace is used to construct the effective representation.\n", + "\n", + "### What is the Krylov subspace? \n", + "\n", + "By definition, the Krylov subspace $K^r$ of order $r$ is the subspace spanned by vectors obtained by multiplying higher powers of $H$, up to $r-1$, with a reference vector $\\vert \\psi \\rangle$.\n", + "\n", + "$$K^r = \\left\\{ \\vert \\psi \\rangle, H \\vert \\psi \\rangle, H^2 \\vert \\psi \\rangle, ..., H^{r-1} \\vert \\psi \\rangle \\right\\}$$\n", + "\n", + "We can gain some insight on why this subspace is interesting by expanding the reference state in terms of the eigenvectors $\\vert \\lambda_i \\rangle$ of the matrix $H$:\n", + "\n", + "$$ \\vert \\psi \\rangle = c_1 \\vert \\lambda_1 \\rangle + c_2 \\vert \\lambda_2 \\rangle + ... + c_n \\vert \\lambda_n \\rangle $$\n", + "\n", + "Applying $j^{th}$ power of the matrix $H$ gives:\n", + "\n", + "$$ H^n \\vert \\psi \\rangle = c_1 \\lambda_1^n \\vert \\lambda_1 \\rangle + c_2 \\lambda_2^n \\vert \\lambda_2 \\rangle + ... + c_n \\lambda_n^n \\vert \\lambda_n \\rangle $$\n", + "\n", + "Which means that the component $k$ with the largest eigenvalue $\\lambda_k$ is amplified by the power iteration (This can also be a problem as the basis vector become too similar to each other). The same is true for the smallest eigenvalue, if we consider power iteration of the matrix $H^{-1}$.\n", + "\n", + "### Why is it useful for ground state energy problems?\n", + "\n", + "The Krylov subspace is constructed using the power iteration method. Therefore, states in the Krylov subspace corresponding to the multiplication with higher power of the matrix with the reference states will have the contribution of the ground state $\\vert \\lambda_k \\rangle$ enhanced.\n", + "\n", + "\n", + "The Krylov subspace that we use classically cannot be accessed on a quantum computer as $H$ is not a unitary matrix. Instead, we can use the time-evolution operator $U = e^{-iHt}$ which can be shown to give similar [convergence guarantees](https://arxiv.org/pdf/2110.07492.pdf) as the power method. Powers of $U$ then become different time steps $U^k = e^{-iH(kt)}$.\n", + "\n", + "\n", + "$$K_U^r = \\left\\{ \\vert \\psi \\rangle, U \\vert \\psi \\rangle, U^2 \\vert \\psi \\rangle, ..., U^{r-1} \\vert \\psi \\rangle \\right\\}$$\n", + "\n", + "The subspace $K_U^r$ obtained in this way is called \"Unitary\" Krylov subspace.\n", + "\n", + "\n", + "### How does the algorithm work in summary?\n", + "\n", + "First, we want to find a compact represention of the Hamiltonian in the Krylov subspace $\\tilde{H}$. Given that the Krylov subspace has dimension $r$, the Hamiltonian projected into the Krylov subspace will have dimensions $r \\times r$. We can then easily diagonalize the projected Hamiltonian $\\tilde{H}$. However, we cannot directly diagonalize $\\tilde{H}$ because of the non-orthogonality of the Krylov subpace vectors. We'll have to measure their overlaps and construct a matrix $\\tilde{S}$ collecting them to do so. We can then solve the generalized eigenvalue problem\n", + "\n", + "$$ \\tilde{H} \\ \\vec{c} = c \\ \\tilde{S} \\ \\vec{c} $$\n", + "\n", + "Where $\\tilde{H}=\\langle \\psi_m \\vert H \\vert \\psi_n \\rangle$ is the Hamiltonian matrix in the Krylov subspace $K_D = \\left\\{ \\vert \\psi_0 \\rangle, \\vert \\psi_1 \\rangle, ..., \\vert \\psi_D \\rangle \\right\\}$ with dimension $D$, $\\vec{c}$ is a vector of variational coefficients that are optimized to get the lowest value of the energy $c_{min}=E_{GS}$ and $\\tilde{S}=\\langle \\psi_m \\vert \\psi_n \\rangle$ is a matrix of overlaps between states of the Krylov subspace.\n", + "\n", + "Each of the Krylov subspace's vectors are obtained by time-evolving the reference state $\\vert \\psi \\rangle$ under the Hamiltonian $H$ for a certain time: $\\vert \\psi_l \\rangle = U \\vert \\psi \\rangle = e^{-i H t_l}\\vert \\psi \\rangle$. \n", + "\n", + "We can implement the algorithm on a quantum computer by using the Hadamard test to calculate the matrix elements of $\\tilde{H}$ and $\\tilde{S}$ as expectation values:\n", + "\n", + "$$\\langle \\psi_m \\vert H \\vert \\psi_n \\rangle = $$\n", + "$$= \\langle \\psi \\vert e^{i H t_m} H e^{-i H t_n} \\vert \\psi \\rangle$$\n", + "$$= \\langle \\psi \\vert e^{i H m \\delta t} H e^{-i H n \\delta t} \\vert \\psi \\rangle$$\n", + "$$= \\langle \\psi \\vert H e^{-i H (n-m) \\delta t} \\vert \\psi \\rangle$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and definitions\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy as sp\n", + "import matplotlib.pylab as plt\n", + "from typing import Union, List\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit.circuit import Parameter\n", + "from qiskit import QuantumCircuit, QuantumRegister, transpile\n", + "from qiskit.circuit.library import PauliEvolutionGate\n", + "from qiskit.synthesis import SuzukiTrotter\n", + "from qiskit.providers.fake_provider import Fake20QV1\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator\n", + "\n", + "\n", + "def solve_regularized_gen_eig(h: np.ndarray, s:np.ndarray, threshold: float, k: int =1, return_dimn: bool = False) -> Union[float, List[float]]:\n", + " \"\"\"\n", + " Method for solving the generalized eigenvalue problem with regularization\n", + "\n", + " Args:\n", + " h (numpy.ndarray):\n", + " The effective representation of the matrix in the Krylov subspace\n", + " s (numpy.ndarray):\n", + " The matrix of overlaps between vectors of the Krylov subspace\n", + " threshold (float):\n", + " Cut-off value for the eigenvalue of s\n", + " k (int):\n", + " Number of eigenvalues to return\n", + " return_dimn (bool):\n", + " Whether to return the size of the regularized subspace\n", + "\n", + " Returns:\n", + " lowest k-eigenvalue(s) that are the solution of the regularized generalized eigenvalue problem\n", + "\n", + " \n", + " \"\"\"\n", + " s_vals, s_vecs = sp.linalg.eigh(s)\n", + " s_vecs = s_vecs.T\n", + " good_vecs = np.array([vec for val, vec in zip(s_vals, s_vecs) if val > threshold])\n", + " h_reg = good_vecs.conj() @ h @ good_vecs.T\n", + " s_reg = good_vecs.conj() @ s @ good_vecs.T\n", + " if k==1:\n", + " if return_dimn:\n", + " return sp.linalg.eigh(h_reg, s_reg)[0][0], len(good_vecs)\n", + " else:\n", + " return sp.linalg.eigh(h_reg, s_reg)[0][0]\n", + " else:\n", + " if return_dimn:\n", + " return sp.linalg.eigh(h_reg, s_reg)[0][:k], len(good_vecs)\n", + " else:\n", + " return sp.linalg.eigh(h_reg, s_reg)[0][:k]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define Hamiltonian\n", + "Let's consider the Heisenberg Hamiltonian for $N$ qubits on a linear chain: $H=-J \\sum_{i,j}^N Z_i Z_j + J \\sum_{i,j}^N X_i X_j + Y_i Y_j$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[('ZZIIIIIIII', -1), ('IZZIIIIIII', -1), ('IIZZIIIIII', -1), ('IIIZZIIIII', -1), ('IIIIZZIIII', -1), ('IIIIIZZIII', -1), ('IIIIIIZZII', -1), ('IIIIIIIZZI', -1), ('IIIIIIIIZZ', -1), ('XXIIIIIIII', 1), ('IXXIIIIIII', 1), ('IIXXIIIIII', 1), ('IIIXXIIIII', 1), ('IIIIXXIIII', 1), ('IIIIIXXIII', 1), ('IIIIIIXXII', 1), ('IIIIIIIXXI', 1), ('IIIIIIIIXX', 1), ('YYIIIIIIII', 1), ('IYYIIIIIII', 1), ('IIYYIIIIII', 1), ('IIIYYIIIII', 1), ('IIIIYYIIII', 1), ('IIIIIYYIII', 1), ('IIIIIIYYII', 1), ('IIIIIIIYYI', 1), ('IIIIIIIIYY', 1)]\n" + ] + } + ], + "source": [ + "# Define problem Hamiltonian. Kicked Ising in this case\n", + "n_qubits = 10\n", + "J = 1 # coupling strength for ZZ interaction\n", + "\n", + "# Define interacting part of the Hamiltonian: sum_ij Z_i Z_j\n", + "H_int = [['I']*n_qubits for _ in range(3*(n_qubits-1))]\n", + "for i in range(n_qubits-1):\n", + " H_int[i][i] = 'Z'\n", + " H_int[i][i+1] = 'Z'\n", + "for i in range(n_qubits-1):\n", + " H_int[n_qubits-1+i][i] = 'X'\n", + " H_int[n_qubits-1+i][i+1] = 'X'\n", + "for i in range(n_qubits-1):\n", + " H_int[2*(n_qubits-1)+i][i] = 'Y'\n", + " H_int[2*(n_qubits-1)+i][i+1] = 'Y'\n", + "H_int = [''.join(term) for term in H_int]\n", + "H_tot = [(term, -J) if term.count('Z') == 2 else (term, 1) for term in H_int]\n", + "\n", + "# Get operator\n", + "H_op = SparsePauliOp.from_list(H_tot)\n", + "print(H_tot)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set parameters for the algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Set parameters for quantum Krylov algorithm\n", + "krylov_dim = 20 # size of krylov subspace\n", + "dt = 0.1 # time step\n", + "num_trotter_steps = 4\n", + "dt_circ = dt/num_trotter_steps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State preparation\n", + "Pick a reference state $\\vert \\psi \\rangle$ that has some overlap with the ground state. For this Hamiltonian, We use the \"checkerboard\" state $\\vert 0101...01 \\rangle$ as our reference." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc_state_prep = QuantumCircuit(n_qubits)\n", + "for i in range(n_qubits):\n", + " if i%2 != 0:\n", + " qc_state_prep.x(i)\n", + "qc_state_prep.draw('mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time evolution\n", + "\n", + "We can realize the time-evolution operator generated by a given Hamiltonian: $U=e^{-iHt}$ via the [Suzuki-Trotter approximation]((https://docs.quantum.ibm.com/api/qiskit/qiskit.synthesis.SuzukiTrotter))." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = Parameter('t')\n", + "\n", + "## Create the time-evo op circuit\n", + "evol_gate = PauliEvolutionGate(H_op, time=t, synthesis=SuzukiTrotter(order=num_trotter_steps) )\n", + "\n", + "qr = QuantumRegister(n_qubits)\n", + "qc_evol = QuantumCircuit(qr)\n", + "qc_evol.append(evol_gate, qargs=qr)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hadamard test\n", + "\n", + "\n", + "\n", + "\\begin{equation}\n", + " |0\\rangle_a|\\psi_0\\rangle\\quad\\longrightarrow\\quad\\frac{1}{\\sqrt{2}}\\Big(|0\\rangle+|1\\rangle\\Big)_a|\\psi_0\\rangle\\quad\\longrightarrow\\quad\\frac{1}{\\sqrt{2}}\\Big(|0\\rangle_a|\\psi_0\\rangle+|1\\rangle_aU_j^\\dagger PU_k|\\psi_0\\rangle\\Big)\n", + "\\end{equation}\n", + "Where $P$ is one of the terms in the decomposition of the Hamiltonian $H=\\sum P$. To measure $X$, first apply $H$...\n", + "\\begin{equation}\n", + " \\longrightarrow\\quad\\frac{1}{2}|0\\rangle_a\\Big(|\\psi_0\\rangle+U_j^\\dagger PU_k|\\psi_0\\rangle\\Big) + \\frac{1}{2}|1\\rangle_a\\Big(|\\psi_0\\rangle-U_j^\\dagger PU_k|\\psi_0\\rangle\\Big)\n", + "\\end{equation}\n", + "... then measure:\n", + "\\begin{equation}\n", + "\\begin{split}\n", + " \\Rightarrow\\quad\\langle X\\rangle_a &= \\frac{1}{4}\\Bigg(\\Big\\||\\psi_0\\rangle+U_j^\\dagger PU_k|\\psi_0\\rangle\\Big\\|^2-\\Big\\||\\psi_0\\rangle-U_j^\\dagger PU_k|\\psi_0\\rangle\\Big\\|^2\\Bigg) \\\\\n", + " &= \\text{Re}\\Big[\\langle\\psi_0|U_j^\\dagger PU_k|\\psi_0\\rangle\\Big].\n", + "\\end{split}\n", + "\\end{equation}\n", + "Similarly, measuring $Y$ yields\n", + "\\begin{equation}\n", + " \\langle Y\\rangle_a = \\text{Im}\\Big[\\langle\\psi_0|U_j^\\dagger PU_k|\\psi_0\\rangle\\Big].\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit for calculating the real part of the overlap in S via Hadamard test\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Create the time-evo op circuit\n", + "evol_gate = PauliEvolutionGate(H_op, time=dt, synthesis= SuzukiTrotter(order=num_trotter_steps) ) #MatrixExponential exact matrix exp, SuzukiTrotter(order=2) for order-2 Trotter evo op\n", + "\n", + "## Create the time-evo op dagger circuit\n", + "evol_gate_d = PauliEvolutionGate(H_op, time=dt, synthesis= SuzukiTrotter(order=num_trotter_steps) )\n", + "evol_gate_d = evol_gate_d.inverse()\n", + "\n", + "# Put pieces together\n", + "qc_reg = QuantumRegister(n_qubits)\n", + "qc_temp = QuantumCircuit(qc_reg)\n", + "qc_temp.compose(qc_state_prep, inplace=True)\n", + "for _ in range(num_trotter_steps):\n", + " qc_temp.append(evol_gate, qargs=qc_reg)\n", + "for _ in range(num_trotter_steps):\n", + " qc_temp.append(evol_gate_d, qargs=qc_reg)\n", + "qc_temp.compose(qc_state_prep.inverse(), inplace=True)\n", + "\n", + "# Create controlled version of the circuit\n", + "controlled_U = qc_temp.to_gate().control(1)\n", + "\n", + "# Create hadamard test circuit for real part\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_real = QuantumCircuit(qr)\n", + "qc_real.h(0)\n", + "qc_real.append(controlled_U, list(range(n_qubits+1)))\n", + "qc_real.h(0)\n", + "\n", + "print('Circuit for calculating the real part of the overlap in S via Hadamard test')\n", + "qc_real.draw('mpl', fold=-1, scale=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Hadamard test circuit can be a deep circuit once we transpile to native gates and topology of a device. For example the 5 qubits case considered here " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The circuit has 2Q gates depth: 96\n" + ] + } + ], + "source": [ + "circuit_trans_unopt = transpile(circuits=qc_real.decompose().decompose(), backend=Fake20QV1())\n", + "\n", + "print('The circuit has 2Q gates depth: ', circuit_trans_unopt.depth(lambda x: x[0].num_qubits == 2))\n" + ] + }, + { + "attachments": { + "optimized_H_test.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Optimize circuits and operators\n", + "\n", + "We can optimize the deep circuits for the Hadamard test that we have obtained by introducing some approximations and relying on some assumption about the model Hamiltonian. For example, consider the following circuit for the Hadamard test:\n", + "\n", + "\n", + "![optimized_H_test.png](attachment:optimized_H_test.png)\n", + "\n", + "Assume we can classically calculate $E_0$, the eigenvalue of $|0\\rangle^N$ under the Hamiltonian $H$.\n", + "This is satisfied when the Hamiltonian preserves the U(1) symmetry.\n", + "Assume that the gate $\\psi_0-prep$ prepares our desired reference state $\\ket{\\psi_0}$, e.g., to prepare the HF state for chemistry $\\psi_0-prep$ would be a product of single-qubit NOTs, so controlled-$\\psi_0-prep$ is just a product of CNOTs.\n", + "Then the circuit above implements the following state prior to measurement:\n", + "\n", + "\\begin{equation}\n", + "\\begin{split}\n", + " \\ket{0} \\ket{0}^N\\xrightarrow{H}&\\frac{1}{\\sqrt{2}}\n", + " \\left(\n", + " \\ket{0}\\ket{0}^N+ \\ket{1} \\ket{0}^N\n", + " \\right)\\\\\n", + " \\xrightarrow{\\text{1-ctrl-init}}&\\frac{1}{\\sqrt{2}}\\left(|0\\rangle|0\\rangle^N+|1\\rangle|\\psi_0\\rangle\\right)\\\\\n", + " \\xrightarrow{U}&\\frac{1}{\\sqrt{2}}\\left(e^{i\\phi}\\ket{0}\\ket{0}^N+\\ket{1} U\\ket{\\psi_0}\\right)\\\\\n", + " \\xrightarrow{\\text{0-ctrl-init}}&\\frac{1}{\\sqrt{2}}\n", + " \\left(\n", + " e^{i\\phi}\\ket{0} \\ket{\\psi_0}\n", + " +\\ket{1} U\\ket{\\psi_0}\n", + " \\right)\\\\\n", + " =&\\frac{1}{2}\n", + " \\left(\n", + " \\ket{+}\\left(e^{i\\phi}\\ket{\\psi_0}+U\\ket{\\psi_0}\\right)\n", + " +\\ket{-}\\left(e^{i\\phi}\\ket{\\psi_0}-U\\ket{\\psi_0}\\right)\n", + " \\right)\\\\\n", + " =&\\frac{1}{2}\n", + " \\left(\n", + " \\ket{+i}\\left(e^{i\\phi}\\ket{\\psi_0}-iU\\ket{\\psi_0}\\right)\n", + " +\\ket{-i}\\left(e^{i\\phi}\\ket{\\psi_0}+iU\\ket{\\psi_0}\\right)\n", + " \\right)\n", + "\\end{split}\n", + "\\end{equation}\n", + "\n", + "where we have used the classical simulable phase shift $ U\\ket{0}^N = e^{i\\phi}\\ket{0}$ in the third line. Therefore the expectation values are obtained as\n", + "\n", + "\\begin{equation}\n", + "\\begin{split}\n", + " \\langle X\\otimes P\\rangle&=\\frac{1}{4}\n", + " \\Big(\n", + " \\left(e^{-i\\phi}\\bra{\\psi_0}+\\bra{\\psi_0}U^\\dagger\\right)P\\left(e^{i\\phi}\\ket{\\psi_0}+U\\ket{\\psi_0}\\right)\n", + " \\\\\n", + " &\\qquad-\\left(e^{-i\\phi}\\bra{\\psi_0}-\\bra{\\psi_0}U^\\dagger\\right)P\\left(e^{i\\phi}\\ket{\\psi_0}-U\\ket{\\psi_0}\\right)\n", + " \\Big)\\\\\n", + " &=\\text{Re}\\left[e^{-i\\phi}\\bra{\\psi_0}PU\\ket{\\psi_0}\\right],\n", + "\\end{split}\n", + "\\end{equation}\n", + "\n", + "\\begin{equation}\n", + "\\begin{split}\n", + " \\langle Y\\otimes P\\rangle&=\\frac{1}{4}\n", + " \\Big(\n", + " \\left(e^{-i\\phi}\\bra{\\psi_0}+i\\bra{\\psi_0}U^\\dagger\\right)P\\left(e^{i\\phi}\\ket{\\psi_0}-iU\\ket{\\psi_0}\\right)\n", + " \\\\\n", + " &\\qquad-\\left(e^{-i\\phi}\\bra{\\psi_0}-i\\bra{\\psi_0}U^\\dagger\\right)P\\left(e^{i\\phi}\\ket{\\psi_0}+iU\\ket{\\psi_0}\\right)\n", + " \\Big)\\\\\n", + " &=\\text{Im}\\left[e^{-i\\phi}\\bra{\\psi_0}PU\\ket{\\psi_0}\\right].\n", + "\\end{split}\n", + "\\end{equation}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Decompose time-evolution operator with Suzuki-Trotter decomposition\n", + "Instead of implementing the time-evolution operator exactly we can use the Suzuki-Trotter decomposition to implement an approximation of it. Repeating several times a certain order Trotter decomposition gives us further reduction of the error introduced from the approximation. In the following, we directly build the Trotter implementation in the most efficient way for the interaction graph of the Hamiltonian we are considering (nearest neighbor interactions only). In practice we insert Pauli rotations $R_{xx}$, $R_{yy}$, $R_{zz}$ with a parametrized angle $t$ which correspond to the approximate implementation of $e^{-i (XX + YY -ZZ) t}$. This gives a much shallower circuit than what is obtained using the generic `PauliEvolutionGate()` functionality. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = Parameter('t')\n", + "\n", + "# Create instruction for rotation about XX+YY-ZZ:\n", + "Rxyz_circ = QuantumCircuit(2)\n", + "Rxyz_circ.rxx(t,0,1)\n", + "Rxyz_circ.ryy(t,0,1)\n", + "Rxyz_circ.rzz(-t,0,1)\n", + "Rxyz_instr = Rxyz_circ.to_instruction(label='RXX+YY-ZZ')\n", + "\n", + "interaction_list = [[[i, i+1] for i in range(0, n_qubits-1, 2)], [[i, i+1] for i in range(1, n_qubits-1, 2)]] # linear chain\n", + "\n", + "qr = QuantumRegister(n_qubits)\n", + "trotter_step_circ = QuantumCircuit(qr)\n", + "for i, color in enumerate(interaction_list):\n", + " for interaction in color:\n", + " trotter_step_circ.append(Rxyz_instr, interaction)\n", + "\n", + "\n", + "qc_evol = QuantumCircuit(qr)\n", + "for _ in range(num_trotter_steps):\n", + " qc_evol.compose(trotter_step_circ, inplace=True)\n", + "\n", + "qc_evol.decompose().draw('mpl', fold=-1, scale = 0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Use an optimized circuit for state preparation" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "controlled_state_prep = QuantumCircuit(n_qubits + 1)\n", + "for idx in range(n_qubits):\n", + " if idx % 2 == 0:\n", + " controlled_state_prep.swap(idx, idx+1)\n", + " else:\n", + " controlled_state_prep.cx(idx+1, idx)\n", + " controlled_state_prep.cx(idx, idx+1)\n", + "\n", + "\n", + "controlled_state_prep.draw('mpl', fold=-1, scale=0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Template circuits for calculating matrix elements of $\\tilde{S}$ via Hadamard test" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create hadamard test circuit for real part\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_real = QuantumCircuit(qr)\n", + "qc_real.h(0)\n", + "qc_real.compose(controlled_state_prep, list(range(n_qubits+1)), inplace=True)\n", + "qc_real.x(n_qubits)\n", + "qc_real.compose(qc_evol, list(range(n_qubits)), inplace=True)\n", + "qc_real.compose(controlled_state_prep.inverse(), list(range(n_qubits+1)), inplace=True)\n", + "qc_real.x(0)\n", + "qc_real.h(0)\n", + "\n", + "S_real_circ = qc_real.decompose().copy()\n", + "\n", + "# # Create hadamard test circuit for imaginary part\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_imag = QuantumCircuit(qr)\n", + "qc_imag.h(0)\n", + "qc_imag.sdg(0)\n", + "qc_imag.compose(controlled_state_prep, list(range(n_qubits+1)), inplace=True)\n", + "qc_imag.x(n_qubits)\n", + "qc_imag.compose(qc_evol, list(range(n_qubits)), inplace=True)\n", + "qc_imag.compose(controlled_state_prep.inverse(), list(range(n_qubits+1)), inplace=True)\n", + "qc_imag.x(0)\n", + "qc_imag.h(0)\n", + "\n", + "\n", + "S_imag_circ = qc_imag.decompose().copy()\n", + "\n", + "S_real_circ.draw('mpl', fold=-1, scale = 0.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The optimized circuit has 2Q gates depth: 96\n", + "Compared to the unoptimized circuit depth of 96\n" + ] + } + ], + "source": [ + "circuit_trans_opt = transpile(S_real_circ.decompose().decompose(), Fake20QV1())\n", + "\n", + "print('The optimized circuit has 2Q gates depth: ', circuit_trans_opt.depth(lambda x: x[0].num_qubits ==2))\n", + "print('Compared to the unoptimized circuit depth of', circuit_trans_unopt.depth(lambda x: x[0].num_qubits == 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have considerably reduced the depth of the Hadamard test with a combination of Trotter approximation and uncontrolled unitaries" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Template circuits for calculating matrix elements of $\\tilde{H}$ via Hadamard test\n", + "The only difference between the circuits used in the Hadamard test will be the phase in the time-evolution operator and the observables measured. Therefore we can prepare a template circuit which represent the generic circuit for the Hadamard test, with placeholders for the gates that depend on the time-evolution operator.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Hamiltonian terms to measure\n", + "observable_list = []\n", + "for pauli, coeff in zip(H_op.paulis, H_op.coeffs):\n", + " # print(pauli)\n", + " observable = pauli[::-1].to_label() + 'Z'\n", + " observable_list.append([observable])\n", + "\n", + "# Parameters for the template circuits\n", + "parameters = []\n", + "for idx_ket in range(krylov_dim):\n", + " for idx_bra in range(idx_ket + 1):\n", + " parameters.append(dt_circ*(idx_ket-idx_bra))\n", + "\n", + "# Real part\n", + "# First half hadamard test\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_real_1 = QuantumCircuit(qr)\n", + "qc_real_1.h(0)\n", + "qc_real_1.compose(controlled_state_prep, list(range(n_qubits+1)), inplace=True)\n", + "qc_real_1.x(n_qubits)\n", + "qc_real_1.compose(qc_evol, list(range(n_qubits)), inplace=True) \n", + "H_real_circ_1 = qc_real_1.decompose().copy()\n", + "\n", + "# Second half hadamard test\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_real_2 = QuantumCircuit(qr)\n", + "qc_real_2.compose(controlled_state_prep.inverse(), list(range(n_qubits+1)), inplace=True)\n", + "qc_real_2.x(0)\n", + "qc_real_2.h(0)\n", + "H_real_circ_2 = qc_real_2.decompose().copy()\n", + "\n", + "# Compose them\n", + "H_real_circ = H_real_circ_1\n", + "H_real_circ = H_real_circ.compose(H_real_circ_2, list(range(n_qubits+1)))\n", + "\n", + "# Imaginary part\n", + "# First half hadamard test\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_imag_1 = QuantumCircuit(qr)\n", + "qc_imag_1.h(0)\n", + "qc_imag_1.compose(controlled_state_prep, list(range(n_qubits+1)), inplace=True)\n", + "qc_imag_1.x(n_qubits)\n", + "qc_imag_1.compose(qc_evol, list(range(n_qubits)), inplace=True) \n", + "H_imag_circ_1 = qc_imag_1.decompose().copy()\n", + "\n", + "# Second half hadamard test\n", + "qr = QuantumRegister(n_qubits+1)\n", + "qc_imag_2 = QuantumCircuit(qr)\n", + "qc_imag_2.compose(controlled_state_prep.inverse(), list(range(n_qubits+1)), inplace=True)\n", + "qc_imag_2.x(0)\n", + "qc_imag_2.sdg(0)\n", + "qc_imag_2.h(0)\n", + "H_imag_circ_2 = qc_imag_2.decompose().copy()\n", + "\n", + "# Compose them\n", + "H_imag_circ = H_imag_circ_1\n", + "H_imag_circ = H_imag_circ.compose(H_imag_circ_2, list(range(n_qubits+1)))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Execute using a quantum primitive" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instantiate the backend and set runtime parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "service = QiskitRuntimeService()\n", + "backend = service.least_busy(operational=True, simulator=True)\n", + "shots = 100000\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Execute circuits for $\\tilde{S}$ with the Estimator" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "estimator = Estimator(backend=backend)\n", + "\n", + "# Define a set of observables to measure\n", + "observable = 'I'*(n_qubits) + 'Z'\n", + "observables = [observable]\n", + "\n", + "# Define a sweep over parameter values\n", + "params = np.vstack(parameters).T\n", + "\n", + "# Estimate the expectation value for all combinations of\n", + "# observables and parameter values, where the pub result will have\n", + "# shape (# observables, # parameter values).\n", + "pub = (S_real_circ, observables, params)\n", + "job = estimator.run([pub], precision=1/np.sqrt(shots))\n", + "S_real_results = job.result()[0]\n", + "\n", + "pub = (S_imag_circ, observables, params)\n", + "job = estimator.run([pub], precision=1/np.sqrt(shots))\n", + "S_imag_results = job.result()[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And for $\\tilde{H}$" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "estimator = Estimator(backend=backend)\n", + "\n", + "# Define a set of observables to measure\n", + "observables = observable_list\n", + "\n", + "# Define a sweep over parameter values\n", + "params = np.vstack(parameters).T\n", + "\n", + "# Estimate the expectation value for all combinations of\n", + "# observables and parameter values, where the pub result will have\n", + "# shape (# observables, # parameter values).\n", + "pub = (H_real_circ, observables, params)\n", + "job = estimator.run([pub], precision=1/np.sqrt(shots))\n", + "H_real_results = job.result()[0]\n", + "\n", + "pub = (H_imag_circ, observables, params)\n", + "job = estimator.run([pub], precision=1/np.sqrt(shots))\n", + "H_imag_results = job.result()[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Post-process and analyze results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once we have the results of the circuit executions we can post-process the data to calculate the matrix elements of $\\tilde{S}$" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "S_circ = np.zeros((krylov_dim, krylov_dim), dtype=complex)\n", + "count = 0\n", + "for idx_ket in range(krylov_dim):\n", + " for idx_bra in range(idx_ket + 1):\n", + "\n", + " # Get expectation values from experiment\n", + " expval_real = S_real_results.data.evs[0][count]\n", + " expval_imag = S_imag_results.data.evs[0][count]\n", + "\n", + " # Get expectation values\n", + " expval = expval_real + 1j*expval_imag\n", + "\n", + " # Fill-in matrix elements\n", + " S_circ[idx_bra, idx_ket] = expval\n", + " S_circ[idx_ket, idx_bra] = expval.conjugate()\n", + "\n", + " count+=1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And the matrix elements of $\\tilde{H}$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "H_eff_circ = np.zeros((krylov_dim, krylov_dim), dtype=complex)\n", + "for obs_idx, (pauli, coeff) in enumerate(zip(H_op.paulis, H_op.coeffs)):\n", + " count = 0\n", + " for idx_ket in range(krylov_dim):\n", + " for idx_bra in range(idx_ket + 1):\n", + " # Get expectation values from experiment\n", + " expval_real = H_real_results.data.evs[obs_idx][count]\n", + " expval_imag = H_imag_results.data.evs[obs_idx][count]\n", + " \n", + "\n", + " # # Get expectation values\n", + " expval = expval_real + 1j*expval_imag\n", + "\n", + "\n", + " # Fill-in matrix elements\n", + " H_eff_circ[idx_bra, idx_ket] += coeff*expval\n", + " if idx_bra != idx_ket: # don't duplicate terms on diagonal\n", + " H_eff_circ[idx_ket, idx_bra] += (coeff*expval).conjugate()\n", + "\n", + "\n", + " count+=1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can solve the generalized eigenvalue problem for $\\tilde{H}$:\n", + "\n", + "$$\\tilde{H} \\vec{c} = c \\tilde{S} \\vec{c}$$\n", + "\n", + "and get an estimate of the ground state energy $c_{min}$" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The estimated ground state energy is: 8.99848\n", + "The estimated ground state energy is: 0.7937378945206248\n", + "The estimated ground state energy is: 1.580148146997832\n", + "The estimated ground state energy is: -2.1358877293150162\n", + "The estimated ground state energy is: -2.868380302510151\n", + "The estimated ground state energy is: -4.308984388844685\n", + "The estimated ground state energy is: -4.908392116269306\n", + "The estimated ground state energy is: -5.049516981337282\n", + "The estimated ground state energy is: -6.7678700851175435\n", + "The estimated ground state energy is: -6.325887605573247\n", + "The estimated ground state energy is: -6.8959604780066766\n", + "The estimated ground state energy is: -8.385726072961965\n", + "The estimated ground state energy is: -8.42929808324567\n", + "The estimated ground state energy is: -6.885616460863645\n", + "The estimated ground state energy is: -9.267911300984151\n", + "The estimated ground state energy is: -9.17835339754369\n", + "The estimated ground state energy is: -8.594949712338924\n", + "The estimated ground state energy is: -8.389182678819786\n", + "The estimated ground state energy is: -8.238216318473675\n", + "The estimated ground state energy is: -8.674016660826856\n" + ] + } + ], + "source": [ + "gnd_en_circ_est_list = []\n", + "for d in range(1, krylov_dim+1):\n", + " # Solve generalized eigenvalue problem\n", + " gnd_en_circ_est = solve_regularized_gen_eig(H_eff_circ[:d, :d], S_circ[:d, :d], threshold=1e-2)\n", + " gnd_en_circ_est_list.append(gnd_en_circ_est)\n", + " print('The estimated ground state energy is: ', gnd_en_circ_est)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(range(1, krylov_dim+1), gnd_en_circ_est_list, color = 'blue', linestyle='-.' , label = 'estimate')\n", + "plt.xticks(range(1, krylov_dim+1), range(1, krylov_dim+1))\n", + "plt.legend()\n", + "plt.xlabel('Krylov space dimension')\n", + "plt.ylabel('Energy')\n", + "plt.title('Estimating Ground state energy with Quantum Krylov')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}