{ "cells": [ { "cell_type": "markdown", "id": "6094ece81c0ee6ce", "metadata": {}, "source": [ "A simple Hubbard model simulation\n", "==================================" ] }, { "cell_type": "markdown", "id": "2d447d0ab820a9e9", "metadata": {}, "source": [ "The Hubbard model describes the motion and interactions of particles on a lattice and is often used to study strongly correlated materials. The extended Hubbard Hamiltonian included in InQuanto reads:\n" ] }, { "cell_type": "markdown", "id": "eada851fdb23bef3", "metadata": {}, "source": [ "$$\n", "H=\\sum_{i} e_i c_i^{\\dagger} c_i-t \\sum_{}-t' \\sum_{<>} c_i^{\\dagger} c_j+U \\sum_{i}n_{i\\uparrow}n_{i\\downarrow}+V \\sum_{} n_{i\\uparrow} n_{j\\downarrow},\n", "$$" ] }, { "cell_type": "markdown", "id": "de4c5313b19f2598", "metadata": {}, "source": [ "where $e_i$ describes onsite energies, $t$ ($t'$) denotes the hopping energy between (next) nearest neighboring sites, $U$ stands for the onsite Hubbard interaction and $V$ is the nearest neighbor Coulomb interaction." ] }, { "cell_type": "markdown", "id": "588a586b6661bd69", "metadata": {}, "source": [ "Here we show an example of the ground state energy calculation for a small Hubbard square structure of $2 \\times 4$ sites. We start by building the Hamiltonian using the `inquanto.express.DriverGeneralizedHubbard2D`. More information on how to use this driver can be found [here](https://docs.quantinuum.com/inquanto/manual/express.html)." ] }, { "cell_type": "code", "execution_count": null, "id": "4dda28feda2e60b9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Snake Hamiltonian:\n", " Coefficient Term Coefficient type\n", "0 -1.0 F0^ F2 \n", "1 -1.0 F0^ F6 \n", "2 4.0 F1^ F0^ F0 F1 \n", "3 -1.0 F1^ F3 \n", "4 -1.0 F1^ F7 \n", "5 -1.0 F2^ F0 \n", "6 -1.0 F2^ F4 \n", "7 -1.0 F3^ F1 \n", "8 4.0 F3^ F2^ F2 F3 \n", "9 -1.0 F3^ F5 \n", "10 -1.0 F4^ F2 \n", "11 -1.0 F4^ F6 \n", "12 -1.0 F4^ F10 \n", "13 -1.0 F5^ F3 \n", "14 4.0 F5^ F4^ F4 F5 \n", "15 -1.0 F5^ F7 \n", "16 -1.0 F5^ F11 \n", "17 -1.0 F6^ F0 \n", "18 -1.0 F6^ F4 \n", "19 -1.0 F6^ F8 \n", "20 -1.0 F7^ F1 \n", "21 -1.0 F7^ F5 \n", "22 4.0 F7^ F6^ F6 F7 \n", "23 -1.0 F7^ F9 \n", "24 -1.0 F8^ F6 \n", "25 -1.0 F8^ F10 \n", "26 -1.0 F8^ F14 \n", "27 -1.0 F9^ F7 \n", "28 4.0 F9^ F8^ F8 F9 \n", "29 -1.0 F9^ F11 \n", "30 -1.0 F9^ F15 \n", "31 -1.0 F10^ F4 \n", "32 -1.0 F10^ F8 \n", "33 -1.0 F10^ F12 \n", "34 -1.0 F11^ F5 \n", "35 -1.0 F11^ F9 \n", "36 4.0 F11^ F10^ F10 F11 \n", "37 -1.0 F11^ F13 \n", "38 -1.0 F12^ F10 \n", "39 -1.0 F12^ F14 \n", "40 -1.0 F13^ F11 \n", "41 4.0 F13^ F12^ F12 F13 \n", "42 -1.0 F13^ F15 \n", "43 -1.0 F14^ F8 \n", "44 -1.0 F14^ F12 \n", "45 -1.0 F15^ F9 \n", "46 -1.0 F15^ F13 \n", "47 4.0 F15^ F14^ F14 F15 \n" ] } ], "source": [ "from inquanto.express import DriverGeneralizedHubbard2D\n", "from inquanto.ansatzes import SiteLabeling2D\n", "\n", "e, t, u, v, nx, ny = (0.0, -1.0, 4.0, 0.0, 2, 4)\n", "labels = SiteLabeling2D.snake\n", "hubbard_driver = DriverGeneralizedHubbard2D(\n", " e=e, u=u, t=t, v=v, n_x=nx, n_y=ny, site_labeling=labels, pbc=False\n", ")\n", "\n", "ham, f_space, f_state = hubbard_driver.get_system()\n", "print('\\nSnake Hamiltonian:\\n', ham.df())" ] }, { "cell_type": "markdown", "id": "bad2159547ca180c", "metadata": {}, "source": [ "\n", "Hamiltonian variational ansatz\n", "-------------------------------" ] }, { "cell_type": "markdown", "id": "9d3dbc1a6251f94a", "metadata": {}, "source": [ "Quantum simulations of Hubbard systems often employ the VQE framework to find the ground state energy of the problem. This involves proposing an initial state with free parameters. These parameters are classically optimized in a loop that is guided by the quantum computed energy of the system. The success of this technique depends strongly on the selection of an efficient ansatz that still captures the problem’s features [[Cade *et al.*]](https://link.aps.org/doi/10.1103/PhysRevB.102.235122).\n", "\n", "A popular ansatz choice is the Hamiltonian Variational Ansatz (HVA), which takes inspiration from the adiabatic theorem. It mimics the adiabatic evolution of the state under the Hubbard Hamiltonian by applying a sequence of rotations with variational parameters instead of fixed time intervals [[Wecker *et al.*]](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.92.042303). More details on constructing a general HVA can be found [here](https://docs.quantinuum.com/inquanto/manual/ansatze/hva.html).\n" ] }, { "cell_type": "markdown", "id": "2e5e4c4f6b5353af", "metadata": {}, "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "id": "e7d8ee9fa9413105", "metadata": {}, "source": [ "\n", "Below we show how a simple HVA is constructed in InQuanto for the Hubbard model on a square lattice. First, the Hubbard Hamiltonian for a square lattice is split into commuting parts [[Cade *et al.*]](https://link.aps.org/doi/10.1103/PhysRevB.102.235122):" ] }, { "cell_type": "markdown", "id": "ee29d8259a12d044", "metadata": {}, "source": [ "$$\n", "H_e=\\sum_{i}e_i c_i^{\\dagger}c_i\n", "$$\n", "$$\n", "H_U=U\\sum_{i} n_{i\\uparrow}n_{i\\downarrow}\n", "$$\n", "$$\n", "H_V=V\\sum_{\\sigma} n_{i\\sigma}n_{j\\sigma}\n", "$$\n", "$$\n", "H_{h_e}=-t_{h_e}\\sum_{ \\text{horiz even}} c_i^{\\dagger}c_j+h.c.\n", "$$\n", "$$\n", "H_{h_o}=-t_{h_o}\\sum_{ \\text{horiz odd}} c_i^{\\dagger}c_j+h.c.\n", "$$\n", "$$\n", "H_{v_e}=-t_{v_e} \\sum_{ \\text{vert even}} c_i^{\\dagger}c_j+h.c.\n", "$$\n", "$$\n", "H_{v_o}=-t_{v_o} \\sum_{ \\text{vert odd}} c_i^{\\dagger}c_j+h.c.,\n", "$$\n", "$$\n", "H_{next}=-t' \\sum_{<>} c_i^{\\dagger}c_j+h.c.,\n", "$$" ] }, { "cell_type": "markdown", "id": "35f7c78be27a30a8", "metadata": {}, "source": [ "where $H_e$ is the onsite term, $H_U$ is the Hubbard U term, $H_{h_e}$ is the horizontal hopping term for even (red dotted in the figure above) and $H_{h_o}$ for odd (orange dashed in the figure above) and $H_{v_e}$ and $H_{v_o}$ are the vertical hopping terms for even (blue solid in the figure above) and odd rows (green dash-dotted in the figure above), and $H_{next}$ is the next nearest neighbor hopping (not shown in the figure for clarity). Not all of these terms will be present for a small structure, but they have been listed and shown here for generality. Each term is multiplied by a variational parameter and used in a unitary rotation. The sequence of all rotations by all terms is then repeated $s$ times for an $s$-layer HVA.\n" ] }, { "cell_type": "markdown", "id": "d0613f416704b17c", "metadata": {}, "source": [ "$$\n", "\\Psi_{HVA}=\\prod_{k=1}^s e^{-i\\phi_{0k}H_V} e^{-i\\phi_{1k}H_U} e^{-i\\phi_{2k}H_ho} e^{-i\\phi_{3k}H_he} e^{-i\\phi_{4k}H_{ve}} e^{-i\\phi_{5k}H_{vo}} e^{-i\\phi_{k}H_{next}} |\\psi_i\\rangle.\n", "$$" ] }, { "cell_type": "markdown", "id": "ef9b783fb02e7962", "metadata": {}, "source": [ "The `inquanto.express.HamiltonianVariationalAnsatzHubbard` has $m \\cdot s$ variational parameters, one for each Hamiltonian term in each layer, and $m$ denotes distinct term types in the Hamiltonian.\n", "\n", "We show an example of how to use HVA for the Hubbard model solution in the next section.\n", "Examples of using HVA for solving chemistry problems can be found [here](https://docs.quantinuum.com/inquanto/manual/ansatze/hva.html).\n" ] }, { "cell_type": "markdown", "id": "9741766d11defaa1", "metadata": {}, "source": [ "Slater determinant state preparation\n", "-------------------------------------" ] }, { "cell_type": "markdown", "id": "ef245df5df9117eb", "metadata": {}, "source": [ "Part of the task of preparing a good HVA involves the choice of an appropriate\n", "initial reference state that the ansatz builds upon. This choice corresponds to selecting\n", "a specific phase characterized by spin or particle number, which is expected\n", "to describe the solution of the Hubbard Hamiltonian.\n", "\n", "One common way to build a reference state is to arrange $N=N_{\\uparrow}+N_{\\downarrow}$ particles on the first $N$ sites of the lattice, with alternating spins, producing an antiferromagnetic state [[Wecker *et al.*]](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.92.042303). This type of state is the default output by the `get_system()` method used above." ] }, { "cell_type": "markdown", "id": "8205a34f824d4fe3", "metadata": {}, "source": [ "Another good choice of a reference state is to initialize the system in the eigenstate of the non-interacting part of the Hamiltonian, i.e. a single Slater determinant (SD) [[Wecker *et al.*]](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.92.042303). The ansatz will then account account for the other (interacting) terms. Coefficients for such a SD state can be obtained by diagonalizing a tight-binding Hamiltonian or a mean-field problem first. A SD reference state can be built with InQuanto by providing a unitary matrix rotation [[Jiang *et al.*]](https://link.aps.org/doi/10.1103/PhysRevApplied.9.044036), [[Kivlichan *et al.*]](https://link.aps.org/doi/10.1103/PhysRevLett.120.110501) using `inquanto.ansatzes.RealGeneralizedBasisRotationAnsatz`, `inquanto.ansatzes.RealRestrictedBasisRotationAnsatz` and\n", "`inquanto.ansatzes.RealUnrestrictedBasisRotationAnsatz`." ] }, { "cell_type": "markdown", "id": "1627c2edfdc130b", "metadata": {}, "source": [ "Solving the Hubbard model with VQE\n", "-----------------------------------" ] }, { "cell_type": "markdown", "id": "44e42f29e297c0a0", "metadata": {}, "source": [ "Here we will put all the above components together to build a Hubbard model simulation for the $2 \\times 4$ structure mentioned at the beginning, using the VQE algorithm.\n", "\n", "We start with building a SD reference state for the HVA ansatz. A reference state is built from the rotation matrix corresponding to the eigenstates of the hopping matrix. The hopping matrix is obtained from the InQuanto Hubbard driver.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "f092fc0306065bbd", "metadata": {}, "outputs": [], "source": [ "from inquanto.mappings import QubitMappingJordanWigner\n", "from inquanto.ansatzes import RealUnrestrictedBasisRotationAnsatz\n", "import numpy as np\n", "\n", "# Get the hopping matrix from the driver (without the Hubbard U term)\n", "hopping_matrix, _ = hubbard_driver.get_one_two_body_terms()\n", "n_sites = nx * ny\n", "\n", "# Define fermion to qubit mapping and map the Hamiltonian\n", "mapping = QubitMappingJordanWigner()\n", "qubit_op = mapping.operator_map(ham)\n", "\n", "# Diagonalise the non-interacting problem\n", "eigvals, eigvecs = np.linalg.eigh(hopping_matrix.todense())\n", "\n", "# Set up the number of particles for one spin and prepare a state with this number\n", "n_el_one_spin = 4\n", "reference_state = [1] * 2 * n_el_one_spin + [0] * (n_sites - n_el_one_spin) * 2\n", "\n", "# Rotate the reference state to the basis diagonalising the non-interacting problem\n", "rotation_driver = RealUnrestrictedBasisRotationAnsatz(reference_state)\n", "rotation_params = rotation_driver.ansatz_parameters_from_unitary(eigvecs, eigvecs)\n", "slater_det_circuit = rotation_driver.get_circuit(rotation_params)" ] }, { "cell_type": "markdown", "id": "60f3912b730dd2cc", "metadata": {}, "source": [ "We then define the HVA with the SD reference state and a given number of layers." ] }, { "cell_type": "code", "execution_count": null, "id": "6aa8853312dc6e2d", "metadata": {}, "outputs": [], "source": [ "from pytket.extensions.qiskit import AerStateBackend\n", "from inquanto.ansatzes import HamiltonianVariationalAnsatzHubbard\n", "\n", "# Define the HVA ansatz. The Slater determinant circuit needs to be compiled\n", "backend = AerStateBackend()\n", "compiled_circuit = backend.get_compiled_circuit(slater_det_circuit)\n", "\n", "\n", "# define the ansatz and starting parameters for a Hubbard model VQE calculation\n", "init_params = {\"sym0_l0\": 0.9481931804543265, \"sym0_l1\": 1.0382884839454627, \"sym0_l2\": -0.924132119830008,\n", " \"sym1_l0\": 1.1082735281121958, \"sym1_l1\": 2.022564270774505, \"sym1_l2\": -0.08425721713315654,\n", " \"sym2_l0\": -0.6123566351342871, \"sym2_l1\": 0.7032504509643882, \"sym2_l2\": 0.9633159435158412,\n", " \"sym3_l0\": -0.6556278859648624, \"sym3_l1\": -1.010560960893456, \"sym3_l2\": -0.12415371369806133}\n", "\n", "n_layer = 3 # number of layers in the ansatz used for accuracy adjustment\n", "ansatz = HamiltonianVariationalAnsatzHubbard(compiled_circuit, lat_dims=[nx, ny],\n", " hamiltonian_operator=ham,\n", " step_number=n_layer, site_labeling=labels)" ] }, { "cell_type": "markdown", "id": "dba12f7b4f2f713a", "metadata": {}, "source": [ "We then build a VQE algorithm and run it.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "2e5919d6ffb2ed9f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# TIMER BLOCK-0 BEGINS AT 2026-04-23 14:00:52.515487\n", "# TIMER BLOCK-0 ENDS - DURATION (s): 22.0879024 [0:00:22.087902]\n", "VQE Energy: -4.268977767009267\n", "VQE Parameters: {sym0_l0: np.float64(0.9481971507635327), sym0_l1: np.float64(1.0382907258804654), sym0_l2: np.float64(-0.9241355898527304), sym1_l0: np.float64(1.108270510078506), sym1_l1: np.float64(2.0225629344784775), sym1_l2: np.float64(-0.08426166333799054), sym2_l0: np.float64(-0.6123580126341529), sym2_l1: np.float64(0.703253523575341), sym2_l2: np.float64(0.9633103448578884), sym3_l0: np.float64(-0.6556297039663058), sym3_l1: np.float64(-1.010559715335178), sym3_l2: np.float64(-0.12415347884908916)}\n" ] } ], "source": [ "from inquanto.algorithms import AlgorithmVQE\n", "from inquanto.computables import ExpectationValue, ExpectationValueDerivative\n", "from inquanto.minimizers import MinimizerScipy\n", "from inquanto.protocols import SparseStatevectorProtocol\n", "\n", "# build the VQE algorithm\n", "expectation_value = ExpectationValue(ansatz, qubit_op)\n", "derivative = ExpectationValueDerivative(ansatz, qubit_op, ansatz.state_symbols.as_set())\n", "vqe = AlgorithmVQE(\n", " objective_expression=expectation_value,\n", " minimizer=MinimizerScipy(),\n", " gradient_expression=derivative,\n", " initial_parameters=init_params,\n", ")\n", "\n", "# Define circuit protocols\n", "protocol_objective = SparseStatevectorProtocol(backend)\n", "protocol_gradient = SparseStatevectorProtocol(backend)\n", "vqe.build(\n", " protocol_objective=protocol_objective,\n", " protocol_gradient=protocol_gradient\n", ")\n", "\n", "# Run the VQE algorithm\n", "vqe.run()\n", "\n", "# print final VQE energy\n", "print(\"VQE Energy: \", vqe.final_value)\n", "print(\"VQE Parameters:\", vqe.final_parameters)" ] }, { "cell_type": "markdown", "id": "a3de9b13c5efceb7", "metadata": {}, "source": [ "The form of the HVA ansatz used here is not sufficiently complex to reproduce the exact GS energy, equal to $E_{GS}=-5.0$. In order to obtain accurate energy, likely $n_{layer}=10$ would be needed. However, the wavefunction obtained from this algorithm already gives a good representation of the ground state." ] }, { "cell_type": "markdown", "id": "5152f4022c54b87b", "metadata": {}, "source": [ "Measuring the ground state spin correlations\n", "---------------------------------------------\n", "\n", "Often, the goal of solving the Hubbard model on a quantum computer is learning more about the nature of its ground state in various areas of the phase space. This can be achieved by e.g. tracking charge and spin observables as the model parameters change. Expectation values of charge and spin operators can be obtained using InQuanto, just like the energy expectation values we needed in each iteration of VQE.\n", "\n", "Spin correlation is given by [[Stanisic *et al.*]](https://www.nature.com/articles/s41467-022-33335-4):\n", "\n", "$C(i,j) = \\langle S_z^i S_z^j \\rangle - \\langle S_z^i\\rangle \\langle S_z^j\\rangle$,\n", "\n", "where $S_z^i$ is the $z$ projection of the spin operator on site $i$.\n", "\n", "Here we show how to produce a spin correlation matrix for the ground state that we obtained from VQE using InQuanto. The `SpinCorrelationComputable` relies on the fermion space object `f_space` generated by the Hubbard driver to produce the necessary spin operators." ] }, { "cell_type": "code", "execution_count": null, "id": "ece29747c396f072", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "spin correlation computable: \n" ] } ], "source": [ "from inquanto.computables.composite import SpinCorrelationComputable\n", "\n", "# define the spin correlation computable\n", "spin_corr_comp = SpinCorrelationComputable(f_space, ansatz, mapping)\n", "print(f\"spin correlation computable: {spin_corr_comp}\")" ] }, { "cell_type": "markdown", "id": "ed5c2b6492568f3b", "metadata": {}, "source": [ "We now evaluate the `SpinCorrelationComputable` and plot the results." ] }, { "cell_type": "code", "execution_count": null, "id": "59e4d26d9508b66b", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib import pyplot as plt\n", "# evaluator driver\n", "evaluator = protocol_objective.get_evaluator(vqe.final_parameters)\n", "# evaluate spin correlation\n", "spin_corr_exp_val = spin_corr_comp.evaluate(evaluator=evaluator)\n", "# extract the spin correlation matrix to plot\n", "spin_corr_mat = np.real(spin_corr_exp_val.data)\n", "\n", "# plot results\n", "plt.figure()\n", "plt.imshow(spin_corr_mat)\n", "plt.colorbar()\n", "plt.title(f\"Spin correlation for 2x4 lattice\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "5b8380aeb1a2e69", "metadata": {}, "source": [ "The result we obtain is a 8x8 matrix, with rows and columns corresponding to all the sites of the lattice structure. This is in agreement with [[Stanisic *et al.*]](https://www.nature.com/articles/s41467-022-33335-4) (Fig. 6c.)." ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }