examples/variational_methods/vqe_custom_ansatz_hamiltonian.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tangelo VQE: Custom Ansatz and qubit Hamiltonian Tutorial\n",
    "\n",
    "Tangelo comes packaged with an implementation of several standard ansatz circuits for the user to take advantage of. In this tutorial, we'll explore how you can incorporate the built in `VQESolver` into your own workflow, by introducing a user-defined custom ansatz circuit and/or a qubit Hamiltonian. We'll base our work here on the `VQESolver` class, and take advantage of tools readily available through Tangelo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Installation of tangelo if not already installed.\n",
    "try:\n",
    "    import tangelo\n",
    "except ModuleNotFoundError:\n",
    "    !pip install git+https://github.com/goodchemistryco/Tangelo.git@develop --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from tangelo.algorithms import VQESolver, FCISolver\n",
    "from tangelo import SecondQuantizedMolecule\n",
    "from tangelo.toolboxes.ansatz_generator.ansatz import Ansatz\n",
    "from tangelo.toolboxes.qubit_mappings.statevector_mapping import get_reference_circuit\n",
    "from tangelo.toolboxes.qubit_mappings.mapping_transform import get_qubit_number, fermion_to_qubit_mapping\n",
    "from tangelo.linq import Circuit, Gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hardware Efficient Ansatz\n",
    "For our example, we're going to implement the so-called [Hardware Efficient Ansatz](https://arxiv.org/pdf/1704.05018.pdf) (HEA), developed by Kandala et al at IBM. In this ansatz, a circuit is constructed with repeated layers of a simple structure. Each layer consists of entangling gates (e.g. CNOT or CZ) which couple neighbouring qubits, followed by a series of Euler rotations carried out as single-qubit rotations $e^{i\\theta_i^1 Z_i}e^{i\\theta_i^2 X_i}e^{i\\theta_i^3 Z_i}$. We'll start by initializing our `Ansatz` class, and then fill in the functionality required to implement this ansatz in `VQESolver`.\n",
    "\n",
    "To construct our HEA ansatz, we're going to make use of the three helper functions defined here. The first will go through a register of qubits and add a layer of Euler-rotations as prescribed above. The second adds two columns of alternating CNOT gates, establishing long-range entanglement. The third brings these together into a sequence of alternating entanglers and Euler rotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def EulerCircuit(n_qubits):\n",
    "    \"\"\"Construct a circuit applying an Euler Z-X-Z rotation to each qubit.\"\"\"\n",
    "    circuit = Circuit()\n",
    "    for target in range(n_qubits):\n",
    "        circuit.add_gate(Gate(\"RZ\" , target, parameter=0.0, is_variational=True))\n",
    "        circuit.add_gate(Gate(\"RX\", target, parameter=0.0, is_variational=True))\n",
    "        circuit.add_gate(Gate(\"RZ\", target, parameter=0.0, is_variational=True))\n",
    "    return circuit\n",
    "\n",
    "def EntanglerCircuit(n_qubits):\n",
    "    \"\"\"Construct a circuit applying two columns of staggered CNOT gates to all qubits\n",
    "     and their neighbours\"\"\"\n",
    "    circuit = Circuit()\n",
    "    for ii in range(n_qubits//2):\n",
    "        circuit.add_gate(Gate(\"CNOT\", control=2*ii, target=2*ii + 1))\n",
    "    for ii in range(n_qubits//2 - 1):\n",
    "        circuit.add_gate(Gate(\"CNOT\", control=2*ii + 1, target=2*(ii+1)))\n",
    "    return circuit\n",
    "\n",
    "def HEACircuit(n_qubits, n_layers):\n",
    "    \"\"\"Construct a circuit consisting of alternating sequence of Euler rotations and entanglers\"\"\"\n",
    "    circuit = EulerCircuit(n_qubits)\n",
    "    for ii in range(n_layers):\n",
    "        circuit += EntanglerCircuit(n_qubits)\n",
    "        circuit += EulerCircuit(n_qubits)\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ansatz Class\n",
    "In the `VQESolver`, we are expecting an instance of an abstract `Ansatz` class, which will be responsible for constructing the variational circuit we use to minimize the energy of our problem. To build up our own `Ansatz` class, we'll require the following.\n",
    "\n",
    "0. **__init__**: an initialization function to instantiate the class.\n",
    "1. **set_var_params**: initialize the variational circuit parameters\n",
    "2. **update_var_params**: update the parametric gates in the circuit\n",
    "3. **prepare_reference_state**: get fixed circuit for initializing the reference, e.g. HF state.\n",
    "4. **build_circuit**: instantiate the variational circuit object\n",
    "\n",
    "Below, we're going to type out the entire class as we will use it. This is a lot of code in one place. So afterwards, we'll break it down into each of the relevant member methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HEA(Ansatz):\n",
    "\n",
    "    def __init__(self, n_spinorbitals, n_electrons, n_layers, mapping='jw'):\n",
    "\n",
    "        self.n_spinorbitals = n_spinorbitals\n",
    "        self.n_qubits = get_qubit_number(mapping, n_spinorbitals)\n",
    "        self.n_electrons = n_electrons\n",
    "        #number of layers of repeated entangler + Euler rotations\n",
    "        self.n_layers = n_layers\n",
    "        \n",
    "        #specify fermion-to-qubit mapping (required for the initial reference state)\n",
    "        self.mapping = mapping\n",
    "        \n",
    "        #Each layer has 3 variational parameters per qubit, and one non-variational entangler\n",
    "        #There is an additional layer with no entangler.\n",
    "        self.n_var_params = self.n_qubits * 3 * (self.n_layers + 1)\n",
    "\n",
    "        self.var_params = None\n",
    "        self.circuit = None\n",
    "\n",
    "    def set_var_params(self, var_params=None):\n",
    "        \"\"\"Set initial variational parameter values\"\"\"\n",
    "        if var_params is None:\n",
    "            var_params = np.random.random(self.n_var_params)\n",
    "        elif isinstance(var_params, str) and var_params == \"ones\":\n",
    "            var_params = np.ones(self.n_var_params, dtype=float)\n",
    "        elif len(var_params) != self.n_var_params:\n",
    "            raise ValueError('Invalid number of parameters.')\n",
    "        self.var_params = var_params\n",
    "        return var_params\n",
    "\n",
    "    def update_var_params(self, var_params):\n",
    "        \"\"\"Update variational parameters (done repeatedly during VQE)\"\"\"\n",
    "        for param_index in range(self.n_var_params):\n",
    "            self.circuit._variational_gates[param_index].parameter = var_params[param_index]\n",
    "    \n",
    "    def prepare_reference_state(self):\n",
    "        \"\"\"Prepare a circuit generating the HF reference state.\"\"\"\n",
    "        return get_reference_circuit(n_spinorbitals=self.n_spinorbitals, n_electrons=self.n_electrons,mapping=self.mapping)\n",
    "\n",
    "    def build_circuit(self, var_params=None):\n",
    "        \"\"\"Construct the variational circuit to be used as our ansatz.\"\"\"\n",
    "        self.var_params = self.set_var_params(var_params)\n",
    "\n",
    "        reference_state_circuit = self.prepare_reference_state()\n",
    "        hea_circuit = HEACircuit(self.n_qubits, self.n_layers)\n",
    "\n",
    "        if reference_state_circuit.size != 0:\n",
    "            self.circuit = reference_state_circuit + hea_circuit\n",
    "        else:\n",
    "            self.circuit = hea_circuit\n",
    "        return self.circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very briefly, we'll go through the member methods required to construct an `Ansatz` class. These code blocks duplicate the code above. We emphasize here that these member functions can be really as simple or as elaborate as you like.\n",
    "\n",
    "Let's start with `set_var_params`. We're going to do something very basic and just force this to be a random or all ones numpy array. We add some error handling in case the number of parameters is incompatible with the number of variational gates in the ansatz circuit. Have a look at the implementation of UCCSD to see how you can make this more fancy and interesting.\n",
    "\n",
    "```python\n",
    "def set_var_params(self, var_params=None):\n",
    "    if var_params is None:\n",
    "        var_params = np.random.random(self.n_var_params)\n",
    "    elif isinstance(var_params, str) and var_params == \"ones\":\n",
    "        var_params = np.ones(self.n_var_params, dtype=float)\n",
    "    elif len(var_params) != self.n_var_params:\n",
    "        raise ValueError('Invalid number of parameters.')\n",
    "    self.var_params = var_params\n",
    "    return var_params\n",
    "```\n",
    "\n",
    "Next, we'll implement `update_var_params`, where the circuit is updated with a new batch of variational parameters. The `tangelo.linq` Circuit class keeps a record of the variational gates in the circuit, making this update very straightforward, and avoids having to rebuild the circuit from scratch. All variational gates in the circuit are updated as per the `var_params` argument.\n",
    "\n",
    "```python\n",
    "def update_var_params(self, var_params):\n",
    "    for param_index in range(self.n_var_params):\n",
    "        self.circuit._variational_gates[param_index].parameter = var_params[param_index]\n",
    "```\n",
    "\n",
    "We'll use the methods from the `qubit_mappings` toolbox to construct a Hartree-Fock reference state. This will just generate a circuit with an X-gate applied to each qubit which we want to begin in the $|1\\rangle$ state.\n",
    "\n",
    "```python\n",
    "def prepare_reference_state(self):\n",
    "    circuit = get_reference_circuit(n_spinorbitals=self.n_spinorbitals, n_electrons=self.n_electrons, mapping=self.mapping)\n",
    "    return circuit\n",
    "```\n",
    "\n",
    "Finally, we'll implement the `build_circuit` method. As compared to the three others here, this is really the only method in the present case that requires much effort--everything else above has followed pretty boilerplate code. For this, we're just going to alternate between entanglers and Euler rotations, using the `HEACircuit` helper function we defined earlier. We then combine this with the Hartree Fock reference circuit. In the event that no qubits are instantiated as $|1\\rangle$, we skip this empty reference circuit.\n",
    "\n",
    "```python\n",
    "def build_circuit(self, var_params=None):\n",
    "    \"\"\"Construct the variational circuit to be used as our ansatz.\"\"\"\n",
    "    self.var_params = self.set_var_params(var_params)\n",
    "\n",
    "    reference_state_circuit = self.prepare_reference_state()\n",
    "    hea_circuit = HEACircuit(self.n_qubits, self.n_layers)\n",
    "\n",
    "    if reference_state_circuit.size != 0:\n",
    "        self.circuit = reference_state_circuit + hea_circuit\n",
    "    else:\n",
    "        self.circuit = hea_circuit\n",
    "    return self.circuit\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HEA-VQE on an H$_2$-dimer\n",
    "With the `Ansatz` so defined, we're ready to go ahead and build our VQE solver class, and run a calculation on a molecule of interest. I'm going to use the `SecondQuantizedMolecule` class to build a hydrogen dimer and run VQE on it using my custom ansatz. In the next section, I will also show how to run VQE with a custom qubit Hamiltonian that did not require passing a molecule.\n",
    "\n",
    "## Using a molecule object as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "H2 = [('H', (0, 0, 0)),('H', (0, 0, 0.74137727))]\n",
    "mol_H2 = SecondQuantizedMolecule(H2, q=0, spin=0, basis=\"sto-3g\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this molecule prepared, we're ready to instantiate our ansatz, and feed it into VQE. I'll access details of the molecule required to build our ansatz circuit (i.e. number of spin-orbitals and number of electrons) from the molecule object. Feel free to change the number of layers in the circuit, and explore how this changes VQE results, and timing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_spinorbitals = mol_H2.n_active_sos\n",
    "n_electrons = mol_H2.n_active_electrons\n",
    "hea_layers = 4\n",
    "HEA_ansatz = HEA(n_spinorbitals=n_spinorbitals, n_electrons=n_electrons, n_layers=hea_layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can instantiate the `VQESolver`, and run. We have decided to initialize all the variational parameters to ones through an option supported in the `set_var_params` of our `HEA` ansatz class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.1372335844997628"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vqe_options = {\"molecule\": mol_H2, \"qubit_mapping\": 'JW', 'ansatz': HEA_ansatz, \"initial_var_params\": \"ones\"}\n",
    "\n",
    "HEA_VQE = VQESolver(vqe_options)\n",
    "HEA_VQE.build()\n",
    "HEA_VQE.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using a custom qubit operator as input\n",
    "\n",
    "`VQESolver` can also directly take as input a custom qubit operator instead of computing a Hamiltonian starting from a molecule. This situation can be relevant in the case where one wants to perform VQE using a qubit Hamiltonian:\n",
    "* That does not correspond to a molecular system;\n",
    "* That has been tailored by the user (to reduce complexity or to study something specific);\n",
    "* That is too expensive to recompute.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As written in the previous section, it is possible to get the same result by providing `VQESolver` with a qubit Hamiltonian instead of a molecule. First, let's store the optimal variational parameters to use them as a starting point for comparison."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next step is to generate the qubit Hamiltonian. With the help of `MolecularData` and `fermion_to_qubit_mapping`, we are able to generate a fermionic Hamiltonian and transform it into operations doable on a quantum computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-0.09883484730799605+0j) [] +\n",
      "(-0.0453218839181063+0j) [X0 X1 Y2 Y3] +\n",
      "(0.0453218839181063+0j) [X0 Y1 Y2 X3] +\n",
      "(0.0453218839181063+0j) [Y0 X1 X2 Y3] +\n",
      "(-0.0453218839181063+0j) [Y0 Y1 X2 X3] +\n",
      "(0.17120123806595933+0j) [Z0] +\n",
      "(0.16862327595071597+0j) [Z0 Z1] +\n",
      "(0.1205461274055685+0j) [Z0 Z2] +\n",
      "(0.1658680113236748+0j) [Z0 Z3] +\n",
      "(0.1712012380659593+0j) [Z1] +\n",
      "(0.1658680113236748+0j) [Z1 Z2] +\n",
      "(0.1205461274055685+0j) [Z1 Z3] +\n",
      "(-0.22279639651093203+0j) [Z2] +\n",
      "(0.17434948757007063+0j) [Z2 Z3] +\n",
      "(-0.22279639651093205+0j) [Z3]\n"
     ]
    }
   ],
   "source": [
    "fermionic_hamiltonian_H2 = mol_H2.fermionic_hamiltonian\n",
    "qubit_hamiltonian_H2 = fermion_to_qubit_mapping(fermionic_hamiltonian_H2, mapping=\"jw\", n_spinorbitals=n_spinorbitals, n_electrons=n_electrons)\n",
    "print(qubit_hamiltonian_H2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notes**: Users can directly retrieve the qubit Hamiltonian object used in `VQESolver` by accessing its `qubit_hamiltonian` attribute.\n",
    "\n",
    "The dihydrogen molecule ground state energy is computed again from this qubit Hamiltonian (which is identical to the one used in the first part computed from the molecule)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.1372335844997628"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vqe_alternative_options = {\"qubit_hamiltonian\": qubit_hamiltonian_H2, 'ansatz': HEA_ansatz, \"initial_var_params\": \"ones\"}\n",
    "\n",
    "HEA_VQE_HAMILTONIAN = VQESolver(vqe_alternative_options)\n",
    "HEA_VQE_HAMILTONIAN.build()\n",
    "HEA_VQE_HAMILTONIAN.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The behaviour of VQE is identical to the previous one. Regarding chemical accuracy, how well did we do here? Let's compare against Hartree Fock and FCI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FCI ENERGY: -1.1372704 Ha\n",
      "HF ENERGY: -1.1166856 Ha\n",
      "HEA-VQE ENERGY (from molecule): -1.1372336 Ha\n",
      "HEA-VQE ENERGY (from qubit Hamiltonian): -1.1372336 Ha\n"
     ]
    }
   ],
   "source": [
    "energy_fci = FCISolver(mol_H2).simulate()\n",
    "energy_hf = mol_H2.mf_energy\n",
    "energy_vqe = HEA_VQE.optimal_energy\n",
    "energy_vqe_hamiltonian = HEA_VQE_HAMILTONIAN.optimal_energy\n",
    "print(f'FCI ENERGY: {energy_fci :.7f} Ha')\n",
    "print(f'HF ENERGY: {energy_hf :.7f} Ha')\n",
    "print(f'HEA-VQE ENERGY (from molecule): {energy_vqe :.7f} Ha')\n",
    "print(f'HEA-VQE ENERGY (from qubit Hamiltonian): {energy_vqe_hamiltonian :.7f} Ha')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using a custom circuit as input\n",
    "\n",
    "Lastly, it is possible to pass a pre-built arbitrary circuit with variational gates as input to `VQESolver`. In that case, `VQESolver` will optimize the variational parameters of these gates in order to minimize the cost function, which still requires a qubit Hamiltonian. This situation can be relevant to users who wish to apply variational approaches to arbitrary circuits or a circuit they got from other collaborators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circuit object. Size 74 \n",
      "\n",
      "X         target : [0]   \n",
      "X         target : [1]   \n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RX        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RX        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RX        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "RX        target : [3]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "CNOT      target : [1]   control : [0]   \n",
      "CNOT      target : [3]   control : [2]   \n",
      "CNOT      target : [2]   control : [1]   \n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RX        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RX        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RX        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "RX        target : [3]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "CNOT      target : [1]   control : [0]   \n",
      "CNOT      target : [3]   control : [2]   \n",
      "CNOT      target : [2]   control : [1]   \n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RX        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RX        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RX        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "RX        target : [3]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "CNOT      target : [1]   control : [0]   \n",
      "CNOT      target : [3]   control : [2]   \n",
      "CNOT      target : [2]   control : [1]   \n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RX        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RX        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RX        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "RX        target : [3]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "CNOT      target : [1]   control : [0]   \n",
      "CNOT      target : [3]   control : [2]   \n",
      "CNOT      target : [2]   control : [1]   \n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RX        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [0]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RX        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [1]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RX        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [2]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "RX        target : [3]   parameter : 0.0\t (variational)\n",
      "RZ        target : [3]   parameter : 0.0\t (variational)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "circuit = HEA_ansatz.build_circuit()\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dihydrogen energy is recomputed for the third time by using its qubit Hamiltonian and the abstract circuit provided. We are here optimizing the variational parameters of the pre-built circuit, in an attempt to return the minimal energy for this ansatz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.1372416894541575"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vqe_second_alternative_options = {\"qubit_hamiltonian\": qubit_hamiltonian_H2, \"ansatz\": circuit, \"initial_var_params\": \"random\"}\n",
    "\n",
    "HEA_VQE_CIRCUIT = VQESolver(vqe_second_alternative_options)\n",
    "HEA_VQE_CIRCUIT.build()\n",
    "HEA_VQE_CIRCUIT.simulate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: Users may also give `VQESolver` a `SecondQuantizedMolecule` with a custom circuit. The energy at the end is the very same as the previous calculations with a molecule + custom ansatz and a qubit Hamiltonian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HEA-VQE ENERGY (from a circuit): -1.1372417 Ha\n"
     ]
    }
   ],
   "source": [
    "energy_vqe_circuit = HEA_VQE_CIRCUIT.optimal_energy\n",
    "print(f'HEA-VQE ENERGY (from a circuit): {energy_vqe_circuit :.7f} Ha')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "In this tutorial, we've seen how to implement a custom ansatz circuit for VQE using the tools from `Tangelo` and how to combine it with a built-in or a custom qubit Hamiltonian. Hopefully, this gives some impression of how this platform is designed to help users construct their own workflows easily, focusing on the specific issues they are interested in studying without the distraction of building the supporting framework from scratch. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "qsdk",
   "language": "python",
   "name": "qsdk"
  },
  "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.10.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "95050af2697fca56ed7491a4fb0b04c1282c0de0a7e0a7cacd318a8297b0b1d8"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}