examples/variational_methods/iqcc_using_clifford.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterative Qubit Coupled Cluster using only Clifford circuits\n",
    "\n",
    "This notebook shows how to implement iQCC using only Clifford circuits with Tangelo, and accompanies a note released at [arXiv:2211.10501](https://arxiv.org/abs/2211.10501). We provide here the abstract of the article in this notebook for convenience and highlight the main steps of our implementation. Please refer to the article for full details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Abstract\n",
    "We draw attention to a variant of the iterative qubit coupled cluster (iQCC) method that only\n",
    "uses Clifford circuits. The iQCC method relies on a small parameterized wave function ansatz, which\n",
    "takes form as a product of exponentiated Pauli word operators, to approximate the ground state\n",
    "electronic energy of a mean field reference state through iterative qubit Hamiltonian transformations.\n",
    "In this variant of the iQCC method, the wave function ansatz at each iteration is restricted to a single\n",
    "exponentiated Pauli word operator and parameter. The Rotosolve algorithm utilizes Hamiltonian\n",
    "expectation values computed with Clifford circuits to optimize the single-parameter Pauli word\n",
    "ansatz. Although the exponential growth of Hamiltonian terms is preserved with this variation\n",
    "of iQCC, we suggest several methods to mitigate this effect. This method is useful for near-term\n",
    "variational quantum algorithm applications as it generates good initial parameters by using Clifford\n",
    "circuits which can be efficiently simulated on a classical computers according to the Gottesman–Knill\n",
    "theorem. It may also be useful beyond the NISQ era to create short-depth Clifford pre-optimized\n",
    "circuits that improve the success probability for fault-tolerant algorithms such as phase estimation."
   ]
  },
  {
   "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": "markdown",
   "metadata": {},
   "source": [
    "### Define Clifford simulator\n",
    "\n",
    "We define a Clifford simulator using cirq. This is a child class of `CirqSimulator` where we overwrite `simulate_circuit` and use `cirq.CliffordSimulator`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from tangelo.linq import Circuit\n",
    "from tangelo.linq.target.target_cirq import CirqSimulator\n",
    "from tangelo.linq.target.backend import Backend\n",
    "from tangelo.linq.translator import translate_circuit as translate\n",
    "\n",
    "class CirqCliffordSimulator(CirqSimulator):\n",
    "\n",
    "    def simulate_circuit(self, source_circuit: Circuit, return_statevector=False, initial_statevector=None, save_mid_circuit_meas=None):\n",
    "        \"\"\"Perform state preparation corresponding to the input circuit using cirq.CliffordSimulator\n",
    "\n",
    "        Args:\n",
    "            source_circuit: a circuit in the Tangelo format to be translated\n",
    "            return_statevector (bool): option to return the statevector.\n",
    "            initial_statevector(list/array) : Not currently supported\n",
    "            save_mid_circuit_meas (bool): Option to save mid circuit measurement values\n",
    "\n",
    "        Returns:\n",
    "            dict: A dictionary mapping multi-qubit states to their corresponding frequency.\n",
    "            numpy.array: The statevector, if available for the target backend\n",
    "                and requested by the user (if not, set to None).\n",
    "        \"\"\"\n",
    "\n",
    "        cirq_circuit = translate(source_circuit, \"cirq\")\n",
    "        self.circuit = cirq_circuit\n",
    "\n",
    "        cirq_simulator = self.cirq.CliffordSimulator()\n",
    "\n",
    "        self.result = cirq_simulator.simulate(cirq_circuit)\n",
    "        self._current_state = self.result.final_state.to_numpy()\n",
    "        frequencies = self._statevector_to_frequencies(self._current_state)\n",
    "\n",
    "        # If requested, set initial state\n",
    "        if initial_statevector is not None:\n",
    "            raise ValueError(f\"Initial statevector is not currently supported in {self.__class__}\")\n",
    "\n",
    "        return (frequencies, self._current_state) if return_statevector else (frequencies, None)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class that implements iQCC using only Clifford circuits\n",
    "The `iQCConlyClifford` class is defined as a child class of `ADAPTSolver` and replaces the `simulate` and `rank_pool` functions. A non-clifford backend is used only to check that the full circuit obtains the same energy using the original qubit hamiltonian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Type\n",
    "from copy import deepcopy\n",
    "\n",
    "from tangelo.algorithms import ADAPTSolver\n",
    "from tangelo.linq import Circuit\n",
    "from tangelo.toolboxes.operators import QubitOperator\n",
    "from tangelo.toolboxes.ansatz_generator.ansatz_utils import get_exponentiated_qubit_operator_circuit\n",
    "from tangelo.toolboxes.molecular_computation.molecule import SecondQuantizedMolecule\n",
    "from tangelo.toolboxes.qubit_mappings.mapping_transform import fermion_to_qubit_mapping\n",
    "from tangelo.toolboxes.ansatz_generator._qubit_cc import get_dis_groups, get_gens_from_idxs\n",
    "from tangelo.toolboxes.ansatz_generator._qubit_mf import init_qmf_from_hf\n",
    "from tangelo.toolboxes.ansatz_generator._qubit_cc import qcc_op_dress\n",
    "\n",
    "\n",
    "class iQCConlyClifford(ADAPTSolver):\n",
    "    \"\"\"iQCC using only Clifford Class. This is an iterative algorithm that uses Clifford circuits\n",
    "    along with Rotosolve to rank single Pauli word operators and obtain its optimal energy and rotation.\n",
    "\n",
    "    Attributes:\n",
    "        molecule (SecondQuantizedMolecule): The molecular system.\n",
    "        tol (float): Maximum gradient allowed for a particular operator  before\n",
    "            convergence.\n",
    "        max_cycles (int): Maximum number of iterations for ADAPT.\n",
    "        pool (func): Function that returns a list of FermionOperator. Each\n",
    "            element represents excitation/operator that has an effect of the\n",
    "            total energy.\n",
    "        pool_args (dict) : The arguments for the pool function. Will be unpacked in\n",
    "            function call as pool(**pool_args)\n",
    "        qubit_mapping (str): One of the supported qubit mapping identifiers.\n",
    "        qubit_hamiltonian (QubitOperator-like): Self-explanatory.\n",
    "        up_then_down (bool): Spin orbitals ordering.\n",
    "        n_spinorbitals (int): Self-explanatory.\n",
    "        n_electrons (int): Self-explanatory.\n",
    "        optimizer (func): Optimization function for VQE minimization.\n",
    "        backend_options (dict): Backend options for the underlying VQE object.\n",
    "        verbose (bool): Flag for verbosity of VQE.\n",
    "        deflation_circuits (list[Circuit]): Deflation circuits to add an\n",
    "            orthogonalization penalty with.\n",
    "        deflation_coeff (float): The coefficient of the deflation.\n",
    "        ref_state (array or Circuit): The reference configuration to use. Replaces HF state\n",
    "        clifford_simulator(Type[Backend]): The clifford simulator used for the operator selection\n",
    "            and minimization.\n",
    "     \"\"\"\n",
    "\n",
    "    def __init__(self, opt_dict: dict, clifford_simulator: Type[Backend]):\n",
    "        super().__init__(opt_dict=opt_dict)\n",
    "        self.clifford_simulator = clifford_simulator\n",
    "        self.qu_op_length = []\n",
    "\n",
    "    def rank_pool(self, circuit: Circuit, backend: Type[Backend]):\n",
    "        \"\"\"Rank pool of operators with a specific circuit.\n",
    "\n",
    "        Args:\n",
    "            reference_circuit (tangelo.linq.Circuit): Reference circuit that only uses Clifford gates\n",
    "            backend (tangelo.linq.backend): Clifford backend to compute expectation values as child class of Backend\n",
    "\n",
    "        Returns:\n",
    "            int: Index of the operators with the highest gradient. If it is not\n",
    "                bigger than tolerance, returns -1.\n",
    "        \"\"\"\n",
    "\n",
    "        if len(self.vqe_solver.ansatz.operators) > 0:\n",
    "            dressed_qu_op = qcc_op_dress(deepcopy(self.qubit_hamiltonian), self.vqe_solver.ansatz.operators[::-1],\n",
    "                                                  self.vqe_solver.optimal_var_params[::-1])\n",
    "            self.energies[-1] = backend.get_expectation_value(dressed_qu_op, self.vqe_solver.ansatz.prepare_reference_state())\n",
    "            print(\"Dressed Hamiltonian, same initial state energy\", self.energies[-1])\n",
    "        else:\n",
    "            dressed_qu_op = self.qubit_hamiltonian\n",
    "\n",
    "        self.qu_op_length.append(len(dressed_qu_op.terms))\n",
    "        self.pool_operators = self.pool(self.molecule, self.qubit_mapping, self.up_then_down, dressed_qu_op)\n",
    "\n",
    "        len_pool = len(self.pool_operators)\n",
    "        thetas = np.zeros(len_pool)\n",
    "        eners = np.zeros(len_pool)\n",
    "        for i, pool_op in enumerate(self.pool_operators):\n",
    "            # get_exponentiated_qubit_operator_circuit multiplies time by 2\n",
    "            cpl = get_exponentiated_qubit_operator_circuit(pool_op, time=np.pi/4)\n",
    "            cmi = get_exponentiated_qubit_operator_circuit(pool_op, time=-np.pi/4)\n",
    "\n",
    "            epl = backend.get_expectation_value(dressed_qu_op, circuit+cpl)\n",
    "            emi = backend.get_expectation_value(dressed_qu_op, circuit+cmi)\n",
    "\n",
    "            ener = self.energies[-1]\n",
    "            theta_min = -0.5 * np.pi - np.arctan2(2. * ener - epl - emi, epl - emi)\n",
    "            a = 0.5*np.sqrt((2*ener-epl-emi)**2+(epl-emi)**2)\n",
    "            b = np.arctan2(2. * ener - epl - emi, epl - emi)\n",
    "            c = 1/2*(epl+emi)\n",
    "            eners[i] = a*np.sin(theta_min+b)+c\n",
    "            thetas[i] = theta_min\n",
    "\n",
    "        index = np.argmin(eners)\n",
    "        self.new_param = thetas[index]\n",
    "        if self.verbose:\n",
    "            print(f'Chosen parameter is {self.new_param} with energy {eners[index]}')\n",
    "\n",
    "        return index if self.energies[-1]-eners[index] > self.tol else -1\n",
    "\n",
    "    def simulate(self):\n",
    "        \"\"\"Performs the iQCC cycles. No VQE minimization is performed but there is a check of the full circuit\n",
    "        with the initial Hamiltonian\n",
    "        \"\"\"\n",
    "\n",
    "        params = self.vqe_solver.ansatz.var_params\n",
    "        self.new_param = 0.\n",
    "\n",
    "        self.energies.append(self.vqe_solver.energy_estimation([]))\n",
    "\n",
    "        # Construction of the ansatz. self.max_cycles terms are added, unless\n",
    "        # all operator gradients are less than self.tol.\n",
    "        while self.iteration < self.max_cycles:\n",
    "            self.iteration += 1\n",
    "            if self.verbose:\n",
    "                print(f\"\\n Iteration {self.iteration} of iQCC using only Clifford circuits.\")\n",
    "\n",
    "            ref_circuit = (self.vqe_solver.ansatz.prepare_reference_state() if self.ref_state is None else\n",
    "                            self.vqe_solver.reference_circuit + self.vqe_solver.ansatz.prepare_reference_state())\n",
    "\n",
    "            pool_select = self.rank_pool(ref_circuit,\n",
    "                                         backend=self.clifford_simulator)\n",
    "\n",
    "            # If pool selection returns an operator that changes the energy by\n",
    "            # more than self.tol. Else, the loop is complete and the energy is\n",
    "            # considered as converged.\n",
    "            if pool_select > -1:\n",
    "\n",
    "                # Adding a new operator to beginning of operator list\n",
    "                # Previous parameters are kept as they were.\n",
    "                self.vqe_solver.ansatz.operators = [self.pool_operators[pool_select]] + self.vqe_solver.ansatz.operators\n",
    "                params = [self.new_param] if self.vqe_solver.optimal_var_params is None else [self.new_param] + list(self.vqe_solver.optimal_var_params)\n",
    "                \n",
    "\n",
    "                self.vqe_solver.ansatz._n_terms_operators = [1] + self.vqe_solver.ansatz._n_terms_operators\n",
    "                self.vqe_solver.ansatz._var_params_prefactor = [1] + self.vqe_solver.ansatz._var_params_prefactor\n",
    "                self.vqe_solver.initial_var_params = params\n",
    "                self.vqe_solver.ansatz.build_circuit()\n",
    "\n",
    "                # Non-clifford simulator used to verify that the energy is the same as determined using the Clifford simulator.\n",
    "                self.vqe_solver.optimal_energy = self.vqe_solver.energy_estimation(params)\n",
    "                if self.verbose:\n",
    "                    print(f\"Full circuit with original Hamiltonian energy = {self.vqe_solver.optimal_energy}\")\n",
    "                self.vqe_solver.optimal_var_params = params\n",
    "\n",
    "                opt_energy = self.vqe_solver.optimal_energy\n",
    "                params = list(self.vqe_solver.optimal_var_params)\n",
    "                self.energies.append(opt_energy)\n",
    "            else:\n",
    "                self.converged = True\n",
    "                break\n",
    "\n",
    "        return self.energies[-1]\n",
    "\n",
    "def full_qcc_pool(mol: SecondQuantizedMolecule, mapping: str, up_then_down: bool, qubit_hamiltonian: QubitOperator):\n",
    "    \"\"\"Generate all possible generators in the DIS for qubit_hamiltonian\n",
    "    \n",
    "    Args:\n",
    "        mol (SecondQuantizedMolecule): The molecule to determine the DIS pool for.\n",
    "        mapping (str): One of the support qubit mappings\n",
    "        up_then_down (bool): Spin orbitals ordering. True is all alpha then beta orbitals. False is alternating.\n",
    "        qubit_hamiltonian (QubitOperator): The current dressed qubit hamiltonian.\n",
    "\n",
    "    Returns:\n",
    "        list: DIS pool operators\n",
    "    \"\"\"\n",
    "    qmf_var_params = init_qmf_from_hf(mol.n_active_sos, mol.n_active_electrons, \n",
    "                                      mapping, up_then_down, mol.spin)\n",
    "\n",
    "    dis, dis_groups = [], get_dis_groups(qubit_hamiltonian, qmf_var_params, 3.e-5)\n",
    "    for dis_group in dis_groups:\n",
    "        dis_group_idxs = [int(idxs) for idxs in dis_group[0].split(\" \")]\n",
    "        dis_group_gens = get_gens_from_idxs(dis_group_idxs)\n",
    "        dis.append(dis_group_gens)\n",
    "    dis_flat = [item for sublist in dis for item in sublist]\n",
    "    return dis_flat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running the algorithm for H<sub>3</sub>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Iteration 1 of iQCC using only Clifford circuits.\n",
      "Chosen parameter is 0.19497620390733506 with energy -1.5146298806979668\n",
      "Full circuit with original Hamiltonian energy = -1.514629880697965\n",
      "\n",
      " Iteration 2 of iQCC using only Clifford circuits.\n",
      "Dressed Hamiltonian, same initial state energy -1.5146298806979663\n",
      "Chosen parameter is -0.10349849269458078 with energy -1.5218965900518353\n",
      "Full circuit with original Hamiltonian energy = -1.5218965900518329\n",
      "\n",
      " Iteration 3 of iQCC using only Clifford circuits.\n",
      "Dressed Hamiltonian, same initial state energy -1.521896590051836\n",
      "Chosen parameter is 0.08657354901273173 with energy -1.5244271035716803\n",
      "Full circuit with original Hamiltonian energy = -1.5244271035716768\n",
      "\n",
      " Iteration 4 of iQCC using only Clifford circuits.\n",
      "Dressed Hamiltonian, same initial state energy -1.5244271035716799\n",
      "Chosen parameter is -0.08225117291478923 with energy -1.5267582996827964\n",
      "Full circuit with original Hamiltonian energy = -1.526758299682792\n",
      "\n",
      "The pool operators used are\n",
      "[1.0 [Y1 X4], 1.0 [Y5], 1.0 [Y1 X4 X5], 1.0 [Y0 X2 X3 X4]]\n",
      "with corresponding parameters\n",
      "[-0.08225117291478923, 0.08657354901273173, -0.10349849269458078, 0.19497620390733506]\n",
      "\n",
      " The final energy is -1.526758299682792 with error 0.0001887054536875432\n",
      "\n",
      " The number of H terms at each iteration is\n",
      "[62, 96, 125, 138]\n"
     ]
    }
   ],
   "source": [
    "from tangelo.toolboxes.molecular_computation.molecule import SecondQuantizedMolecule\n",
    "from tangelo.algorithms.classical import FCISolver\n",
    "\n",
    "# Define molecular system\n",
    "xyz_H3 = [\n",
    "    (\"H\", (0., 0., 0.)),\n",
    "    (\"H\", (0., 0., 0.7414)),\n",
    "    (\"H\", (0., 0., 2*0.7414))\n",
    "]\n",
    "mol = SecondQuantizedMolecule(xyz_H3, q=0, spin=1, basis=\"sto-3g\")\n",
    "max_cycles = 4\n",
    "\n",
    "# Calculate reference FCI energy\n",
    "cc = FCISolver(mol)\n",
    "exact = cc.simulate()\n",
    "\n",
    "mapping = \"JKMN\"\n",
    "\n",
    "qu_op = fermion_to_qubit_mapping(mol.fermionic_hamiltonian, mapping, mol.n_active_sos, mol.n_active_electrons, up_then_down=False, spin=mol.active_spin)\n",
    "pool_args = {\"mol\": mol, \"mapping\": mapping, \"up_then_down\": False, \"qubit_hamiltonian\": qu_op}\n",
    "\n",
    "backend_options = {}  # {\"target\": QulacsSimulator}\n",
    "opt_dict = {\"molecule\": mol, \"tol\": 1.e-9, \"max_cycles\": max_cycles, \"verbose\": True,\n",
    "            \"qubit_mapping\": mapping, \"n_spinorbitals\": mol.n_active_sos, \"n_electrons\": mol.n_active_electrons, \n",
    "            \"pool\": full_qcc_pool, \"pool_args\": pool_args, \"up_then_down\": False, \"backend_options\": backend_options}\n",
    "\n",
    "iQCC_C_solver = iQCConlyClifford(opt_dict, CirqCliffordSimulator())\n",
    "iQCC_C_solver.build()\n",
    "iQCC_C_solver.simulate()\n",
    "print(\"\\nThe pool operators used are\")\n",
    "print(iQCC_C_solver.ansatz.operators)\n",
    "print(\"with corresponding parameters\")\n",
    "print(iQCC_C_solver.vqe_solver.optimal_var_params)\n",
    "print(f\"\\n The final energy is {iQCC_C_solver.energies[-1]} with error {iQCC_C_solver.energies[-1]-exact}\")\n",
    "print(\"\\n The number of H terms at each iteration is\")\n",
    "print(iQCC_C_solver.qu_op_length)\n",
    "#adapt_circ = adapt_solver.vqe_solver.optimal_circuit\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plots of energy convergence and growth of Hamiltonian terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1306a0ca0>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "fig.set_size_inches(16, 8)\n",
    "\n",
    "ax1.set_xticks(list(range(len(iQCC_C_solver.energies))))\n",
    "ax1.set_title(\"Energy convergence\", fontdict={\"size\": 20})\n",
    "ax1.set_xlabel(\"Iteration Number\", fontdict={\"size\": 14})\n",
    "ax1.set_ylabel(\"Energy Error (Hartree)\", fontdict={\"size\": 14})\n",
    "ax1.semilogy(range(len(iQCC_C_solver.energies)), np.abs(iQCC_C_solver.energies-exact), \"-x\" )\n",
    "\n",
    "ax2.set_title(\"Hamiltonian Growth\", fontdict={\"size\": 20})\n",
    "ax2.set_ylabel(\"# H terms\", fontdict={\"size\": 14})\n",
    "ax2.set_xticks(list(range(len(iQCC_C_solver.qu_op_length))))\n",
    "ax2.set_xlabel(\"Iteration #\", fontdict={\"size\": 14})\n",
    "ax2.semilogy(list(range(len(iQCC_C_solver.qu_op_length))), iQCC_C_solver.qu_op_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizing interior generators\n",
    "\n",
    "Below is the method highlighted in the manuscript to optimize interior generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tangelo.linq import get_backend, Gate, Circuit\n",
    "dressed_qu_op = qcc_op_dress(deepcopy(iQCC_C_solver.qubit_hamiltonian),\n",
    "                             iQCC_C_solver.vqe_solver.ansatz.operators[::-1],\n",
    "                             iQCC_C_solver.vqe_solver.optimal_var_params[::-1])\n",
    "ref_circ = iQCC_C_solver.vqe_solver.ansatz.prepare_reference_state()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize_interior_generator(op_index, ref_circ):\n",
    "    dressed_qu_op = qcc_op_dress(deepcopy(iQCC_C_solver.qubit_hamiltonian),\n",
    "                                 list(reversed(iQCC_C_solver.vqe_solver.ansatz.operators[op_index+1:4])),\n",
    "                                 list(reversed(iQCC_C_solver.vqe_solver.optimal_var_params[op_index+1:4])))\n",
    "    dressed_ref_qu_op = QubitOperator((), 1)\n",
    "    for i in range(op_index-1, -1, -1):\n",
    "        p = iQCC_C_solver.vqe_solver.optimal_var_params[i]\n",
    "        q = iQCC_C_solver.vqe_solver.ansatz.operators[i]\n",
    "        dressed_ref_qu_op *= (np.cos(p/2)*QubitOperator((), 1) - 1j*np.sin(p/2)*q)\n",
    "\n",
    "    # CirqCliffordSimulator is very slow but does work\n",
    "    # sim = CirqCliffordSimulator()\n",
    "    # Use default simulator instead, ideally qulacs is installed\n",
    "    sim = get_backend()\n",
    "    \n",
    "\n",
    "    expect0 = 0\n",
    "    expectpl = 0\n",
    "    expectmi = 0\n",
    "    circpl = get_exponentiated_qubit_operator_circuit(iQCC_C_solver.ansatz.operators[op_index], time=np.pi/4)\n",
    "    circmi = get_exponentiated_qubit_operator_circuit(iQCC_C_solver.ansatz.operators[op_index], time=-np.pi/4)\n",
    "    circ0 = get_exponentiated_qubit_operator_circuit(iQCC_C_solver.ansatz.operators[op_index], time=0)\n",
    "\n",
    "    zero_one_qu_op = QubitOperator(\"X6\") + QubitOperator(\"Y6\", 1j)\n",
    "\n",
    "    for term1, coeff1 in dressed_ref_qu_op.terms.items():\n",
    "        ref_circ1 = Circuit([Gate(\"C\"+op, q, 6) for q, op in term1], n_qubits=7)\n",
    "\n",
    "        for term2, coeff2 in dressed_ref_qu_op.terms.items():\n",
    "            ref_circ2 = Circuit([Gate(\"C\"+op, q, 6) for q, op in term2], n_qubits=7)\n",
    "\n",
    "            prep_12_circuit = ref_circ + Circuit([Gate(\"H\", 6)]) + ref_circ1 + Circuit([Gate(\"X\", 6)]) + ref_circ2\n",
    "\n",
    "            for hterm, hcoeff in dressed_qu_op.terms.items():\n",
    "                qu_circ = Circuit([Gate(\"C\"+op, q, 6) for q, op in hterm], n_qubits=7)\n",
    "                \n",
    "                plus_circ = prep_12_circuit + circpl + qu_circ + Circuit([Gate(\"X\", 6)])\n",
    "                expectpl += sim.get_expectation_value(zero_one_qu_op, plus_circ) * coeff1 * np.conj(coeff2) * hcoeff\n",
    "                \n",
    "                minus_circ = prep_12_circuit + circmi + qu_circ + Circuit([Gate(\"X\", 6)])\n",
    "                expectmi += sim.get_expectation_value(zero_one_qu_op, minus_circ) * coeff1 * np.conj(coeff2) * hcoeff\n",
    "\n",
    "                zero_circ = prep_12_circuit + circ0 + qu_circ + Circuit([Gate(\"X\", 6)])\n",
    "                expect0 += sim.get_expectation_value(zero_one_qu_op, zero_circ) * coeff1 * np.conj(coeff2) * hcoeff\n",
    "    ener= expect0.real\n",
    "    epl = expectpl.real\n",
    "    emi = expectmi.real\n",
    "    theta_min = -0.5 * np.pi - np.arctan2(2. * ener - epl - emi, epl - emi)\n",
    "    a = 0.5*np.sqrt((2*ener-epl-emi)**2+(epl-emi)**2)\n",
    "    b = np.arctan2(2. * ener - epl - emi, epl - emi)\n",
    "    c = 1/2*(epl+emi)\n",
    "    new_energy = a*np.sin(theta_min+b)+c\n",
    "\n",
    "    return theta_min, new_energy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform one rotosolve sweep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iQCC using only Clifford circuits results in energy -1.526758299682792 with error 0.0001887054536875432\n",
      "\n",
      " Optimizing operator 3 results in new energy of -1.5268018129766077\n",
      "The calculated new energy is -1.5268018129766032 with error 0.00014519215987629508\n",
      "\n",
      " Optimizing operator 2 results in new energy of -1.5268018780136394\n",
      "The calculated new energy is -1.526801878013637 with error 0.0001451271228425366\n",
      "\n",
      " Optimizing operator 1 results in new energy of -1.5268303820972458\n",
      "The calculated new energy is -1.5268303820972426 with error 0.0001166230392368739\n",
      "\n",
      " Optimizing operator 0 results in new energy of -1.5268319664163135\n",
      "The calculated new energy is -1.5268319664163104 with error 0.00011503872016915828\n"
     ]
    }
   ],
   "source": [
    "starting_energy = iQCC_C_solver.vqe_solver.energy_estimation(iQCC_C_solver.vqe_solver.optimal_var_params)\n",
    "print(f\"iQCC using only Clifford circuits results in energy {starting_energy} with error {starting_energy-exact}\")\n",
    "\n",
    "# Start at max_cycles-1 as operator 0 was the last optimized.\n",
    "for op_index in range(max_cycles-1, -1, -1):\n",
    "    theta_min, new_energy = optimize_interior_generator(op_index, ref_circ)\n",
    "    print(f\"\\n Optimizing operator {op_index} results in new energy of {new_energy}\")\n",
    "    iQCC_C_solver.vqe_solver.optimal_var_params[op_index] = theta_min\n",
    "    calculated_new_energy = iQCC_C_solver.vqe_solver.energy_estimation(iQCC_C_solver.vqe_solver.optimal_var_params)\n",
    "    print(f\"The calculated new energy is {calculated_new_energy} with error {calculated_new_energy-exact}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Closing words\n",
    "\n",
    "This notebook shows that a variant of iQCC can be implemented while only using Clifford circuits as described in our [manuscript](https://arxiv.org/abs/2211.10501). This method can be used to initialize the QCC ansatz for VQE or to create short depth circuits that improve the success probability of fault-tolerant algorithms such as phase estimation. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "95050af2697fca56ed7491a4fb0b04c1282c0de0a7e0a7cacd318a8297b0b1d8"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}