{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Quantinuum Systems - Quantum Subspace Expansion \n", "==================================================" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "This tutorial illustrates the computation of molecular excited states through the application of the Quantum Subspace Expansion (QSE) technique on a Quantinuum emulator. The QSE method leverages a precise calculation of the ground state energy for a specific molecular configuration to approximate the energies of corresponding excited states. Consider a stable molecule, denoted by a Hamiltonian $H$, and let $\\left|\\Psi_{0}\\right\\rangle$ represent the outcome of the Variational Quantum Eigensolver ([VQE](InQ_tut_vqe_1.ipynb)) algorithm employed to estimate the ground state energy of $H$. More information on the QSE method can be found in the publication available at this [link](https://doi.org/10.1103/PhysRevA.95.042308). \n", "\n", "The QSE technique constructs a subspace of state vectors $\\left|\\Psi_j^k\\right\\rangle$ formed by one-electron excitations of the ground state wavefunction:\n", "\n", "$$\n", "\\left|\\Psi_{j}^{k}\\right\\rangle = c_k^{\\dagger}c_{j}\\left|\\Psi_0\\right\\rangle.\n", "$$\n", "\n", "where $c_k^{\\dagger}, c_{j}$ are the fermionic creation and annihilation operators over spin orbitals $k$ and $j$, respectively. That is, these vectors are formed by reducing the occupation of spin orbital $j$ by one, and increasing the occupation of spin orbital $k$ by one. The vectors are not in general orthogonal to $\\Psi_{0}$ hence we will need to calculate an overlap matrix.\n", "\n", "\n", "Within this subspace, we solve a generalized eigenvalue problem. Consider the operator $\\hat{H} $ with matrix elements given by\n", "$$(H)_{jk}^{lm} = \\langle\\Psi_j^l \\left| \\hat{H} \\right| \\Psi_k^m\\rangle,$$\n", "\n", "and define an overlap matrix $S$ whose matrix elements are given by\n", "\n", "$$S_{jk}^{lm} = \\langle \\Psi_j^l \\left|\\Psi_k^m\\right\\rangle.$$\n", "\n", "The generalized eigenvalue equation to be solved is \n", "\n", "$$\n", "HC=SCE,\n", "$$\n", "\n", "where $C$ is the matrix of eigenvectors, and $E$ is the vector of eigenvalues. Crucially, the energy eigenvalues $E$ provide an estimate of the excited state energies of $H$ as well as a refined value of the ground state energy.\n", "\n", "Notice that the solution to the generalized eigenvalue equation can be done on a classical computer, provided $H$ and $S$ have been calculated. The matrix elements of both of these matrices can be constructed using a quantum computer, in the following way. First, re-write the matrix elements in terms of $\\left | \\Psi_{0}\\right \\rangle$:\n", "\n", "$$\n", "(H)_{jk}^{lm} = \\langle\\Psi_j^l \\left| \\hat{H} \\right| \\Psi_k^m\\rangle = \\langle \\Psi_{0} | c_{j}^\\dagger c_{l} \\hat{H}c_{m}^{\\dagger}c_{k}|\\Psi_{0}\\rangle\\\\\n", "S_{jk}^{lm} = \\langle \\Psi_j^l \\left|\\Psi_k^m\\right\\rangle = \\langle \\Psi_{0} | c_{j}^\\dagger c_{l} c_{m}^{\\dagger}c_{k}|\\Psi_{0}\\rangle.\n", "$$\n", "\n", "The matrix elements can be calculated using a quantum computer or simulator. By transforming the operators \n", "$c_{j}^\\dagger c_{l} c_{k}^{\\dagger}c_{m}$ and $c_{l}^\\dagger c_{j} \\hat{H} c_{m}^{\\dagger}c_{k}$ to a set of Pauli quantum gates according to an appropriate scheme such as Jordan-Wigner or Bravyi-Kitaev, apply this gate set to the ground state wavefunction (constructed with the coefficients obtained from the VQE calculation) and perform a measurement to obtain the expected value. By measuring these expectation values, we obtain estimates of $S_{jk}^{lm}$ and $H_{jk}^{lm}$, respectively.\n", "\n", "This tutorial will guide you through the process of performing QSE and will show how to collate the resulting eigen-energies and eigen-vectors. To demonstrate these concepts, we will utilize the methane (CH$_4$) chemical system. Note that to follow this tutorial, you must have been granted access to Quantinuum systems which can be obtained by contacting Quantinuum support. Users can access Quantinuum backends through [pytket-quantinuum](https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/) or via [Quantinuum Nexus](https://docs.quantinuum.com/nexus/trainings/notebooks/basics/getting_started.html).\n", "\n", "\n", "\n", "The steps below are such:\n", "\n", "- Define the system\n", "- Prepare the approximate ground state obtained by the VQE algorithm\n", "- Configure the Quantinuum backend\n", "- Establish the PMSV error mitigation \n", "- Define protocol for measuring QSE matrix elements \n", "- Build InQuanto computables \n", "- Submit and retreive InQuanto computables\n", "- The black-box approach using the AlgorithmQSE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After defining the Z-matrix for Methane, the Hamiltonian object is created using a restricted Hartree-Fock (RHF) InQuanto-PySCF driver.\n", "\n", "The `get_system` function is responsible for computing the fermionic Hamiltonian operator, Fock space, and Hartree Fock state.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "from inquanto.extensions.pyscf import ChemistryDriverPySCFMolecularRHF\n", "\n", "zmatrix = \"\"\"\n", "C\n", "H 1 1.083000\n", "H 1 1.083000 2 109.471000\n", "H 1 1.083000 2 109.471000 3 120.000000\n", "H 1 1.083000 2 109.471000 4 120.000000\n", "\"\"\"\n", "\n", "driver = ChemistryDriverPySCFMolecularRHF(\n", " zmatrix=zmatrix,\n", " charge=0,\n", " frozen=[0, 1, 2, 3, 7, 8],\n", " basis=\"STO-3G\",\n", " point_group_symmetry=True,\n", ")\n", "\n", "hamiltonian, space, state = driver.get_system()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "The `qubit_encode` function carries out qubit encoding, utilizing the mapping class associated with the current integral operator. The default mapping approach is the Jordan-Wigner method. Additionally, we employ the `compress` method, which eliminates Hamiltonian terms with coefficients less than `abs_tol`, chosen as $10^{-6}$ here. This step is a means of reducing the number of measurement circuits/quantum computational resources needed (which means less time to run which is preferred for a tutorial), and the threshold we use is fairly reasonable compared to the scale of errors induced by noisy quantum simulation. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
CoefficientTermCoefficient Type
0-37.822198<class 'numpy.float64'>
1-0.496463Z5<class 'numpy.float64'>
2-0.496463Z4<class 'numpy.float64'>
30.128963Z4 Z5<class 'numpy.float64'>
4-0.496463Z3<class 'numpy.float64'>
50.110247Z3 Z5<class 'numpy.float64'>
60.123222Z3 Z4<class 'numpy.float64'>
7-0.012975X2 X3 Y4 Y5<class 'numpy.float64'>
80.012975X2 Y3 Y4 X5<class 'numpy.float64'>
90.012975Y2 X3 X4 Y5<class 'numpy.float64'>
10-0.012975Y2 Y3 X4 X5<class 'numpy.float64'>
11-0.496463Z2<class 'numpy.float64'>
120.123222Z2 Z5<class 'numpy.float64'>
130.110247Z2 Z4<class 'numpy.float64'>
140.128963Z2 Z3<class 'numpy.float64'>
15-0.067741Z1<class 'numpy.float64'>
160.106870Z1 Z5<class 'numpy.float64'>
170.118715Z1 Z4<class 'numpy.float64'>
180.106870Z1 Z3<class 'numpy.float64'>
190.118715Z1 Z2<class 'numpy.float64'>
20-0.011845X0 X1 Y4 Y5<class 'numpy.float64'>
21-0.011845X0 X1 Y2 Y3<class 'numpy.float64'>
220.011845X0 Y1 Y4 X5<class 'numpy.float64'>
230.011845X0 Y1 Y2 X3<class 'numpy.float64'>
240.011845Y0 X1 X4 Y5<class 'numpy.float64'>
250.011845Y0 X1 X2 Y3<class 'numpy.float64'>
26-0.011845Y0 Y1 X4 X5<class 'numpy.float64'>
27-0.011845Y0 Y1 X2 X3<class 'numpy.float64'>
28-0.067741Z0<class 'numpy.float64'>
290.118715Z0 Z5<class 'numpy.float64'>
300.106870Z0 Z4<class 'numpy.float64'>
310.118715Z0 Z3<class 'numpy.float64'>
320.106870Z0 Z2<class 'numpy.float64'>
330.123178Z0 Z1<class 'numpy.float64'>
\n", "
" ], "text/plain": [ " Coefficient Term Coefficient Type\n", "0 -37.822198 \n", "1 -0.496463 Z5 \n", "2 -0.496463 Z4 \n", "3 0.128963 Z4 Z5 \n", "4 -0.496463 Z3 \n", "5 0.110247 Z3 Z5 \n", "6 0.123222 Z3 Z4 \n", "7 -0.012975 X2 X3 Y4 Y5 \n", "8 0.012975 X2 Y3 Y4 X5 \n", "9 0.012975 Y2 X3 X4 Y5 \n", "10 -0.012975 Y2 Y3 X4 X5 \n", "11 -0.496463 Z2 \n", "12 0.123222 Z2 Z5 \n", "13 0.110247 Z2 Z4 \n", "14 0.128963 Z2 Z3 \n", "15 -0.067741 Z1 \n", "16 0.106870 Z1 Z5 \n", "17 0.118715 Z1 Z4 \n", "18 0.106870 Z1 Z3 \n", "19 0.118715 Z1 Z2 \n", "20 -0.011845 X0 X1 Y4 Y5 \n", "21 -0.011845 X0 X1 Y2 Y3 \n", "22 0.011845 X0 Y1 Y4 X5 \n", "23 0.011845 X0 Y1 Y2 X3 \n", "24 0.011845 Y0 X1 X4 Y5 \n", "25 0.011845 Y0 X1 X2 Y3 \n", "26 -0.011845 Y0 Y1 X4 X5 \n", "27 -0.011845 Y0 Y1 X2 X3 \n", "28 -0.067741 Z0 \n", "29 0.118715 Z0 Z5 \n", "30 0.106870 Z0 Z4 \n", "31 0.118715 Z0 Z3 \n", "32 0.106870 Z0 Z2 \n", "33 0.123178 Z0 Z1 " ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubit_hamiltonian = hamiltonian.qubit_encode()\n", "qubit_hamiltonian.compress(abs_tol=1e-6)\n", "qubit_hamiltonian.df()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To construct our ansatz for the specified fermion space and fermion state, we have employed the Chemically Aware Unitary Coupled Cluster method with singles and doubles excitations (UCCSD). The circuit is synthesized using Jordan-Wigner encoding." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from inquanto.ansatzes import FermionSpaceAnsatzChemicallyAwareUCCSD\n", "\n", "ansatz = FermionSpaceAnsatzChemicallyAwareUCCSD(space, state)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, a noiseless VQE simulation is executed on the QulacsBackend. The goal is to achieve a minimized expectation value and a set of circuit parameters corresponding to the ground state. These optimized parameters are subsequently employed in the Hamiltonian averaging experiment later on." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# TIMER BLOCK-0 BEGINS AT 2024-02-19 10:02:38.479944\n", "# TIMER BLOCK-0 ENDS - DURATION (s): 0.8142243 [0:00:00.814224]\n" ] } ], "source": [ "from inquanto.express import run_vqe\n", "from pytket.extensions.qulacs import QulacsBackend\n", "\n", "state_backend = QulacsBackend()\n", "vqe = run_vqe(ansatz, hamiltonian, backend=state_backend, with_gradient=False)\n", "\n", "parameters = vqe.final_parameters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To simulate the specific noise profiles of machines, we can load and apply them to our simulations using the `QuantinuumBackend`, which retrieves information from your Quantinuum account. The QuantinuumBackend offers a range of available emulators, such as H1-1E and H1-2E. These emulators are designed for specific devices and they run remotely on a server.\n", "\n", "Parameters used:\n", "\n", "`device_name` – Name of device, e.g. “H1-1”\n", "\n", "`label` – Job labels used if Circuits have no name, defaults to “job”\n", "\n", "`group` – string identifier of a collection of jobs, can be used for usage tracking.\n", "\n", "The [pytket-quantinuum](https://docs.quantinuum.com/tket/extensions/pytket-quantinuum/) extension allows the user to access the following quantum devices, emulators and syntax checkers." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from pytket.extensions.quantinuum import QuantinuumBackend\n", "\n", "backend = QuantinuumBackend(device_name=\"H1-1E\", group =\"Default - UK\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To reduce errors and inaccuracies caused by quantum noise and imperfections in the Quantinuum device, we can employ noise mitigation techniques. In this case, we will define the Qubit Operator symmetries within the system, enabling us to utilize PMSV (Partition Measurement Symmetry Verification). More information about QubitOperator can be found in the provided [link](https://docs.quantinuum.com/inquanto/api/inquanto/operators.html#inquanto.operators.QubitOperator)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from inquanto.operators import QubitOperator\n", "from inquanto.protocols import PMSV\n", "\n", "stabilizers = [QubitOperator(\"Z0 Z1 Z2 Z3 Z4 Z5\", 1)]\n", "\n", "mitms_pmsv = PMSV(stabilizers)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To expand the subspace for computing low-lying excited states, it is essential to define the basis. In this context, the function `generate_subspace_singlet_singles` is employed, which sequentially provides spin-adapted singlet-single excitation operators to preserve spin symmetry which are then mapped to qubits using the Jordan-Wigner method." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from inquanto.mappings import QubitMappingJordanWigner\n", "\n", "mapping = QubitMappingJordanWigner()\n", "\n", "fermionic_excitations_singlets = list(space.generate_subspace_singlet_singles())\n", "qubit_excitations_singlets = mapping.operator_map(fermionic_excitations_singlets)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that the Hamiltonian, Ansatz and QSE basis operators are defined, we can build the computable. The computable is the chemical quantity that we are interested in. In this example, we are interested in building the QSE computable using the `QSEMatricesComputable` function. \n", "\n", "Parameters used:\n", "\n", "`state` – Ansatz used to represent the ground state, it is used as a reference state for the excitations to generate the subspace.\n", "\n", "`hermitian_operator` – A hermitian operator, typically a hamiltonian, to be expanded in the subspace.\n", "\n", "`expansion_operators` – A List of excitation operators spanning the subspace." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from inquanto.computables.composite import QSEMatricesComputable\n", "\n", "qse = QSEMatricesComputable(\n", " state=ansatz,\n", " hermitian_operator=qubit_hamiltonian,\n", " expansion_operators=qubit_excitations_singlets,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To compute the expectation value of a Hermitian operator through operator averaging on the system register, we employ the `PauliAveraging` protocol. This protocol effectively implements the procedure outlined in [Operator Averaging](https://docs.quantinuum.com/inquanto/manual/protocols/expval.html)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from inquanto.protocols import PauliAveraging\n", "from pytket.partition import PauliPartitionStrat\n", "\n", "protocol = PauliAveraging(\n", " backend=backend,\n", " shots_per_circuit=6000,\n", " pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n", ")\n", "\n", "protocol.build_from(parameters=parameters, computable=qse, noise_mitigation=mitms_pmsv)\n", "protocol.compile_circuits()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Despite having many Qubit Operators to measure, this protocol ends up generating 30 measurement circuits due to the commutation relations measurement partitioning strategy pytket uses." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "30" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "protocol.n_circuit" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "To launch the circuits to the backend we have used the `launch` function. This method processes all the circuits associated with the expectation value calculations and returns a list of ResultHandle objects representing the handles for the results. We can pickle these ResultHandle objects so we can retrieve the results once they are ready. After our experiments have finished, we can obtain the results by utilizing the `retrieve` function, which retrieves distributions from the backend for the specified source." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "handles = protocol.launch()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pickle\n", "\n", "with open(\"handles.pickle\", \"wb\") as handle:\n", " pickle.dump(handles, handle, protocol=pickle.HIGHEST_PROTOCOL)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Circuit is queued.\n" ] } ], "source": [ "completion_check=backend.circuit_status(handles[-1])[0].value #n-1 \n", "print(completion_check)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "protocol.retrieve(handles)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once the results have been retrieved the Hamiltonian expectation value is evaluated as a classical post-processing step.\n", "\n", "We now need to pass the output of the `QSEMatricesComputable` into `pd_safe_eigh`. This will solve the generalized eigenvalue equation and return the eigenvalues and eigenvectors." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "H,S = qse.evaluate(protocol.get_evaluator())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-39.729 -38.91 -38.871 -38.768 -38.273 -37.903]\n", "[[-0.156+0.476j 0.004-0.008j 0.002-0.006j -0.018+0.023j 0.002-0.015j\n", " -0. -0.002j]\n", " [-0.311-0.135j -0.24 +0.368j -0.567+0.08j 3.806+1.333j 0.888+0.622j\n", " -0.223-0.734j]\n", " [-0.388-0.069j -0.606-0.105j -0.781+0.008j 4.621+0.967j -1.663-0.86j\n", " -0.85 +0.603j]\n", " [-0.003-0.003j 0.576+0.164j -0.384+0.022j 0.06 +0.043j -0.061+0.026j\n", " -0.004-0.055j]\n", " [-0.077-0.165j -1.04 +0.671j -0.19 -0.518j 0.644+1.722j -1.634+2.515j\n", " -5.204+1.559j]\n", " [ 0.16 +0.204j 0.08 +1.131j 0.391+0.141j -2.197-2.655j 0.879+3.241j\n", " -2.243+2.55j ]\n", " [-0.006+0.003j 0.111+0.338j 0.363+0.46j 0.113+0.117j -0.12 -0.056j\n", " -0.007+0.04j ]\n", " [-0.098-0.106j -0.638+0.085j -0.395+0.104j 1.81 +1.216j -1.329+1.704j\n", " 1.878-1.188j]\n", " [ 0.17 +0.018j 0.057+0.8j 0.203+0.411j -1.287-0.708j 1.636+4.126j\n", " 3.24 -1.954j]]\n" ] } ], "source": [ "from inquanto.core import pd_safe_eigh\n", " \n", "e_vals_singlets, e_coeffs_singlets, _ = pd_safe_eigh(H,S)\n", "\n", "print(e_vals_singlets)\n", "print(e_coeffs_singlets)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We perform additional post-processing to report the operator expansion for each excited state." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(-0.15565783977198872+0.47621487975804033j, F0^ F0 ), (-0.15565783977198872+0.47621487975804033j, F1^ F1 ), (-0.3109942131939058-0.13521605338785778j, F0^ F2 ), (-0.3109942131939058-0.13521605338785778j, F1^ F3 ), (-0.38839307178519544-0.0693114600174391j, F0^ F4 ), (-0.38839307178519544-0.0693114600174391j, F1^ F5 ), (-0.003308852334800071-0.002955219215334559j, F2^ F0 ), (-0.003308852334800071-0.002955219215334559j, F3^ F1 ), (-0.07692730809458342-0.1649068223822534j, F2^ F2 ), (-0.07692730809458342-0.1649068223822534j, F3^ F3 ), (0.16028553390102782+0.2040034257419802j, F2^ F4 ), (0.16028553390102782+0.2040034257419802j, F3^ F5 ), (-0.006135282730581221+0.003137920667681536j, F4^ F0 ), (-0.006135282730581221+0.003137920667681536j, F5^ F1 ), (-0.09846811137359278-0.10620905658730515j, F4^ F2 ), (-0.09846811137359278-0.10620905658730515j, F5^ F3 ), (0.16993533787082993+0.01769895101511043j, F4^ F4 ), (0.16993533787082993+0.01769895101511043j, F5^ F5 )\n", "(0.003529209585032674-0.00795687921061023j, F0^ F0 ), (0.003529209585032674-0.00795687921061023j, F1^ F1 ), (-0.24049475157327982+0.36783111046288186j, F0^ F2 ), (-0.24049475157327982+0.36783111046288186j, F1^ F3 ), (-0.6060191423196757-0.10482632989727117j, F0^ F4 ), (-0.6060191423196757-0.10482632989727117j, F1^ F5 ), (0.5763459636232429+0.16388842490954422j, F2^ F0 ), (0.5763459636232429+0.16388842490954422j, F3^ F1 ), (-1.0398193192980176+0.6711364842936922j, F2^ F2 ), (-1.0398193192980176+0.6711364842936922j, F3^ F3 ), (0.0799938237057527+1.1312076955513257j, F2^ F4 ), (0.0799938237057527+1.1312076955513257j, F3^ F5 ), (0.11138656902183633+0.3380893725102996j, F4^ F0 ), (0.11138656902183633+0.3380893725102996j, F5^ F1 ), (-0.6378073443599778+0.08473450806257327j, F4^ F2 ), (-0.6378073443599778+0.08473450806257327j, F5^ F3 ), (0.057037317243711416+0.7995538108062838j, F4^ F4 ), (0.057037317243711416+0.7995538108062838j, F5^ F5 )\n", "(0.002165953897558483-0.005944635760931628j, F0^ F0 ), (0.002165953897558483-0.005944635760931628j, F1^ F1 ), (-0.5667818952627056+0.08033281708487372j, F0^ F2 ), (-0.5667818952627056+0.08033281708487372j, F1^ F3 ), (-0.7806938566797863+0.008375225559272712j, F0^ F4 ), (-0.7806938566797863+0.008375225559272712j, F1^ F5 ), (-0.38358059039903575+0.02164733189057025j, F2^ F0 ), (-0.38358059039903575+0.02164733189057025j, F3^ F1 ), (-0.18951924122622935-0.5175643220754953j, F2^ F2 ), (-0.18951924122622935-0.5175643220754953j, F3^ F3 ), (0.39067878123749633+0.14105366840747063j, F2^ F4 ), (0.39067878123749633+0.14105366840747063j, F3^ F5 ), (0.3633037576320181+0.45991596424530234j, F4^ F0 ), (0.3633037576320181+0.45991596424530234j, F5^ F1 ), (-0.3948958613818514+0.10360791672209882j, F4^ F2 ), (-0.3948958613818514+0.10360791672209882j, F5^ F3 ), (0.2025074399411661+0.41092059234737977j, F4^ F4 ), (0.2025074399411661+0.41092059234737977j, F5^ F5 )\n", "(-0.017840047182897188+0.022744956740089296j, F0^ F0 ), (-0.017840047182897188+0.022744956740089296j, F1^ F1 ), (3.806126291783216+1.332658212611577j, F0^ F2 ), (3.806126291783216+1.332658212611577j, F1^ F3 ), (4.621131902658994+0.9671995436795001j, F0^ F4 ), (4.621131902658994+0.9671995436795001j, F1^ F5 ), (0.05993966785070938+0.04310122860320857j, F2^ F0 ), (0.05993966785070938+0.04310122860320857j, F3^ F1 ), (0.6441688080331356+1.7220627585285808j, F2^ F2 ), (0.6441688080331356+1.7220627585285808j, F3^ F3 ), (-2.1965755386805927-2.655483790470051j, F2^ F4 ), (-2.1965755386805927-2.655483790470051j, F3^ F5 ), (0.1127899167896759+0.11659167840761259j, F4^ F0 ), (0.1127899167896759+0.11659167840761259j, F5^ F1 ), (1.809508151433246+1.2160491220244634j, F4^ F2 ), (1.809508151433246+1.2160491220244634j, F5^ F3 ), (-1.2874605040396814-0.7077883650219732j, F4^ F4 ), (-1.2874605040396814-0.7077883650219732j, F5^ F5 )\n", "(0.0021294584990190677-0.01537836611697584j, F0^ F0 ), (0.0021294584990190677-0.01537836611697584j, F1^ F1 ), (0.8881021827827966+0.6217291428756166j, F0^ F2 ), (0.8881021827827966+0.6217291428756166j, F1^ F3 ), (-1.6634091829941275-0.85957877147374j, F0^ F4 ), (-1.6634091829941275-0.85957877147374j, F1^ F5 ), (-0.06072464916897717+0.025946744324903372j, F2^ F0 ), (-0.06072464916897717+0.025946744324903372j, F3^ F1 ), (-1.6336871970371127+2.515156393240569j, F2^ F2 ), (-1.6336871970371127+2.515156393240569j, F3^ F3 ), (0.8787624912303986+3.2406507977554675j, F2^ F4 ), (0.8787624912303986+3.2406507977554675j, F3^ F5 ), (-0.12020930798769339-0.055773317529686006j, F4^ F0 ), (-0.12020930798769339-0.055773317529686006j, F5^ F1 ), (-1.3286485705307103+1.7035098710284213j, F4^ F2 ), (-1.3286485705307103+1.7035098710284213j, F5^ F3 ), (1.6355067063551598+4.126046236307394j, F4^ F4 ), (1.6355067063551598+4.126046236307394j, F5^ F5 )\n", "(-0.00020756753326981142-0.0016959811491862975j, F0^ F0 ), (-0.00020756753326981142-0.0016959811491862975j, F1^ F1 ), (-0.22283094986115085-0.7342082125387235j, F0^ F2 ), (-0.22283094986115085-0.7342082125387235j, F1^ F3 ), (-0.8502303263381792+0.6025252787670932j, F0^ F4 ), (-0.8502303263381792+0.6025252787670932j, F1^ F5 ), (-0.004028844274401662-0.054943191515560284j, F2^ F0 ), (-0.004028844274401662-0.054943191515560284j, F3^ F1 ), (-5.203599573643404+1.5592992892443864j, F2^ F2 ), (-5.203599573643404+1.5592992892443864j, F3^ F3 ), (-2.2427076382898403+2.550269786999596j, F2^ F4 ), (-2.2427076382898403+2.550269786999596j, F3^ F5 ), (-0.006964622239363893+0.040135082617393666j, F4^ F0 ), (-0.006964622239363893+0.040135082617393666j, F5^ F1 ), (1.878027835548134-1.18788450746501j, F4^ F2 ), (1.878027835548134-1.18788450746501j, F5^ F3 ), (3.2403778890630868-1.953712459189611j, F4^ F4 ), (3.2403778890630868-1.953712459189611j, F5^ F5 )\n" ] } ], "source": [ "from inquanto.operators import FermionOperator\n", "\n", "e_vecs = []\n", "for i in range(e_coeffs_singlets.shape[1]):\n", " operator = FermionOperator()\n", " for c, o in zip(e_coeffs_singlets[:, i], fermionic_excitations_singlets):\n", " operator += c * o\n", " operator.compress(abs_tol=1e-5)\n", " print(operator)\n", " e_vecs.append(operator)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, the Quantum Subspace Expansion algorithm implemented in InQuanto, known as `AlgorithmQSE`, can be employed. This is a black-box method enabling direct retrieval of eigenvalues and eigenvectors, stored as `final_value` and `final_states`, respectively. The algorithm addresses numerical instabilities during matrix diagonalization by eliminating near-linear dependencies in the basis. However, it's worth noting that the user has less control over the specific details of the process. Some examples that cannot be executed include launching, retrieving, and performing PMSV." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from inquanto.algorithms import AlgorithmQSE\n", "\n", "algorithm = AlgorithmQSE(\n", " computable_qse_matrices=qse,\n", " parameters=parameters,\n", ")\n", "\n", "protocol_expression = PauliAveraging(\n", " backend=backend,\n", " shots_per_circuit=1000,\n", " pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n", ")\n", " \n", "algorithm.build(protocol=protocol_expression)\n", " \n", "#algorithm.run() \n", "\n", "#print(algorithm.generate_report())" ] } ], "metadata": { "kernelspec": { "display_name": "11jun25_docs", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.12.6" } }, "nbformat": 4, "nbformat_minor": 4 }