{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Fermion to qubit transformations\n", "\n", "In this tutorial you will learn more about fermion to qubit transformations, including how to apply those already implemented in openfermion, and try your hand at constructing your own!\n", "\n", "1. Fermions and Qubits\n", " 1. Fermionic states\n", " 1. Fermionic operators and commutation relations\n", "1. The Jordan-Wigner transform\n", " 1. Jordan-Wigner transformation in OpenFermion\n", " 1. Locality scaling under Jordan-Wigner\n", " 1. Quadratic and quartic operator transforms\n", "1. The Bravyi-Kitaev transform\n", " 1. Occupation number and parity representations\n", " 1. The transformation\n", " 1. Locality scaling\n", "1. The JKMN transform\n", " 1. Majorana representation of Fermionic operators\n", " 1. The ternary tree construction\n", " 1. Locality scaling\n", "1. Final notes and caveats\n", " 1. Geometric locality: another point of view\n", " 1. Ancillas to go \"beyond optimal\" scaling" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Fermions and Qubits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Fermionic states\n", "\n", "As we saw during the lecture, states of a second-quantized fermionic system can be connected quite naturally to states of a qubit register.\n", "In a fermionic system with $n$ modes (i.e. sites or orbitals), each mode can be either empty or filled, giving rise to $2^n$ basis states. These take the form $\\vert f_0, f_1, ..., f_n\\rangle$, with $f_j\\in\\{0 : \\mathrm{empty}, 1 : \\mathrm{filled}\\}$.\n", "The filling state of each mode can be represented by a qubit.\n", "OpenFermion takes the following convention in representing the state of a Fermionic Mode:\n", "- empty state : $\\begin{pmatrix}1 \\\\ 0\\end{pmatrix}$ — same representation as the $\\vert0\\rangle$ qubit state,\n", "- filled state : $\\begin{pmatrix}0 \\\\ 1\\end{pmatrix}$ — same representation as the $\\vert1\\rangle$ qubit state.\n", "\n", "The vector representation of multi-mode fermionic states is built from the single-mode states with kronecker products, the same way as for multi-qubit systems.\n", "\n", "#### Fermionic operators and commutation relations\n", "\n", "Under this convention, the **single-mode** creation and annihilation operators act like simple raising and lowering matrices on these vectors:" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T12:59:41.099337Z", "start_time": "2020-04-16T12:59:41.089363Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "creation operator:\n", " [[0.+0.j 0.+0.j]\n", " [1.+0.j 0.+0.j]] \n", "\n", "annihilation operator:\n", " [[0.+0.j 1.+0.j]\n", " [0.+0.j 0.+0.j]]\n" ] } ], "source": [ "from openfermion import FermionOperator, get_sparse_operator\n", "\n", "creation = FermionOperator('0^')\n", "annihilation = FermionOperator('0')\n", "\n", "print('creation operator:\\n', get_sparse_operator(creation).A, '\\n')\n", "print('annihilation operator:\\n', get_sparse_operator(annihilation).A)" ] }, { "cell_type": "markdown", "metadata": { "ExecuteTime": { "end_time": "2020-04-08T16:24:00.886227Z", "start_time": "2020-04-08T16:24:00.881637Z" } }, "source": [ "Such $2 \\times 2$ matrices can easily be constructed by linear combinations of Pauli matrices.\n", "$$\n", " c^\\dagger \\to \\frac{\\sigma_x - i \\sigma_y}{2} \n", " \\quad , \\qquad \n", " c \\to \\frac{\\sigma_x + i \\sigma_y}{2}\n", "$$\n", "\n", "Unfortunately, constructing the representation of fermionic operators in a **multi-mode** system is more complicated than taking a kronecker product of such matrices.\n", "This is because fermionic operators acting on different modes **anticommute**, while qubit operators acting on different qubits **commute**.\n", "\n", "**Exercise 1:** Construct the QubitOperators corresponding to the single-mode $c$ and $c^\\dagger$ and verify their commutation relations. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-04-17T14:12:24.353199Z", "start_time": "2020-04-17T14:12:23.583531Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "com : (1+0j) [Z0]\n", "acom : (1+0j) []\n" ] } ], "source": [ "from openfermion import QubitOperator\n", "def com(A, B): return A*B - B*A\n", "def acom(A, B): return A*B + B*A\n", "\n", "c = QubitOperator('X0', 0.5) + QubitOperator('Y0', 0.5j) \n", "cdag = QubitOperator('X0', 0.5) + QubitOperator('Y0', -0.5j) \n", "\n", "print('com : ', com(c, cdag))\n", "print('acom : ', acom(c, cdag))" ] }, { "cell_type": "markdown", "metadata": { "ExecuteTime": { "end_time": "2020-04-08T16:24:00.886227Z", "start_time": "2020-04-08T16:24:00.881637Z" } }, "source": [ "**Exercise 2:** Convince yourself that QubitOperators acting on different qubits commute, while fermionic creation/annihilation operators on different modes *anti*commute." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# The Jordan-WIgner transform\n", "\n", "The Jordan-Wigner transformation is arguably the simplest method to map fermionic operators to qubit operators while conserving commutation relations.\n", "\n", "To reconstruct the correct commutation relations, the Jordan-Wigner transformation attaches to each fermionic operator at site $k$ a sign $\\{+, -\\}$, depending on the **parity** of the number of fermions in the first $k-1$ modes: $P(k) = (-1)^{\\sum_{j=0}^{k-1} f_j}$. \n", "A creation (or annihilation) operator $c^\\dagger_j$ changing the state of a $f_j$, will also change the parity $P(k)$ for $k>j$. This changes the sign carried over by any operator on the mode $k$ applied **after** $c^\\dagger_j$, making the overall sign depend on the order of operators.\n", "\n", "For the separable basis states $\\vert f_0\\rangle \\otimes \\vert f_1\\rangle \\otimes ... \\otimes \\vert f_n\\rangle$ the action of the creation operator is defined as\n", "$$\n", " c^\\dagger_k \\vert f_0\\rangle \\otimes ... \\otimes \\vert f_k \\rangle \\otimes ... \\otimes \\vert f_n\\rangle =\n", " (-1)^{\\sum_{j=0}^{k-1} f_j} \\vert f_0\\rangle \\otimes ... \\otimes \\left(c^\\dagger_k \\vert f_k \\rangle\\right) \\otimes ... \\otimes \\vert f_n\\rangle,\n", "$$\n", "where the action of $\\left(c^\\dagger_k \\vert f_k \\rangle\\right)$ is the one defined above for the single mode.\n", "Defining the action on basis states is enough to describe an operator (extending to other states by linearity).\n", "\n", "The parity $P(k)$ can be calculated by a string of Pauli Z operators $Z_0\\,Z_1\\,...\\,Z_{k-1}$ (called Jordan-Wigner string), as each $Z_j$ takes the value $-1$ when a state is filled $\\vert f_j=1 \\rangle$ and $+1$ otherwise.\n", "This brings us to the definition of the Jordan-Wigner transform:\n", "\\begin{equation}\n", " c^\\dagger_k \\to Z_0\\,...\\,Z_{k-1} \\frac{X_k - i Y_k}{2} \\\\\n", " c_k \\to Z_0\\,...\\,Z_{k-1} \\frac{X_k + i Y_k}{2} \n", " \\label{eq:JW} \\tag{1}\n", "\\end{equation}\n", "\n", "\n", "### Jordan-Wigner transformation in OpenFermion\n", "\n", "Fermion to qubit transformations are core elements of OpenFermion. They can be found in the module `openfermion.transforms`. Let's have a look at the `jordan_wigner` function:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T13:13:47.781358Z", "start_time": "2020-04-16T13:13:47.401672Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function jordan_wigner in module openfermion.transforms._jordan_wigner:\n", "\n", "jordan_wigner(operator)\n", " Apply the Jordan-Wigner transform to a FermionOperator,\n", " InteractionOperator, or DiagonalCoulombHamiltonian to convert\n", " to a QubitOperator.\n", " \n", " Operators are mapped as follows:\n", " a_j^\\dagger -> Z_0 .. Z_{j-1} (X_j - iY_j) / 2\n", " a_j -> Z_0 .. Z_{j-1} (X_j + iY_j) / 2\n", " \n", " Returns:\n", " transformed_operator: An instance of the QubitOperator class.\n", " \n", " Warning:\n", " The runtime of this method is exponential in the maximum locality\n", " of the original FermionOperator.\n", " \n", " Raises:\n", " TypeError: Operator must be a FermionOperator,\n", " DiagonalCoulombHamiltonian, or InteractionOperator.\n", "\n" ] } ], "source": [ "from openfermion.transforms import jordan_wigner\n", "help(jordan_wigner)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 3:** construct the the QubitOperators corresponding to fermionic creation and annihilation operators under Jordan-Wigner transform, and verify they satisfy fermionic commutation relations. (you can compare with exercise 3 of the \"Introduction to OpenFermion\" tutorial)" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T13:28:36.717681Z", "start_time": "2020-04-16T13:28:36.661316Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "acom(1.0 [0] , 1.0 [0^]) = 1.0 []\n", "acom after JW transform : (1+0j) []\n", "\n", "acom(1.0 [0] , 1.0 [1] ) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0] , 1.0 [1^]) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0] , 1.0 [2] ) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0] , 1.0 [2^]) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0^], 1.0 [1] ) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0^], 1.0 [1^]) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0^], 1.0 [2] ) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [0^], 1.0 [2^]) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [1] , 1.0 [1^]) = 1.0 []\n", "acom after JW transform : (1+0j) []\n", "\n", "acom(1.0 [1] , 1.0 [2] ) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [1] , 1.0 [2^]) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [1^], 1.0 [2] ) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [1^], 1.0 [2^]) = 0\n", "acom after JW transform : 0\n", "\n", "acom(1.0 [2] , 1.0 [2^]) = 1.0 []\n", "acom after JW transform : (1+0j) []\n", "\n" ] } ], "source": [ "from openfermion import FermionOperator, normal_ordered\n", "from itertools import combinations\n", "from _jkmn import inline\n", "\n", "n = 3\n", "fops = []\n", "for idx in range(n):\n", " fops.append( FermionOperator((idx, 0),) )\n", " fops.append( FermionOperator((idx, 1),) )\n", "\n", "for A, B in combinations(fops, 2):\n", " print(f'acom({str(A):8}, {str(B):8}) =', normal_ordered(acom(A, B)))\n", " print('acom after JW transform :', acom(jordan_wigner(A), jordan_wigner(B)))\n", " print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Locality scaling under Jordan-Wigner\n", "\n", "We define **locality** (or many-body order) of an operator the maximum number of modes or of qubits on which the operator acts non-trivially at the same time. In openfermion we can access this value by the `many_body_order()` method of the FermionOperator and QubitOperator classes.\n", "We say an operator is **k-local** if its locality is at most $k$.\n", "\n", "The Jordan-Wigner maps a FermionOperator acting on a single mode (1-local) to a QubitOperator acting on many qubits. In fact, every $c_k$ acts nontrivially on the first $k$ qubits (k-local).\n", "\n", "**Exercise 4:** compute the average locality of all Jordan-Wigner transformed single-qubit operators in a n-mode system. Verify that this result is what you would expect." ] }, { "cell_type": "code", "execution_count": 127, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T11:59:13.518928Z", "start_time": "2020-04-15T11:59:13.510287Z" }, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "N -> avg locality\n", "2 -> 1.5\n", "3 -> 2.0\n", "4 -> 2.5\n", "5 -> 3.0\n", "6 -> 3.5\n", "7 -> 4.0\n", "8 -> 4.5\n", "9 -> 5.0\n" ] } ], "source": [ "from openfermion import FermionOperator\n", "\n", "print('N -> avg locality')\n", "for N in range(2, 10):\n", " print(N, '->', \n", " np.average(list(jordan_wigner(FermionOperator(str(i))).many_body_order() \n", " for i in range(N)))\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wehat you just verified shows that Jordan-Wigner transform does not preserve locality. A generic $k-$local fermionic operator will be transformed into a qubit operator which locality depends on the system size. \n", "This is a general property of fermion to qubit transformations, and gives rise to one of the major challenges in simulating fermionic problems on a quantum computer.\n", "When simulating the evolution of a system, this implies we will need to implement operations on a number of qubits that gets larger with increasing system size.\n", "\n", "### Quadratic and quartic operator transforms \n", "\n", "Hamiltonians relevant for the electronic structure problem consist of terms that are quadratic (i.e. 2-local: site energies and hoppings) and quartic (i.e. 4-local: Coulomb interactions). These can all be written in normal-ordered form:\n", "- $ c^\\dagger_i c_j \\quad \\forall \\, i, j $\n", "- $ c^\\dagger_i c^\\dagger_j c_k c_l \\quad \\forall \\, i>j; k>l $\n", "\n", "**Exercise 5:** construct all quadratic particle-conserving operator terms for an $n$-mode fermionic system, transform them with Jordan-Wigner and calculate the average locality of the resulting QubitOperator. Do the same for quartic operators. Plot the results and infer the scaling of the average locality with the system size $n$." ] }, { "cell_type": "code", "execution_count": 131, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:23:27.807764Z", "start_time": "2020-04-16T15:23:27.798528Z" }, "code_folding": [] }, "outputs": [], "source": [ "def single_avg_loc(n):\n", " fops = (FermionOperator(f'{i}') for i in range(n)) # generator\n", " qops = (jordan_wigner(fop) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)\n", "\n", "def quadratic_avg_loc(n):\n", " fops = (FermionOperator(f'{i}^ {j}') for i in range(n) for j in range(n)) # generator\n", " qops = (jordan_wigner(fop) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)\n", "\n", "def quartic_avg_loc(n):\n", " fops = (FermionOperator(f'{i}^ {j}^ {k} {l}') \n", " for i in range(n) for j in range(i) for k in range(n) for l in range(k)\n", " ) # generator\n", " qops = (jordan_wigner(fop) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)" ] }, { "cell_type": "code", "execution_count": 132, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:23:28.664476Z", "start_time": "2020-04-16T15:23:28.661678Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:24:36.675631Z", "start_time": "2020-04-16T15:23:29.678658Z" } }, "outputs": [], "source": [ "n_list = np.arange(2, 20)\n", "\n", "single_locs_jw = list(single_avg_loc(n) for n in n_list)\n", "quadratic_locs_jw = list(quadratic_avg_loc(n) for n in n_list)\n", "quartic_locs_jw = list(quartic_avg_loc(n) for n in n_list)" ] }, { "cell_type": "code", "execution_count": 134, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:24:36.877493Z", "start_time": "2020-04-16T15:24:36.702482Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(n_list, single_locs_jw, label='single')\n", "plt.plot(n_list, quadratic_locs_jw, label='quadratic')\n", "plt.plot(n_list, quartic_locs_jw, label='quartic')\n", "plt.legend()\n", "plt.ylabel('avg locality')\n", "plt.xlabel('n')\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Geometric locality under Jordan-Wigner\n", "\n", "Another relevant concept in physics is **geometric locality** (not to be confused with k-locality, defined earlier!).\n", "Most phyisical systems live in a $d$-dimensional space (with $d\\leq3$), where particles interact mostly or only with neighboring ones. \n", "Typical examples of fermionic systems with geometrically local interactions are electrons in crystal lattices.\n", "Geometrically-local systems can typically be represented on a lattice, with nearest-neighbor interactions (or extensions thereof).\n", "\n", "The Jordan-Wigner transformation lets us exploit geometric locality of lattices to our advantage. \n", "If the $Z$ operator Jordan-Wigner strings of two operators $c^\\dagger_j$ and $c_k$ largely overlap, they will square and cancel in the quadratic operator $c^\\dagger_j c_k$ (similar for quartic operators, where there are two couples of fermionic operators to consider).\n", "In a lattice, only a specific set of $c^\\dagger_j c_k$ are allowed: the ones for which $j$ and $k$ index neighboring sites.\n", "Indexing sites following the geometric structure of the lattice, lets us reduce the many-body order of the resulting QubitOperators.\n", "\n", "**Exercise 6:** \n", "Construct all hopping operators $c^\\dagger_j c_{j\\pm1}$ in a fermionic $d=1$ lattice (a chain) with $n$ sites. \n", "Verify that the many-body order of the Jordan-Wigner transformed operator is constant. \n", "Now reshuffle the indices by a random permutation $j\\to\\alpha(j)$ (hoppings will now be $c^\\dagger_{\\alpha(j)}, c_{\\alpha(j\\pm1)}$ and verify you recover the linear scaling of locality of the transormed operator with $n$." ] }, { "cell_type": "code", "execution_count": 151, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:30:44.641382Z", "start_time": "2020-04-16T15:30:44.623560Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "N -> avg locality\n", "2 -> 2.0\n", "3 -> 2.0\n", "4 -> 2.0\n", "5 -> 2.0\n", "6 -> 2.0\n", "7 -> 2.0\n", "8 -> 2.0\n", "9 -> 2.0\n" ] } ], "source": [ "from openfermion import FermionOperator, jordan_wigner\n", "\n", "def avg_loc_jw_chain(n):\n", " hopping_fops = ([FermionOperator(f'{idx}^ {idx+1}') for idx in range(n-1)] +\n", " [FermionOperator(f'{idx} {idx+1}^') for idx in range(n-1)] )\n", " hopping_qops = [jordan_wigner(fop) for fop in hopping_fops]\n", " localities = [qop.many_body_order() for qop in hopping_qops ]\n", " return np.average(localities)\n", "\n", "print('N -> avg locality')\n", "for n in range(2, 10):\n", " print(n, '->', avg_loc_jw_chain(n))" ] }, { "cell_type": "code", "execution_count": 164, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:36:59.882979Z", "start_time": "2020-04-16T15:36:58.399335Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from numpy.random import permutation\n", "\n", "def avg_loc_jw_chain(n):\n", " perm = permutation(n)\n", " hopping_fops = ([FermionOperator(f'{perm[idx]}^ {perm[idx+1]}') for idx in range(n-1)] +\n", " [FermionOperator(f'{perm[idx]} {perm[idx+1]}^') for idx in range(n-1)] )\n", " hopping_qops = [jordan_wigner(fop) for fop in hopping_fops]\n", " localities = [qop.many_body_order() for qop in hopping_qops]\n", " return np.average(localities)\n", "\n", "sample_number=20\n", "\n", "n_list = np.arange(2, 20)\n", "avgs = []\n", "stds = []\n", "for n in n_list:\n", " samples = [avg_loc_jw_chain(n) for _ in range(sample_number)]\n", " avgs.append(np.average(samples))\n", " stds.append(np.std(samples))\n", "\n", "plt.errorbar(n_list, avgs, yerr=stds)\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 7:** \n", "Use the function below to generate all quadratic operators in a nearest-neighbor square lattice of side length $L$. Compute the average locality of the transformed operator as a function of the system size $L^2$, how does it scale? Think of how can you intepret the result." ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T13:48:26.087448Z", "start_time": "2020-04-16T13:48:25.479278Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " L | n | avg locality\n", " 1 | 1 | 1.0\n", " 2 | 4 | 2.0\n", " 3 | 9 | 2.4545454545454546\n", " 4 | 16 | 2.875\n", " 5 | 25 | 3.2857142857142856\n", " 6 | 36 | 3.6923076923076925\n", " 7 | 49 | 4.096774193548387\n", " 8 | 64 | 4.5\n", " 9 | 81 | 4.902439024390244\n" ] } ], "source": [ "def square_lattice_quadratic(L):\n", " from openfermion.hamiltonians import fermi_hubbard\n", " return fermi_hubbard(x_dimension=L,\n", " y_dimension=L,\n", " tunneling = -1.0, # hoppings (quadratic)\n", " coulomb = 0.0, # electrostatic interaction: change to 1.0 to get quartic terms\n", " chemical_potential = -1.0, # on-site energy (quadratic)\n", " periodic = False, # open boundary conditions\n", " spinless = True # one fermion per site\n", " ).get_operators() # returns a generator of all (quadratic) terms\n", "\n", "def avg_loc_jw_square(L):\n", " fops = square_lattice_quadratic(L)\n", " qops = [jordan_wigner(fop) for fop in fops]\n", " localities = [qop.many_body_order() for qop in qops ]\n", " return np.average(localities)\n", "\n", "print(' L | n | avg locality')\n", "for L in range(1, 10):\n", " print(f'{L:2} |{L**2:^5}|', avg_loc_jw_square(L))" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T13:45:30.654956Z", "start_time": "2020-04-16T13:45:30.652051Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T14:51:23.920537Z", "start_time": "2020-04-16T14:51:23.203193Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "L_list = np.arange(1, 10)\n", "loc_list = [avg_loc_jw_square(int(L)) for L in L_list]\n", "plt.plot(L_list, loc_list)\n", "plt.xlabel('$L = \\sqrt{n}$')\n", "plt.ylabel('average locality')\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# The Bravyi-Kitaev transform \n", "\n", "The qubit representation of fermionic operations is, in general, non-local.\n", "This is because the action of any fermionic operator depends, through commutation relations, on all previously-applied operators. \n", "Generic operations on fermions at the opposite ends of a lattice still influence each other!\n", "Nevertheless, using more complicated ways to encode fermionic states and to map fermionic operators to a qubit register, we can improve on the linear scaling of locality we found for Jordan-Wigner transformed operators, even in absence of a lattice structure.\n", "The Bravyi-Kitaev transform was the first to obtain a logarithmic scaling with $n$ of the average locality of transformed single-fermion operators.\n", "\n", "### Occupation number and parity representations\n", "\n", "To understand Bravyi-Kitaev transform, we have to realize that when we want to calculate the action of a fermionic operator $c^\\dagger_k$ on a fermionic state, two things matter:\n", "- $f_k$, the **occupation** state of the site $k$ (defining whether $c^\\dagger_k$ can actually \"succeed\" in creating a fermion, or if it will \"fail\" sending the state to $0$)\n", "- $P(k)$ the **parity** of the total number of fermions in sites $jk$ (and thus flipping all qubits $j: jk$).\n", " \n", "An in-depth explaination of the algorithm, taking a pedagogical approach, can be found in [arXiv:1208.5986](https://arxiv.org/pdf/1208.5986.pdf), from which we took inspiration in writing this tutorial. There you can find also the full (highly non trivial) definition of the Bravyi-Kitaev mapping of fermionic operators.\n", "\n", "### Locality scaling\n", "\n", "In this encoding information is stored systematically in recursive binary groupings of sites, which can be represented by a binary tree. The key feature of this is that both parity $P(k)$ and occupation number $f_k$ at site $k$ are related to the state of only $\\log_2(n)$ qubits (i.e. the depth of the binary tree).\n", "We'll try to retrieve this scaling for the average locality empirically, using the `bravyi_kitaev` function of the `openfermion.transforms` module." ] }, { "cell_type": "code", "execution_count": 231, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:01:05.138996Z", "start_time": "2020-04-16T16:01:05.135819Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function bravyi_kitaev in module openfermion.transforms._bravyi_kitaev:\n", "\n", "bravyi_kitaev(operator, n_qubits=None)\n", " Apply the Bravyi-Kitaev transform.\n", " \n", " Implementation from arXiv:quant-ph/0003137 and\n", " \"A New Data Structure for Cumulative Frequency Tables\" by Peter M. Fenwick.\n", " \n", " Note that this implementation is equivalent to the one described in\n", " arXiv:1208.5986, and is different from the one described in\n", " arXiv:1701.07072. The one described in arXiv:1701.07072 is implemented\n", " in OpenFermion as `bravyi_kitaev_tree`.\n", " \n", " Args:\n", " operator (openfermion.ops.FermionOperator):\n", " A FermionOperator to transform.\n", " n_qubits (int|None):\n", " Can force the number of qubits in the resulting operator above the\n", " number that appear in the input operator.\n", " \n", " Returns:\n", " transformed_operator: An instance of the QubitOperator class.\n", " \n", " Raises:\n", " ValueError: Invalid number of qubits specified.\n", "\n" ] } ], "source": [ "from openfermion.transforms import bravyi_kitaev\n", "help(bravyi_kitaev)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the Bravyi-Kitaev transform **needs** to know the total number of modes (or of qubits) in the system that is being transformed. Make sure to specify n_qubits when you use the `bravyi_kitaev` function.\n", "e.g. the same operator $c_0$, as part of a $n$ modes system, looks different for different $n$:" ] }, { "cell_type": "code", "execution_count": 232, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:01:06.939614Z", "start_time": "2020-04-16T16:01:06.932571Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Example: in a 4-modes system FermionOperators are mapped according to:\n", "0 -> 0.5 [X0 X1 X3] + 0.5j [Y0 X1 X3]\n", "0^ -> 0.5 [X0 X1 X3] + -0.5j [Y0 X1 X3]\n", "1 -> 0.5 [Z0 X1 X3] + 0.5j [Y1 X3]\n", "1^ -> 0.5 [Z0 X1 X3] + -0.5j [Y1 X3]\n", "2 -> 0.5 [Z1 X2 X3] + 0.5j [Z1 Y2 X3]\n", "2^ -> 0.5 [Z1 X2 X3] + -0.5j [Z1 Y2 X3]\n", "3 -> 0.5 [Z1 Z2 X3] + 0.5j [Y3]\n", "3^ -> 0.5 [Z1 Z2 X3] + -0.5j [Y3]\n" ] } ], "source": [ "n = 4 # Explore how this changes with n!\n", "print(f'Example: in a {n}-modes system FermionOperators are mapped according to:')\n", "for i in range(n):\n", " print(f'{i} ->', str(bravyi_kitaev(FermionOperator(f'{i}'), n_qubits=n)).replace('\\n', ' '))\n", " print(f'{i}^ ->', str(bravyi_kitaev(FermionOperator(f'{i}^'), n_qubits=n)).replace('\\n', ' '))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 9:** Repeat the study did in exercises 4 and 5, this time using the Bravyi-Kitaev transform. Plot results in a log-lin graph, and verify the $\\log_2(n)$ scaling of the average locality for transformed single, quadratic and quartic fermionic operators." ] }, { "cell_type": "code", "execution_count": 233, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:01:08.118654Z", "start_time": "2020-04-16T16:01:08.110574Z" }, "code_folding": [] }, "outputs": [], "source": [ "def single_avg_loc(n):\n", " fops = (FermionOperator(f'{i}') for i in range(n)) # generator\n", " qops = (bravyi_kitaev(fop, n) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)\n", "\n", "def quadratic_avg_loc(n):\n", " fops = (FermionOperator(f'{i}^ {j}') for i in range(n) for j in range(n)) # generator\n", " qops = (bravyi_kitaev(fop, n) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)\n", "\n", "def quartic_avg_loc(n):\n", " fops = (FermionOperator(f'{i}^ {j}^ {k} {l}') \n", " for i in range(n) for j in range(i) for k in range(n) for l in range(k)\n", " ) # generator\n", " qops = (bravyi_kitaev(fop, n) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)" ] }, { "cell_type": "code", "execution_count": 234, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:01:09.019549Z", "start_time": "2020-04-16T16:01:09.015746Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 240, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:02:34.889312Z", "start_time": "2020-04-16T16:02:03.586112Z" } }, "outputs": [], "source": [ "n_list = np.arange(2, 20)\n", "single_locs_bk = list(single_avg_loc(n) for n in n_list)\n", "quadratic_locs_bk = list(quadratic_avg_loc(n) for n in n_list)\n", "quartic_locs_bk = list(quartic_avg_loc(n) for n in n_list)" ] }, { "cell_type": "code", "execution_count": 241, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:02:35.190730Z", "start_time": "2020-04-16T16:02:34.917764Z" }, "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(n_list, single_locs_bk, 'o-', label='single')\n", "plt.plot(n_list, quadratic_locs_bk, 'o-', label='quadratic')\n", "plt.plot(n_list, quartic_locs_bk, 'o-', label='quartic')\n", "plt.legend()\n", "plt.ylabel('avg locality')\n", "plt.xlabel('n')\n", "plt.xscale('log')\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The Bravyi-Kitaev transform restructures the geometry of the system to achieve logarithmic locality for a generic transformed operator.\n", "In doing so, it loses the advantage that Jordan-Wigner transform could get in geometrically-local systems.\n", "\n", "**Exercise 10:** Repeat the analysis for $d=1$ and $d=2$ lattices from exercises 6 and 7, using the Bravyi-Kitaev transform. Find the scaling of the average locality with $n$, compare it with results from exercise 9 and argue wether geometric locality gives a gain in this case, and how it compares to the advantage gained in the Jordan-Wigner case." ] }, { "cell_type": "code", "execution_count": 238, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:01:51.858025Z", "start_time": "2020-04-16T16:01:47.634984Z" } }, "outputs": [], "source": [ "from openfermion import FermionOperator, jordan_wigner\n", "from itertools import combinations\n", "\n", "def avg_loc_bk_generic(n):\n", " hopping_fops = ([FermionOperator(f'{idx1}^ {idx2}') for idx1, idx2 in combinations(range(n),2)]+\n", " [FermionOperator(f'{idx2}^ {idx1}') for idx1, idx2 in combinations(range(n),2)])\n", " hopping_qops = [bravyi_kitaev(fop, n) for fop in hopping_fops]\n", " localities = [qop.many_body_order() for qop in hopping_qops ]\n", " return np.average(localities)\n", "\n", "def avg_loc_bk_chain(n):\n", " hopping_fops = ([FermionOperator(f'{idx}^ {idx+1}') for idx in range(n-1)] +\n", " [FermionOperator(f'{idx} {idx+1}^') for idx in range(n-1)] )\n", " hopping_qops = [bravyi_kitaev(fop, n) for fop in hopping_fops]\n", " localities = [qop.many_body_order() for qop in hopping_qops ]\n", " return np.average(localities)\n", "\n", "def avg_loc_bk_square(L):\n", " fops = square_lattice_quadratic(L)\n", " qops = [bravyi_kitaev(fop, L**2) for fop in fops]\n", " localities = [qop.many_body_order() for qop in qops ]\n", " return np.average(localities)\n", "\n", "n_list = np.arange(2, 50)\n", "L_list = np.arange(1, 8)\n", "generic_locs_bk = [avg_loc_bk_generic(n) for n in n_list]\n", "chain_locs_bk = [avg_loc_bk_chain(n) for n in n_list]\n", "square_locs_bk = [avg_loc_bk_square(int(L)) for L in L_list]" ] }, { "cell_type": "code", "execution_count": 239, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:01:54.140071Z", "start_time": "2020-04-16T16:01:53.834156Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEOCAYAAACKDawAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl4lNXZ+PHvmclkIyFhTUhYI2FfQ1gEhSAEVBBR1NaKre1bsdoq2qqV2iKv1lqrXbC/tr6+fdVarYoIWEUlQQiWTQ37FkgghJAESICETBYymTm/PyYJWSbJJOTJzCT357q4wjzzLGfw8Z6T+znnPkprjRBCiI7P5OkGCCGEaB8S8IUQopOQgC+EEJ2EBHwhhOgkJOALIUQnIQFfCCE6CQn4QgjRSUjAF0KITkICvhBCdBIS8IUQopPw83QDauvZs6ceOHBgq44tKSmhS5cubdsgITxE7mfhrl27dhVorXu5s69XBfyBAweSmpraqmNTUlJISEho2wYJ4SFyPwt3KaWy3N3X0JSOUmqpUuqgUuqQUupRI68lhBCiaYYFfKXUKOB+YBIwFpivlIo16npCCCGaZmQPfziwU2tdqrWuBLYAtxl4PSGEEE0wMod/EHheKdUDKANuBlqcoLfZbJw+fZry8vIm9wsLC+PIkSOtaqgvCwwMpG/fvlgsFk83RQjh5QwL+FrrI0qpF4FkwArsAyrr76eUWgIsAYiIiCAlJaXO+yEhIURERBAdHY1SqtHr2e12zGZz230AH6C1pqioiH379mG1Wj3dHNGGrFZrg/8XRMeyPdfGh8dsnC/X9AhULBpiYWqUsR031V4rXimlfgOc1lr/tbF94uPjdf1ROkeOHGHYsGFNBnuA4uJiQkND26StvkRrTVpaGsOHD/d0U0QbklE6Hdu6PTksW3OAMpu9ZluQxcwLt49m4fjoFp1LKbVLax3vzr5Gj9LpXfWzP3A78G4rz9OWzepQ5N9GCN/z0oajdYI9QJnNzop/HzL0ukbPtP1QKXUY+Bj4sdb6osHX6xBuvvlmCgsLPd0MIYRBcgvLXG4vLLOxbk+OYdc1dOKV1vp6I8/vyro9Oby04Si5hWVEhQfxxNyhLf4VyVO01mit+fTTTz3dFCGEgaLCg8hpJOi/tOGoYTGrQ9XSqc6L5RSWoYGcwjKWrTlw1d+Yzz33HMOGDSMxMZG7776bl19+mePHj3PjjTcyYcIErr/+etLS0gC47777eOSRR5g6dSoxMTGsXr265jwvvfQSEydOZMyYMTzzzDMAnDx5kuHDh/PQQw8RFxdHdnY2AwcOpKCgAIC33nqLMWPGMHbsWO69996r+hxCCO/wxNyhjb7XWO+/LXhVaYXm/PfHhzice8nle3a7nf05xVTYHXW2l9nsPLl6P+9+fcrlcSOiuvLMLSMbvWZqaioffvghe/bsobKykri4OCZMmMCSJUt49dVXiY2N5auvvuKhhx5i06ZNAOTl5bF161bS0tJYsGABd9xxB0lJSaSnp/P111+jtWbBggV8+eWX9O/fn6NHj/LGG2/w17/WfZ596NAhnn/+ebZt20bPnj25cOFCS/65hBBeauH4aJ5YvQ+bveGgmajwIMOu61MBvzn1g31z292xdetWbr31VoKCnP8RbrnlFsrLy9m+fTt33nlnzX6XL1+u+fvChQsxmUyMGDGCs2fPApCUlERSUhLjx48HnMPu0tPT6d+/PwMGDGDKlCkNrr1p0ybuuOMOevbsCUD37t1b/TmEEN6lT1ggpy+W4agV84Ms5iZ7/1fLpwJ+Uz3x4uJibvzLNy7zYtHhQbz/wLWtuqarYasOh4Pw8HD27t3r8piAgIAGx2utWbZsGQ888ECdfU+ePNloVUSttYzCEaKDKi6vZHJMd06dL2u3Z44dKof/xNyhBFnqTr662m/M6667jo8//pjy8nKsVivr168nODiYQYMG8cEHHwDOwLxv374mzzN37lxef/31mglSOTk5nDt3rsljZs2axapVqzh//jyApHSE6CCKSm1cLLUxc2hvtj11A5m/nce2p24wfICJT/Xwm1P9j9WWo3QmTpzIggULGDt2LAMGDCA+Pp6wsDDeeecdHnzwQX79619js9n49re/zdixYxs9z5w5czhy5AjXXuv8TSMkJIS33367ydnBI0eO5Omnn2bGjBmYzWbGjx/Pm2++2erPIoTwDlkXSgAY0KN91zxot5m27mhspq07s0iNnGlrtVoJCQmhtLSU6dOn89prrxEXF2fItVrD3X8j4Ttkpm3H9u99uTzy7h42PDqdoZFXF7e8ZqZtR7FkyRLGjRtHXFwcixYt8qpgL4TwLev25PDLtQcA+P4bXxs60aq+DpXSMcq//vUvTzdBCOHj1u3JYcW/D1FYZqvZlltUzrI1zuDfHhNEJeALIYRBXAX5+spsdkNn19YmAV8IIQywbk8OT3ywD5uj+eekRs6urU1y+EIIYYCXNhx1K9iDsbNra5OAL4QQBnC312707NraJKXTCvfddx/z58/njjvucPuYqVOnsn37dgNbJYRob/Wr884c1ovNafmNVsKsr1uwhWduGdluFX07XsDfvwq+eBaKTkNYX5i1HMbc5elWSbAXooOpv2pVTmEZb+90XaSxvvYO9NU6Vkpn/yr4+BEoyga08+fHjzi3XwVXJYq//PLLBiWQrVYrs2bNIi4ujtGjR/PRRx/VnCMkJAS4MqHmjjvuYNiwYdxzzz0u6/UIIbybq1WrmtMt2MKfvjWOPcvneGSdDkN7+Eqpx4AfAho4AHxfa13e6hN+9hScOeDyrSB7JeTtAfvlum/YyuCjn8Cuf7g+Z+RouOm3jV7SVYnin/70py5LIAcGBrJ27Vq6du1KQUEBU6ZMYcGCBQ0KoO3Zs4dDhw4RFRXFtGnT2LZtG9ddd12L/imEEJ7V0pE1CtizfI4xjXGTYT18pVQ08AgQr7UeBZiBbxt1PaBhsG9uuxsaK1HsqgSy1ppf/OIXjBkzhtmzZ5OTk1PzXm2TJk2ib9++mEwmxo0bx8mTJ1vdPiGEZ7R0ZE17jcRpitE5fD8gSCllA4KB3Ks6WxM98bLiYkL/fm1VOqeesH7w/fWtumRjJYpdlUB+5513yM/PZ9euXVgsFgYOHEh5ecNfaGofazabqaysbFXbhBCe88TcoTy1Zj/ltubX22jPkThNMayHr7XOAV4GTgF5QJHWOsmo6wHOB7SWet+iliDn9taesgUliouKiujduzcWi4XNmzeTlZXV6usKIbzbwvHR/DhhcKPvm6r6idHhQbxw+2ivWFvbsB6+UqobcCswCCgEPlBKLdZav11vvyXAEoCIiAhSUlLqnCcsLIzi4uJmr2e32ykedBN+ib8j4D+/RRXnokOjuHz9U1QOugncOIcr/fv356c//SnXX389ZrOZMWPGAFBWVlanXcXFxdx6663cddddNQ9thwwZgtVqrdmvuLiY0tJSKisra7ZVVFRQXl7u1mdsTHl5eYN/N+HbrFar/Df1AWdOO0smfGeYhQ0nKzlfrukRqFg0xMLUKMuVHYvSSUlJ91ArrzCsPLJS6k7gRq31f1W9/i4wRWv9UGPHeGt5ZG8n5ZE7HimP7BsefncPqScvsGPZLI+1wVvKI58CpiilgpUzCT4LOGLg9YQQol2s25PDtN9u4uN9uRSWVrRrieOrYVhKR2v9lVJqNbAbqAT2AK8ZdT0hhDCaq+qXZTZHu5Y4vhqGTrzSWj+jtR6mtR6ltb5Xa9368ZFCCOFB1TNrXZU6ri5x7O06XmkFIYRoI9W1ctypjdNeJY6vhgR8IYRwoX6tnOZ4w8Sq5nSsWjpCCNFGWlIrx1smVjVHevhCCOGCuykaT1W+bI0OF/DXn1jPyt0rOVNyhsgukSyNW8q8mHmebpZb7HY7ZrPZ080QQuBM0TSVuzcrxe/vGusTgb5ah0rprD+xnhXbV5BXkodGk1eSx4rtK1h/onV1dABKSkqYN28eY8eOZdSoUbz//vt8/vnnDBs2jOuuu45HHnmE+fPnA7BixQpefvnlmmNHjRpVUxht4cKFTJgwgZEjR/Laa1dGp4aEhLB8+XImT57Mjh072LVrFzNmzGDChAnMnTuXvLy8VrddCNEy1ePrBz61vskefpDF7HPBHnysh//i1y+SdiHN5Xt2u51DFw5R4aios73cXs7ybctZfWy1y+OGdR/Gzyf9vNFrfv7550RFRbF+vfNLo6ioiFGjRrFp0yYGDx7Mt771Lbfa/vrrr9O9e3fKysqYOHEiixYtokePHpSUlDBq1CieffZZbDYbM2bM4KOPPqJXr168//77PP3007z++utuXUMI0Xr1H9LWr0FgUuDQzto4T8wd6nPBHnws4DenfrBvbrs7Ro8ezeOPP87Pf/5z5s+fT2hoKIMGDSI2NhaAxYsX1+mxN+aVV15h7dq1AGRnZ5Oenk6PHj0wm80sWrQIgKNHj3Lw4EESExMB55dYnz59Wt12IURdtZckDAuyoBRcLLVhVgp7M2Vm+oQFse2pG9qppcbwqYDfVE+8uLiYRRsWkVfSMAXSp0sf3rjxjVZdc8iQIezatYtPP/2UZcuWMWfOHJflkgH8/PxwOK6USq0ujZySksLGjRvZsWMHwcHBJCQk1LwXGBhYk7fXWjNy5Eh27NjRqrYKIVxzNUO29t+bC/bgG+Psm9OhcvhL45YSaA6ssy3QHMjSuKWtPmdubi7BwcEsXryYxx9/nO3bt5OZmcnx48cBePfdd2v2HThwILt37wZg9+7dZGZmAs40ULdu3QgODiYtLY2dO3e6vNbQoUPJz8+vCfg2m41Dhw61uu1CdDbVOfhBT61n2m83sW5PTpMzZFvCF8bZN8enevjNqR6N05ajdA4cOMATTzyByWTCYrHwt7/9jYKCAubNm0fPnj257rrrOHjwIACLFi3irbfeYty4cUycOJEhQ4YAcOONN/Lqq68yZswYhg4dypQpU1xey9/fn9WrV/PII49QVFREZWUljz76KCNHjmx1+4XoLFwtKv7Y+3sb5OJbw1fG2TenQwV8cAb9thyGOXfuXObOndtge1qa8+FxSkpKTcAPCgoiKcn1Gi+fffaZy+1Wq7XO63HjxvHll19eTZOF6JRcTZS6mmBfndf35Ye09XW4gC+E6JzaKsceZDF7zQpVba1D5fA9ISEhgU8++cTTzRCi02tpjj3YYqJbsHNVKnPVQAxvWo7QCNLDF0J0CE/MHcrPVu1rdsRNR0rRtJRPBHytdaNDITs7o5aoFMIb1B43H1UvUNcfU+/QGrvWKJy5++qf1TpyqsZdRi5iPhR4v9amGGC51vpPLTlPYGAg58+fp0ePHhL069Fac/78eQIDA5vfWQgf42rUTfXKUkCd92oPudQ4g/uiCdFsTst3+WXRWRm5xOFRYByAUsoM5ABrW3qevn37cvr0afLz85vcr7y8vFMGvsDAQPr27evpZgjR5lyNuimz2d1K25TZ7GxOy/f5mbFtrb1SOrOA41rrrJYeaLFYGDRoULP7paSkMH78+Na0TQjhhRobdePOrNimju/M2muUzreBd5vdSwghqlztzNaOMDO2rSmjH/oppfyBXGCk1vqsi/eXAEsAIiIiJrz33nutuo7VaiUkJORqmiqE15D7Gbbn2njzYAUVjub3rc/fBPeN8mdqlKXtG+ZlZs6cuUtrHe/Ovu2R0rkJ2O0q2ANorV8DXgOIj4/XCQkJrbpISkoKrT1WCG8j9zMkAI5PDvP3rZkowNRERcvwqsqXhaU2eUDbhPYI+Hcj6RwhRCtUOjRBFjN7n0nkswNnGiwqLkMtW8bQgK+UCgYSgQeMvI4QomPamlHApEHdCfAz1wT1xsbli+YZGvC11qVADyOvIYTomPKKysg4Z+XbE/vVbFs4PloC/FWQWjpCCK+0LeM8ANMG9/RwSzoOCfhCCK+0NT2fniH+DIsM9XRTOgwJ+EIIr6O1ZmvGeaYN7iklVdqQBHwhhFdZtyeHyb/5ggLrZbYcy2fdnhxPN6nD8IlqmUKIjq268mVOYVmdKpeFpbaagmnysPbqSQ9fCOFR1VUxc6pq39SfWlVms/PShqPt37AOSAK+EMKjXFXFrE8KobUNCfhCCI/KcSOYSyG0tiE5fCGE4eqvXDVzWK+axUmaE2Qx88Tcoe3Qyo5PAr4QwlCuVq56e+epJo+pfnDbmdefNYIEfCGEodzJ0QOYlcKhtdTIMZAEfCGEodx94OrQmszfzjO4NZ2bPLQVQhjK3Qeu8mDWeBLwhRCGWjprcLP7yIPZ9iEBXwhhqMqqJQp7hvijcD6IXTylP9HhQTWvZRGT9iE5fCGEYbTWvLk9k5FRXfnk4eukEJqHSQ9fCGGYHcfPc+yslfumDpRg7wWMXuIwHPg7MArnsNofaK13GHlNIYTn1S6GZpI47zWMTumsBD7XWt+hlPIHgg2+nhDCw+pPtHJoWP7RISxmk+TpPazZgK+U6q61vtDSEyulugLTgfsAtNYVQEVLzyOE8H61SyeYFNjrlbysrngpAd+z3Onhf6WU2gu8AXymta5fvbQxMUA+8IZSaiywC1iqtS6pvZNSagmwBCAiIoKUlBR3216H1Wpt9bFCeBtfup+359p482AFFVWjceoH+2o5hWU+85k6KtVc/FbOJy2zgR8Ak4D3gTe11seaOS4e2AlM01p/pZRaCVzSWv+qsWPi4+N1ampqCz+CU0pKCgkJCa06Vghv40v387TfbnKr4mV0eBDbnrqhHVrUuSildmmt493Zt9lROtopWWt9N/BD4HvA10qpLUqpa5s49DRwWmv9VdXr1UCcO40SQvgOqXjpO9zJ4fcAFgP3AmeBh4F/A+OAD4BBro7TWp9RSmUrpYZqrY8Cs4DDbdVwIYTn2ewOLH4mKqpnV9UixdC8jzs5/B3AP4GFWuvTtbanKqVebebYh4F3qkbonAC+37pmCiG8Re0HtEH+ZioqHVjMClut5H2QxSyzZ72QOwH/l1rrVbU3KKXu1Fp/oLV+sakDtdZ7AbdyS0II71Q7wIcFWSipqKwJ7qUVdvxMim9N7FezoIn06L2XOwH/KWBVvW3LcKZzhBAdiKuVqT7clVMzpr6wzNbgmEqHZnNavjyQ9QGNBnyl1E3AzUC0UuqVWm91BSqNbpgQwjj1A3v1A9WWrkxVTRYZ9w1N9fBzgVRgAc4x9NWKgceMbJQQwjiulhx8cvV+zCbl1spUrkgte9/QaMDXWu8D9iml3tFaS49eiA7C1ZKDFXYHtC7Wy5BLH9JUSmeV1vouYI9SqsHsLK31GENbJoQwREvTL9ULilezmBQhgX4UltrkAa2PaSqls7Tq5/z2aIgQwnjlNjsBfibKXYybDw+ycLnSUaf3H2Qxs2hCtIzA6SCaSunkVf3Mar/mCCFaw9VD2IXjo+tsjwwLJCTATHkj4+ZXLBgJ4PI8omNoKqVTTN3f5GrewllxoathrRJCuM3VQ9hlaw6QmnWhzpDKvKJyAL4zqR+TBvVoNLBLgO+4murhh7ZnQ4QQrePqIWyZzc47O0+57LFtOVbAb24fI4G9E3J7ARSlVG8gsPq11tq9AbpCCEM19hC2sTq4Mma+82q2WqZSaoFSKh3IBLYAJ4HPDG6XEMJNjY2BNzeyhqyMme+83FnE/DlgCnBMaz0IZ9XLbYa2Sgjhth8lxDTYFmQxc/fkfgRZzA22y5j5zsudgG/TWp8HTEopk9Z6M87SyEIIL3DqfCkAvUMDUDgXGnnh9tH8euFoXrh9NNHhQXW2S+6+83Inh1+olAoBvsRZ6vgcUktHCK9wrricf+7M4vbx0fzhWw37YQvHR0uAFzXc6eHfCpTirJ/zOXAcuMXIRgkh3PNqyglsds3Ds2I93RThA9zp4fcG8rTW5cA/lFJBQARw3tCWCSGadPZSOW9/5ezdD+rZxdPNET7AnR7+B0Dtedh23KyFr5Q6qZQ6oJTaq5Rq3erkQgiX/ro5A4dD8/AN0rsX7nGnh++nta6ofqG1rqhastBdM7XWBS1vmhCiMbmFZbz7dTZ3xvelf49gTzdH+Ah3evj5SqkF1S+UUrcCEsCF8KC/bM5Ao/nxzMGeboq4CutPrGfO6jmM+ccY5qyew/oT6w29njs9/B/hHJ3zl6rX2cC9bp5fA0lV5ZX/R2v9WivaKISgboE0DUy7pjt9u0nv3letP7GeFdtXUG531jjKK8ljxfYVAMyLmWfINZXWjU3Arrejc2im0loXu31ypaK01rlVZRmSgYe11l/W22cJsAQgIiJiwnvvved242uzWq2EhIS06lghvE39+3l7ro03D1ZQUetpmsUE3x/lz9QoiwdaKK7W8tPLuWi/2GB7N3M3nu37rNvnmTlz5i6tdbw7+zYb8JVSYcAzwPSqTVuAZ7XWRW63yHmeFYBVa/1yY/vEx8fr1NTWPdtNSUkhISGhVccK4W3q38/TfruJHBc1cKLDg2TxcB+jtSbtQhp3fXKXy/cViv3f2+/2+ZRSbgd8d1I6rwMHgerW3Qu8AdzeTCO6ACatdXHV3+cA7n9tCdEJVadtcgrLiN65iSfmDmXGkF4ugz1IITRf4dAODhQcYGPWRjZmbeS09XSj+0Z2iTSsHe4E/Gu01otqvf5vpdReN46LANYqZwEnP+BfWuvPW9FGIToFV3Xtf7aq6f/VpBCa97I77Ow+t9sZ5E9t5FzpOfxMfkzuM5kfjv4hlbqSl795uSaHDxBoDmRp3NImznp13An4ZUqp67TWWwGUUtOAZrsVWusTwNirbJ8QnYaruvZ2DV0CzDyYcA1/2XS8wfKDUgjNu9gcNr7J+4bkU8lsOrWJC+UXCDAHMDVqKo/GPcqMfjPo6n9l7agQSwgrd6/kTMkZIrtEsjRuqWEPbMG9gP8gzhm2YThXu7oA3GdYi4TopBpLz5RetvOTmbH0DQ+W5Qe90GX7ZXbk7iA5K5mU7BQuVVwiyC+I6X2nM3vAbKZHTyfY4no01byYeYYG+PqaDfha673AWKVU16rXlwxvlRCdUM/QAPKLLzfYXp22kUJo7W/9ifUue+CltlK25mxlY9ZGtpzeQmllKaGWUBL6JTB7wGymRk0l0C+w+Qu0s6bWtP1pI9sB0Fr/waA2CdHpFJZWYHc4GmyXtI3nuBon/6ttv+KtQ29xougE5fZyugV046ZBNzF7wGwmR07GYvbuIbJN9fBlTVsh2oHdoVn63l6s5XYenR3LB6mnnaN0JG3jUSt3r6zzQBWcOfq0i2ncNeQuEgckEhcRh5/J7ZViPa6pRcz/uz0bIkRntXLjMbYcy+f520Zxz+QBPDp7iMwr8ZAL5Rf4Ou9rdubtJK8kz+U+WmuenvJ0O7esbfjOV5MQHVDy4bO8simDOyf05TuT+nu6OZ1Oqa2UPef2sDNvJzvzdpJ2IQ2AUEsoAeYALtsbPlMxcpy80STgC+EhmQUl/PT9vYyODuO5haNqno8J41Q6Kjl8/nBNgN97bi82hw2LycK43uN4ePzDTOkzhRE9RrDh5IY6OXwwfpy80STgC+EBJZcreeCfqfiZFX9bHEdgvcXGRdvQWpN5KZOduc4An3omlWKbsxzY8O7DWTx8MVP6TGF8xHiC/OpOYqseLtme4+SN1mzAb2S0ThGwq2rIphDCTc7SCWnkFDp7jT+aESMVL9tYfml+TQ9+Z95OzpWeAyA6JJo5A+cwJWoKkyIn0T2we7Pnau9x8kZzp4cfX/Xn46rX84BvgB8ppT7QWv/OqMYJ0ZHUL50A8I/tWQyL7Cojcdzkalx8Qr8EUs+k1gT4jMIMAMICwpgcOZkpUVOY0mcK/UL7ebj1nudOwO8BxGmtrQBKqWeA1TirZ+4CJOAL4YbffHqkQemEMpudlzYclYDvBlfj4pf9ZxkAGk2AOYC43nHccs0tTOkzhWHdh2FS7qzx1Hm4E/D7AxW1XtuAAVrrMqVUw0fYQog6jp0tZuUX6ZxzMYsWpOKlu36f+vsG4+I1mhBLCH+a+SfG9R5HgDnAQ63zDe4E/H8BO5VSH1W9vgV4t6rk8WHDWiaED6m9GlV1nZvhfbryyhfpfHowj2CLmZAAP6yXKxscKxUvG6e1JvVsKm8dfov8snyX+5TYSpjcZ3I7t8w3uVNL5zml1KfAdTiLp/1Ia129Ssk9RjZOCF/gqqzxT1ftxaGhi7+ZhxKu4YfXxbDlWH6DHL6UTnCtwl7BZ5mf8faRt0m7kEZ4QDghlhCsNmuDfX15XHx7c2eUzkrgfa31ynZojxA+x1VZY4eG0AA/vnxyJt26+APU5Oml4mXjLpRfYNXRVbx/9H0Kygq4Juwanrn2GebHzOeLU190uHHx7c2dlM5u4JdKqSHAWpzBv3XrEArRgRSX29h8NL/R1aislytrgn01qXjpWvrFdN4+8jafHP+ECkcF06Kn8fzw57k26tqaCWkdcVx8e3MnpfMPnPXwuwOLgBeVUv211rHuXEApZQZSgRyt9fyraq0Q7ax+bv6BGTH4mUwkHT7D9ozzVNgdmJSzR1+f5Oab5tAOtuZs5e3Db7MjbweB5kBuHXwri4cvJiY8xuUxHW1cfHtryUzbwcAwYCAte1i7FDgCdG1uRyG8iTM3v58ym7NscU5hGcs/OgRA/+7BfG/qAOaMjCT7fClPrzsouXk3ldpK+eTEJ/zz8D85eekkvYJ68cj4R7hzyJ2EB4Z7unkdmjs5/BdxLlh+HFgFPKe1LnTn5Eqpvjgnaj0PuKyvL0R7cjWapnaKpdLu4HDeJb7OvMDLSUcptzWsUd87NIAtTyTUpBomDuyOyaQkN9+MsyVneTftXT449gGXKi4xoscIXrj+BeYOmOv1deQ7Cnd6+JnAtVrrglac/0/Ak0htfeEFXI2meWrNftLPFRPgZ+abkxfYnXWRkgp7k+fJL77coNCZ5OYbd7DgIG8dfovkk8k4cHBDvxu4d8S9jO89XgrGtTOltYvkY/2dlOoGxAI1a3Zprb9s5pj5wM1a64eUUgnA465y+EqpJcASgIiIiAnvvfdeiz5ANavVSkhISKuOFZ3Dz1JKOV/u+n5XQN9QE0O6mRjSzcyQbiZ+vbPc5f49AhW/TzC2/o2v3892bWd/6X6cB7ygAAAcaElEQVQ2F28m83ImgSqQa0OuZXrodHpaenq6eR3KzJkzd2mt493Zt9mAr5T6Ic48fF9gLzAF2KG1vqGZ414A7gUqcX5RdAXWaK0XN3ZMfHy8Tk1t3QAgWTBCNGfQU+tp7G7ft3wOYcF10wquat8EWcy8cPtow3vzvno/F1cUsyZ9Df868i9yS3KJDonmnuH3cNvg2wjx990vMMPsXwVfPAtFpyGsL8xaDmPuatEplFJuB3x3UjpLgYnATq31TKXUMKDZ1bC01suAZVUNSsDZw2802AthtF6hAS7LG0SHBzUI9iDj5lsi+1I276S9w9r0tZRWlhLXO44nJz5JQr8EzCYvL/3cBkG3VefYvwo+fgRsVcN6i7Kdr6Hl13eTOwG/XGtdrpRCKRWgtU5TSsnwA+FT8orKuFzZMDff3Ggayc03rrrswduH32Zz9mbMysyNg25k8YjFjOwx0tPNc4+roLtmCay5H5QZtL3xn2H9IHYOHFoLZReunLMo23n82gdAO3AmDKt+t1Qm57awfs5jbPXmcNjKnF8cHgz4p5VS4cA6IFkpdRHIbclFtNYpQEqLWydEGygqs3Hf699gd8Djc4fw7lfZ0mNvgfoliX887seYlIl/Hv4nRy4cISwgjB+O/iHfHvZtegf39nRzW+aLZxsG3ergrO1N/yzKhtT/a/zcunqEl264rSi78eOKTjfX6lZzZ+LVbVV/XaGU2gyEAZ8b1iIh2lC5zc79b6VyosDKP74/iamDe/KTmW7NGRS4Lkn8y22/BCAmLIbl1y5nfsz8BqtFGaYt0i+1z9VU4PWUsL6GnbpFSxxqrbcY1RAh2prdoXns/b18nXmBV+4ez9TBMjqkJS5VXOKlb15qUJIYoLtDs27vFlTmcZilDUtB1NFU+iWoavWqsgtXUi412y5CULcrfw/r60zF7PuX8W1ujVnLDTu1rGkrOiStNc9+fIjPDp7hl/OGs2BslKeb5LXKK8s5UXSCjMIMMi5mcKzwGBkXMzhberbRYy4qUOgrDxpP7YT0pMZ73vV75rFz6u5f/3X18bWPU6Yr6ZQaVemS2jn06n1qb6ufY28qFeNJQd0N/fKUgC86pL9tOc4/dmRx//WD+OH1ruuydDaVjkpOXTpFemF6TXBPL0wnuzgbR1Vu2d/kT0x4DBMjJxLbLZY3D73JxfKLDc4VWfsBuK0MUl+nJvgWZcO6h+Czn1/pXVdYwV5x5f3aAdfV6+qee+0Hng2CfQdjCYKbXjT0EhLwRYezetdpfvf5UW4dF8Wym4Z7ujntTmtNXkke6RfT6wT3E0UnsDlsAJiUif6h/RnSbQg3D7qZweGDie0WS7/QfviZroSFiOCIhiWJHQ6WXqxfXaXeDAeH7Uqvunbv2v1P4fq8RgvqDv5dnF86jY3Oqf0lVP/YkbdV/aaS3fz+9Y+96UXDU2MS8EWHknL0HD//cD/TBvfgpTvGYjJ17Kn758vOOwN6YUZNgD9eeJwSW0nNPpFdIhkcPpip0VOJDY9lcPhgBoUNItAvsIkzO82LmQendrLyxFrOmJw9+6UXC5lXUmrkx/KM6h62O0H3ah4et+WD5xaSgC86jH3ZhTz0zm6GRoTy6uIJ+Pt1nAWsrRXWmsBeHdwzCjO4UH6l9xweEE5st1gWXLOA2G6xxIbHck3OfkJTfgcHv7kSXK5pwW89+1cxb9v/Mq/B0MXa3OjBtqWW9JzdFdavZYF3zF2tD9JXc+xVkoAvOoSTBSX84M1v6N7Fnzd/MJHQQO+svrg+5VdXessOWBpzG/MSnqt5v8JeQWZRJt9Yv2HPrj016ZjckitTX4L8gogNjyWhXwKDwwfXpGN6BPaoW4xs/yr49EnXMznBvV6my3HqVAVdR90RL01+KbQRSxDc8krDB7o1o3CaGKVTeRlq/ebT4HydgFvF09qL1NIRrZFffJk7Xt3OpTIbHz44lZhe3lmzZX3Kr1iRuZbyWmkmi9bMCBuG6tafjMIMThWdxF7Va/XTmkFBEcT2iSe2W2xNcI8KicKk6v324ipN8MWzrseZB3WHyrK6Abo68MGV84T2geLG5lgqWFErj18/+NZ+SAtgskBAaN1hkS5H6WTTsOde9bqlvXBXPJhOMUpLaulIwBc+qXZdez+zQmvNBz+ayvj+3TzdtEbNfn0UZ80uniloTf+uAxhsCmJw9m5iy8uIraigv60SS2M92vpDF2uPTwcw+YGjsmUNDOgKdpvzy6A5Yf3gsYONv++jOW5f1NbF04TwKvWrWNrsGn+ziazzpV4X8B3awc68naxJX8PZRh4pKGC91QLZ2xumHKprq4DrQlvnT8BXf22YTmlpsAe4fKmRN+r1uC1BzU8O8tEcd0cnAV/4nJc2HK1Tshigwu7gpQ1HvaYuTp41j3UZ61iXsY7cklzCTP4Ea02piwU/Iu0OqChqGOyrFWXDRz+umyIBZ5Df8kLTDbEENUzd+AW1cKhkVTpFetw+TwK+8Dm5ha5TDo1tby8V9go2ZW9ibfpaduTuQKOZ0m04jxXkM/NsBhv7jmIFRXVy+IEOzdJrFkHCc/DHUa5z7pZgsDUxDLJrFFxykWuvznnXT49AwxRQU18EzaVvhM+QgC98RqXdwatbjjc6EC8qvJ0KeNWTfjGdNTte5JOzOyk0KSLtmgcir2VhhYno3e9BWH/4zmrmxSZCU6N0Zi13HYhvWdn4A9jqoO7quOqeeGO9cXe/CAys7SLalwR84ROOnS3mZ6v2cSCniPH9wjly5lKdBcabq2vf1qwVVj47+Rlr09dyoOAAflpzQ2kpt1tLmFJWjvlUVXC+9icw8xfO2ZvAvITn6gzDrKM6MH/xLLroNKp++qSpoF51nNtpl5Z8EUj6psOQUTrCq1XaHfzvfzL5Y/IxQgL9+PXCUdw8uk+dUTrtVddea82ec3tYk76GpKwkyirLGBw+mNty0plfkEN3h6PuASER8PixVl3L5f0so1eEC14xSkcpFQh8CQRUXWe11voZo64nOp6Mc1Ye/2Afe7MLuWlUJM8tHEXPkACgfVeiKigr4N/H/83a9LWcvHSSYL9gbh50M7cPvo3RNjtqz0zXB1rPtW1DZPSKuEpGpnQuAzdora1KKQuwVSn1mdZ6p4HXFB2A3aF5fWsmLyUdJdjfzCt3j+eWMX0aziJtTW/XzeMqHZVsy9nGh7te4cvCo9iVYrxN81/X3MqcoXcQnLYe3rsPLpxo/FoGLmQhRGsYFvC1M1dkrXppqfrjPfkj4ZUyC0p4/IN97Mq6SOKICJ6/bRS9Q+sV+Wrt4s9uHHfq0inWZqzlo4yPyC/Lp7vdwXeLrSy0WomxVcLpv8CW/+eszT5oOlz3mHPM+4ZfyMNO4fUMfWirlDIDu4DBwF+01l8ZeT3huxwOzZvbT/K7DWn4m0388VtjWTguum6vvtrGFa4Xf177gDPwNqb0fK11Rq8cV7buR2zc8ivWBJpJ9Tdj0prrKxzcVnSR6SWl1K3KoyEwHH7yDYTUWr/VP0Ty68LrtctD26pF0NcCD2utD9Z7bwmwBCAiImLCe++916prWK1WQkK8s4aKaNq5Ugf/d+AyRy86GNvLzH0j/ekW2HBaqrmyhOicTxmU+Tauih5rIDfqxkavE5X7ec1xGjjsb2FtaAifdulCsdlEH21hrj2c2fZwemKps3/d6yi2JKxrxSd1n9zPwl0zZ870vlo6SqlngBKt9cuN7SOjdDq+2qNr+oQHcm1MDz49cAY/k2L5LSO4Y0Lfhr36kgLY+Vf4+n+d0//9AqGy4TqrzU4Q+uMoiopz+CQkmLUhIRwN8CfA4SDRprh9wRtMiJhQtyhZYxOh2mEiktzPwl3eMkqnF2DTWhcqpYKA2YCx63cJr1a/Bk5uYTkf7s5haGQob9w3seHEqUu5sP3PsOtNZ8pmxAK4/meQf7RFE4Qc2sFXeV+xNmYUX1yECqUYfrmCpwsucPNlB13nr4TIiQ0PbGpCkxA+yMgcfh/gH1V5fBOwSmv9iYHXE17MermSX68/3KAGDoC13FY32F/IhG1/gr3/AofdmQu/7jHoVTWxqs9Y589mcuZnSs7U1LPJseYQ6h/Kol6TuP341wy7cNZ53Pwmcu2tmdAkhBczcpTOfmC8UecX3klrTV5ROYdzL3E47xJH8pw/s843Xgsmt7AqPXMuDbb+AQ6sBpMZxi+GaUuh28CGBzUyJt1mt7E5ezNrMtawPWc7Gs3kyMk8Mv4RZg2YRYA5oGUfSMa+iw5ESisIl9yZyVpR6SDjnPVKYK8K8kVltpp9BvYIZmRUV+6c0Jc3tp1kWtkmnvRbRZQqIFf35HeVd2ENiYH3F8ORj52FwqY86CxJ0LWP2+09XnicNelr+Pj4x1y8fJHewb25f8z9LBy8kH6h/drs30UIXyYBXzRQP9eeU1jGU2v2c+xcMd2D/TmSV8zhvEtknCvGZnc+9A/wMzGsT1duHt2HEX1CGRHVlaGRXQkJuHKLTbZuYtSuvxOknGV++6oC/mj5G+YKDSfCYPoTMPlB6NLDrXaW2Er4PPNz1mSsYX/+fvxMfszsN5PbBt/G1KipmE3mNv6XEcK3ScAXDbiqN19uc/DXzccB6BUawPA+XZkxpBcjoroyok9XBvXsgtnkahDjFRMzVoKqW9PdrDQEhsGjByGwa7Nt01qzL38fa9LX8PnJzymrLCMmLIbH4x9nfsx8egS592UhRGckAV/UUVZhJ6eJuvJfPz2r4czX+rR2jrA5c8D552zVz0s5rvcvv9RssD9fdp6Pj3/Mmow1ZBZlEuQXxE2DbuK2wbcxttdY1xO0hBB1SMAXANjsDt77Jps/f5EOwALT1ga59l1dExsGe7vNOUzyzAE4exDO7Hf+vezilX26DYLI0VByHi4XNbx4IzVnKh2VbM/dzpr0NWzJ3kKlrmRcr3E8O/VZ5g6cS7AluK0+vhCdggT8Ts7h0Hy8P5ffJx3j1IVS4gd045mBh7jhWN1c+4uWv5M2pDdkWqoC+wFncM8/emXpPb9A6D0Chi9wBvjI0c7X1b13V4ttuxjXnl2czdr0tXx0/CPOlZ6je2B37hl+D7fH3k5MeEx7/LMI0SFJwO+ktNZsSjvHSxuOknammGGRobx+Xzwzh/ZG/WlJg1x7kKpg/P4VsL9qQ5deEDkGrrnB+TNyNHS/BsxN3FJNjGsvryxn46mNrE1fy9dnvsakTEyNmsqyScuY0XcGFrOl8fMKIdwiAb8T+jrzAr/7PI3UrIsM6BHMym+P45YxUZhMylnu11U5gWqLP4SI0RAa0aprrw/pwsp+UZzpbiKySyR36ELydz7P+sz1FFcUEx0SzU/G/YRbB99KZJfIVn5CIYQrEvA7kUO5Rby04SgpR/PpHRrArxeO4lsT+2HRNji81lnCIHNL4ycI6weDZ7f6+utPrGfF9hWU250TrfJK8vjz3j9jxszcQXO5PfZ2JkZOrFvPRgjRZiTgdwKZBSX8IfkYH+/LpWugHz+/cRj3TR1I0KVM+GK5s4RB6XlnQJ/5NASEwRfPtGkNmfNl53nhqxdqgn1tPYN78uJ0KbMkhNEk4HdgZ4rKWflFOqtSs/E3m/jxzGtYMjWasMzP4J1HIGsrmPxg6E0Qdx9cM9NZ0gAguNtV15DJL83ni1NfkJyVTOrZVBz1a9FXOVfaxksBCiFckoDfARWWVvC3lOO8uf0kDq25Z3J/lo6ppEfam/DX95xDJrsNhFnPwLh7XOfjW1lD5kzJGb449QVJJ5PYc24PGs2gsEHcP/p+Pkz/kIKyggbHSK5eiPYhAb8DKblcyRvbMvmfLSewVlRy55ge/LxfGj2O/gn+8RWYLDB8Pky4DwZOB1Pb5MrzrHkkZyWTnJXM3vy9AAwOH8yDYx8kcUAig7sNBmBQ2KA6OXyAQHMgS+OWtkk7hBBNk4DfAVyutPPuV6f4f5szKLBWcF+MlaXdttEtYx0cLYIegyHxORj3HejSs02umV2czcasjSRnJXOg4AAAw7oP4+HxDzN7wGxiwhqOl58XMw+AlbtXcqbkDJFdIlkat7RmuxDCWBLwfZjdoVm3J4c/bjzGhYsXWRqxj8XhKXTJ3QdnA2DErTDhezBgGrRB6YGsS1kkZyWTdDKJIxeOADCyx0gejXuUxAGJ9O/av9lzzIuZJwFeCA+RgO+DtNYkHT7L75OO4n9uP0933UpiyH/wKyqBXsPgxt/CmG9BcPervtaJohMkn0wmKSuJYxePATCm5xh+NuFnzB4wm76hrssiCCG8j5FLHPYD3gIiAQfwmtZ6pVHX6yy2Hy/gz5/uIebMp/wlIIXYgBNoexBq1O0Q9z3oN+mqevNaazIKM2py8hmFGQCM7z2eJyc+yez+s+kT4n6deiGE9zCyh18J/ExrvVspFQrsUkola60PG3jNDuObf/8P/Xa/RG+dzznVi71DHmZnYRjDc9fyut8OgiyX0T1HQvzLqNF3QlB4q6+lteboxaMknUwiOSuZk5dOolBMiJjAsknLmNV/FhFdWjezVgjhPYxc4jAPyKv6e7FS6ggQDUjAb8Y3//4fRu36pbN4mYJI8plz9BluVBpbQBBq9F0Q/31UdFyre/Naaw6fP0xSljPIZxdnY1ImJkZM5N4R93JD/xvoGdQ2D3iFEN6hXXL4SqmBONe3/ao9rufr+u1+qaZSZTWT0hQRQtiTaRAQ2qrzaq05UHCgJl2TY83BrMxM7jOZH4z6ATf0v4HugVef9xdCeCfDA75SKgT4EHhUa33JxftLgCUAERERpKSktOo6Vqu11cd6m+k6H1x03EN1CSk7drXoXA7t4OTlk+wp3cO+0n1ctF/EjJmhQUNJ6JHA6KDRdDF3gVzYn7u/+ROKdtGR7mfhPZTW2riTK2UBPgE2aK3/0Nz+8fHxOjU1tVXXSklJISEhoVXHepszKwYTSX7D7fQickVGs8fbHXZ2n9tNclYyG7M2kl+Wj8VkYVr0NOYMmMOMfjPo6t/8coLCczrS/SyMpZTapbWOd2dfI0fpKOD/gCPuBHtxRXbcE4RV5/CrlGl/sic8QWNFCCodlew6u6smyJ8vP0+AOYDro68ncUAi0/tOJ8Q/pH0+gBDCKxmZ0pkG3AscUErtrdr2C631pwZes0OYuOABvoGqUToFnFM9yZ7wBBMXPFBnP5vDxjd535CUlcSmU5u4ePkiQX5BziA/MJHp0dNlGUAhRA0jR+lsxWUmWrhj4oIHoCrAR1b9AbDZbezI20FyVjKbTm3iUsUlgv2CmdFvBnMGzGFa9DSC/II81m4hhPeSmbY+4LL9MttztpOclUxKdgrFtmJCLCHM7DeTxAGJTI2eSoA5wNPNFEJ4OQn4Xqq8spxtOdvYkLWBLdlbKK0sJdQ/lBv638CcgXOY0mcK/mZ/TzdTCOFDJOB7kVJbKf/J+Q/JWcl8efpLyirLCA8I56ZBN5E4IJFJkZNkMW8hRKtJwPewElsJW7K3kJyVzNacrZTby+ke2J1bYm4hcWAi8RHx+JnkP5MQ4upJJPGA4opiUrJTSMpKYnvOdiocFfQK6sVtsbeROCCRuN5xmKuXGhRCiDYiAb+dFF0uYnP2ZpKzktmeu51KRyURwRHcNfQuEgckMq73OEyqbVagEkIIVyTgG+hi+UU2ndpEclYyX+V9RaWuJKpLFPcMu4fEgYmM7jlagrwQot1IwG9jBWUFbDq1iaSsJFLPpGLXdvqG9OW7I7/LnAFzGNFjBKoNVp8SQoiWkoDfBs6VnqtZ33X3ud04tIOBXQfyg1E/YM7AOQztNlSCvBDC4yTgt9KZkjM1QX7PuT1oNNeEXcOSMUtIHJBIbHisBHkhhFeRgN8COdYcNmZtJCkrif35zlLCQ7oN4aFxD5E4IJFrwq/xcAuFEKJxEvCbkX0pu2ZVqEPnDwEwvPtwlsYtZXb/2QwMG+jZBgohhJsk4LtwsugkyVnJJGUlkXYhDYBRPUbx2ITHSByQSL/Qfh5uoRBCtJwE/CrHC4/X9OTTL6YDMLbXWB6Pf5zEAYlEhUR5uIVCCHF1Om3A11pz7OKxmvVdTxSdQKEY33s8T016iln9ZxHZpbHlRoQQwvd0qoCvtebIhSM1QT7rUhYmZSI+Ip67h93NrP6z6BXcy9PNFEIIQxi5xOHrwHzgnNZ6lFHXaY7WmkPnDznTNSeTOW09jVmZmRg5ke+O+C439L+BnkE9PdU8IYRoN0b28N8E/h/wloHXYP2J9azcvZK8kjz6rO7D0ril3DToJvbn76/pyeeV5OGn/JgcNZn7x9zPzH4z6RbYzchmCSGE1zFyicMvlVIDjTo/OIP9iu0rKLeXA5BXksfTW5/m+Z3PU2wrxmKyMDVqKj8e92MS+iUQFhBmZHOEEMKr+XQOf+XulTXBvppd26lwVPCb635DQr8EQv1DPdQ6IYTwLh4P+EqpJcASgIiICFJSUtw+Nq8kz+X2y/bLhGaHsit7V1s0UYh2Z7VaW/T/ghDu8HjA11q/BrwGEB8frxMSEtw+ts/qPi6Dfp8ufWjJeYTwNikpKXIPizbn08XYl8YtJdAcWGdboDmQpXFLPdQiIYTwXoYFfKXUu8AOYKhS6rRS6r/a+hrzYuaxYuoK+nTpAzh79iumrmBezLy2vpQQQvg8I0fp3G3UuWubFzOPeTHz5FdgIYRohk+ndIQQQrhPAr4QQnQSEvCFEKKTkIAvhBCdhAR8IYToJJTW2tNtqKGUygeyGnk7DChq4vCeQEGbN8rzmvvcvnr9tjpva8/T0uPc3b+t9pP72beu78n7eYDW2r267lprn/gDvNbM+6mebqMnPrevXr+tztva87T0OHf3b6v95H72ret7+n52948vpXQ+9nQDPMTTn9uo67fVeVt7npYe5+7+bb1fR+Ppz91R72e3eFVK52oopVK11vGebocQbUHuZ2EEX+rhN+c1TzdAiDYk97Nocx2mhy+EEKJpHamHL4QQogkS8IUQopOQgC+EEJ1Ehwz4SqkuSql/KKX+Vyl1j6fbI8TVUkrFKKX+Tym12tNtEb7LZwK+Uup1pdQ5pdTBettvVEodVUplKKWeqtp8O7Baa30/sKDdGyuEG1pyT2utT2it23wRIdG5+EzAB94Ebqy9QSllBv4C3ASMAO5WSo0A+gLZVbvZ27GNQrTEm7h/Twtx1Xwm4GutvwQu1Ns8Ccio6v1UAO8BtwKncQZ98KHPKDqXFt7TQlw1Xw+G0VzpyYMz0EcDa4BFSqm/4fmp3EK0hMt7WinVQyn1KjBeKbXMM00Tvs6wNW3biXKxTWutS4Dvt3djhGgDjd3T54EftXdjRMfi6z3800C/Wq/7ArkeaosQbUHuaWEYXw/43wCxSqlBSil/4NvAvz3cJiGuhtzTwjA+E/CVUu8CO4ChSqnTSqn/0lpXAj8BNgBHgFVa60OebKcQ7pJ7WrQ3KZ4mhBCdhM/08IUQQlwdCfhCCNFJSMAXQohOQgK+EEJ0EhLwhRCik5CAL4QQnYQEfCGE6CQk4AshRCchAV+IJiilBiqljlStnnZIKZWklArydLuEaA0J+EI0Lxb4i9Z6JFAILPJwe4RoFQn4QjQvU2u9t+rvu4CBHmyLEK0mAV+I5l2u9Xc7vr+OhOikJOALIUQnIQFfCCE6CSmPLIQQnYT08IUQopOQgC+EEJ2EBHwhhOgkJOALIUQnIQFfCCE6CQn4QgjRSUjAF0KITkICvhBCdBL/HyNixp505Z5GAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(n_list, generic_locs_bk, 'o-', label = 'generic')\n", "plt.plot(n_list, chain_locs_bk, 'o-', label = 'chain')\n", "plt.plot(L_list**2, square_locs_bk, 'o-', label = 'square')\n", "plt.legend()\n", "plt.ylabel('avg locality')\n", "plt.xlabel('n')\n", "plt.xscale('log')\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# the JKMN transform \n", "\n", "The research on Fermion to Qubit mappings is still active. One of the most recent developments is dated Oct 2019 ([arXiv:1910.10746](https://arxiv.org/abs/1910.10746)).\n", "In this paper, Zhang Jiang and collaborators propose an elegant method based on ternary trees to achieve average locality of transformed single fermionic operators to $\\lceil{\\log_3(n)}\\rceil$ for a $n$-mode fermionic system.\n", "The authors also prove this method to be *optimal*: no general fermion to qubit mapping using $n$ qubits can do better than this.\n", "\n", "It is beyond the scope of this tutorial to explain the whole transform, but we give some concepts that can be useful if one wants to delve deeper into it.\n", "\n", "\n", "### Majorana representation of Fermionic operators\n", "\n", "To perform the JKMN transform we first have to rewrite the fermionic operators in term of **Majorana operators**, defined as\n", "$$\n", " \\gamma_{2j} = c^\\dagger_j + c_j,\\\\\n", " \\gamma_{2j+1} = i( c^\\dagger_j - c_j ).\n", "$$\n", "These operators behave much like generalizations of Pauli operators: they are Hermitian and unitary, thus squaring to the identity $\\gamma_j^2=\\mathbb{1}$, and they all anticommute with each other ($\\{\\gamma_j, \\gamma_k\\} = 2\\delta_{j,k}$).\n", "For a single-mode system, their matrix representation also looks like Pauli matrices (note that the last matrix is obtained by the product of all the previous ones):" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T12:33:15.840082Z", "start_time": "2020-04-16T12:33:15.824500Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "gamma_0 = [0^] + [0]\n", "[[0.+0.j 1.+0.j]\n", " [1.+0.j 0.+0.j]] \n", "(same form as Pauli X)\n", "\n", "gamma_1 = 1j [0^] - 1j [0]\n", "[[0.+0.j 0.-1.j]\n", " [0.+1.j 0.+0.j]] \n", "(same form as Pauli Y)\n", "\n", "gamma_0 * gamma_1 = 2 [0^0] + 1 []\n", "[[0.+1.j 0.+0.j]\n", " [0.+0.j 0.-1.j]] \n", "(same form as Pauli Z)\n", "\n" ] } ], "source": [ "from openfermion import get_sparse_operator, FermionOperator\n", "\n", "gamma_0 = FermionOperator('0^', 1) + FermionOperator('0', 1)\n", "gamma_1 = FermionOperator('0^', 1j) + FermionOperator('0', -1j)\n", "\n", "print('gamma_0 = [0^] + [0]')\n", "print(get_sparse_operator(gamma_0).A, '\\n(same form as Pauli X)\\n')\n", "print('gamma_1 = 1j [0^] - 1j [0]')\n", "print(get_sparse_operator(gamma_1).A, '\\n(same form as Pauli Y)\\n')\n", "print('gamma_0 * gamma_1 = 2 [0^0] + 1 []')\n", "print(get_sparse_operator(gamma_0 * gamma_1).A, '\\n(same form as Pauli Z)\\n') " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An operator in an $n$-mode fermionic system can be rewritten by choosing among $2n$ Majorana operators (sometimes also called Majorana modes).\n", "\n", "*Sidenote*: all transformations can be defined in terms of Majorana operators (as they're just a re-writing of fermionic operators). For JKMN this is specially useful.\n", "\n", "### The ternary tree construction\n", "\n", "Let's suppose that the number of fermionic modes in our system is $n = (3^m-1)/2$ (the extension to a generic $n$ is technical but conceptually simple).\n", "The number of Majorana modes will then be $3^m-1$.\n", "Let's now construct a **ternary tree** like in Figure 1 of the [JKMN paper](https://arxiv.org/abs/1910.10746):\n", "we start with one root node from which 3 branches spring. At the end of every branch a new node springs 3 more branches. Repeating the operation $m$ times we obtain a tree with $3^m$ terminal nodes (or **leaf nodes**).\n", "To each leaf node but the last one we assign one of the Majorana operators $\\gamma_j$.\n", "To each branching node (i.e. non-terminal node) we associate a qubit $Q_i$ (exercise: convince yourself that we need exactly $n$ qubits).\n", "To each branch we associate one of the three pauli operators acting on the qubit on the node from which the branch springs $\\{X_i, Y_i, Z_i\\}$.\n", "Each $\\gamma_j$ will be mapped to a string of Pauli operators corresponding to the branches on the path that connect the leaf $\\gamma_j$ to the root of the tree.\n", "\n", "Mappings of $\\gamma_j$ and $\\gamma_{j'}$ will differ by a single different Pauli matrix on the same qubit, at the node where the paths join (plus a bunch of identities on qubits not touched by the paths.\n", "For this reason, all transformed $\\gamma_j$ will anticommute.\n", "Also, as the number of branches on the path from any leaf to the root is $m = \\log_3(2n+1)$, every majorana operator will be mapped to a $m$-local qubit operator.\n", "\n", "### Locality scaling\n", "\n", "The code for JKMN is not yet in openfermion, but we coded it for the tutorial and for our research. We are planning to add it to openfermion in the near future.\n", "The code is in the module file `_jkmn.py`, which you should have downloaded from the course website. Run `import _jkmn` and `help(_jkmn)` to see the content of the module.\n", "The function `jkmn` from this module is homologue to the `bravyi_kitaev` function of `openfermion.transforms` and requires the number of modes to be specified.\n", "\n", "**Exercise 11:** The code below prints the `FermionOperator` objects for each of the 8 Majorana $\\gamma_j$ in a $n=4$ fermionic modes system. Use JKMN to map them to QubitOperators and check the mapped operators against the tree in Figure 1 of the [JKMN paper](https://arxiv.org/abs/1910.10746)." ] }, { "cell_type": "code", "execution_count": 225, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T15:54:13.379850Z", "start_time": "2020-04-16T15:54:13.371800Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Maj | Fermion op | JKMN-mapped Qubit op\n", " 0 | 1.0 [0] + 1.0 [0^] | 1.0 [X0 X1] \n", " 1 | 1j [0] - 1j [0^] | (1+0j) [X0 Y1] \n", " 2 | 1.0 [1] + 1.0 [1^] | 1.0 [X0 Z1] \n", " 3 | 1j [1] - 1j [1^] | (1+0j) [Y0 X2] \n", " 4 | 1.0 [2] + 1.0 [2^] | 1.0 [Y0 Y2] \n", " 5 | 1j [2] - 1j [2^] | (1+0j) [Y0 Z2] \n", " 6 | 1.0 [3] + 1.0 [3^] | 1.0 [Z0 X3] \n", " 7 | 1j [3] - 1j [3^] | (1+0j) [Z0 Y3] \n" ] } ], "source": [ "from _jkmn import majorana_to_fermion, inline, jkmn\n", "from openfermion import MajoranaOperator\n", "\n", "n = 4\n", "print(f'Maj | Fermion op | JKMN-mapped Qubit op')\n", "for maj_idx in range(2*n):\n", " fop = majorana_to_fermion(MajoranaOperator((maj_idx,)))\n", " qop = jkmn(fop, n)\n", " print(f'{maj_idx:^3} | {inline(fop):^20} | {inline(qop):^25}')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 12:** Use the `jkmn` function to perform the same study on average locality versus system size you performed for the Jordan-Wigner and Bravyi-Kitaev transforms. Do this for single fermionic operators, for quadratic and for quartic. \n", "For each, plot results of the three transforms together (choose the preferred plotting scale)." ] }, { "cell_type": "code", "execution_count": 249, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:09:10.308526Z", "start_time": "2020-04-16T16:09:10.300615Z" }, "code_folding": [] }, "outputs": [], "source": [ "def single_avg_loc(n):\n", " fops = (FermionOperator(f'{i}') for i in range(n)) # generator\n", " qops = (jkmn(fop, n) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)\n", "\n", "def quadratic_avg_loc(n):\n", " fops = (FermionOperator(f'{i}^ {j}') for i in range(n) for j in range(n)) # generator\n", " qops = (jkmn(fop, n) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)\n", "\n", "def quartic_avg_loc(n):\n", " fops = (FermionOperator(f'{i}^ {j}^ {k} {l}') \n", " for i in range(n) for j in range(i) for k in range(n) for l in range(k)\n", " ) # generator\n", " qops = (jkmn(fop, n) for fop in fops) # generator\n", " localities = list(qop.many_body_order() for qop in qops)\n", " return np.average(localities)" ] }, { "cell_type": "code", "execution_count": 250, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:09:10.710961Z", "start_time": "2020-04-16T16:09:10.707111Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 251, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:13:52.945140Z", "start_time": "2020-04-16T16:09:10.990336Z" } }, "outputs": [], "source": [ "n_list = np.arange(2, 20)\n", "single_locs_jkmn = list(single_avg_loc(n) for n in n_list)\n", "quadratic_locs_jkmn = list(quadratic_avg_loc(n) for n in n_list)\n", "quartic_locs_jkmn = list(quartic_avg_loc(n) for n in n_list)" ] }, { "cell_type": "code", "execution_count": 252, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:13:53.251945Z", "start_time": "2020-04-16T16:13:52.974883Z" }, "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.title('JKMN')\n", "plt.plot(n_list, single_locs_jkmn, 'o-', label='single')\n", "plt.plot(n_list, quadratic_locs_jkmn, 'o-', label='quadratic')\n", "plt.plot(n_list, quartic_locs_jkmn, 'o-', label='quartic')\n", "plt.legend()\n", "plt.ylabel('avg locality')\n", "plt.xlabel('n')\n", "plt.xscale('log')\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### summary of localities for singles " ] }, { "cell_type": "code", "execution_count": 253, "metadata": { "ExecuteTime": { "end_time": "2020-04-16T16:13:53.536947Z", "start_time": "2020-04-16T16:13:53.279229Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.title('Singles')\n", "plt.plot(n_list, single_locs_jw, 'o-', label='Jordan-Wigner')\n", "plt.plot(n_list, single_locs_bk, 'o-', label='Bravyi-Kitaev')\n", "plt.plot(n_list, single_locs_jkmn, 'o-', label='JKMN')\n", "plt.legend()\n", "plt.ylabel('avg locality')\n", "plt.xlabel('n')\n", "plt.xscale('log')\n", "plt.grid()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Final notes and caveats\n", "\n", "#### Geometric locality: another point of view\n", "\n", "We saw that Jordan-Wigner transform preserves takes into account geometric locality to some degree, while Bravyi-Kitaev and JKMN don't. \n", "This is useful when studying systems that can be mapped to a local lattice.\n", "Most phyisical systems have built-in geometric locality at some scale: at a deep level all physical sytems are local because of relativity!\n", "Unfortunately this scale is sometimes larger than what we can ever expect to simulate on a quantum computer.\n", "\n", "In chemistry, for example, Hamiltonians constructed using molecular orbitals (which often extend over many atoms) as modes are often not geometrically local at all.\n", "Finding efficient ways to construct molecular Hamiltonians that use localised fermionic modes, to retain some sort of geometric locality, is an active research field (with applications beyond efficiency of fermion to qubit mappings).\n", "\n", "Furthermore, most quantum devices that can be used to actually implement quantum algorithms are themselves geometrically local. \n", "Qubits are arranged in some lattice structure, typically on a plane or on a line, and can only interact with a subset of neighboring qubits.\n", "(Examples are superconducting qubits, spin qubits and most topological qubit models. Notable exceptions are ion-based devices, which show all-to-all interactions).\n", "Simulating a geometrically local fermionic system on a geometrically local quantum processor might quickly become very hard because non-local operations might be needed.\n", "In this case, Jordan-Wigner might be much better than the seemingly more optimized JKMN!\n", "\n", "#### Ancillas to go \"beyond optimal\" scaling\n", "\n", "Even though it is proven that no transform that maps the whole fermionic $n$-mode Hilbert space to $n$ qubits can show better locality scaling than BKSF, better locality can be achieved adding ancilla qubits.\n", "Bravyi-Kitaev superfast transform (BKSF, not to be confused with Bravyi-Kitaev!) does exactly this to achieve *constant* locality at a cost of introducing a qubit for each interaction.\n", "These kind of transforms tend to be less general (BKSF can *only* map number-conserving quadratic and quartic operators), allowing to exploit specific properties of the problem." ] } ], "metadata": { "hide_input": false, "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.7.1" }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }