time_test_caching_estimator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-27T13:41:07.878080Z",
     "start_time": "2021-04-27T13:41:05.980627Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import h5py\n",
    "import sys\n",
    "import time\n",
    "from collections import defaultdict\n",
    "from collections.abc import Iterable, Sequence\n",
    "from functools import lru_cache\n",
    "\n",
    "cache = lru_cache(maxsize=None)\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from qiskit.circuit import Instruction, Parameter, QuantumCircuit\n",
    "from qiskit.exceptions import QiskitError\n",
    "from qiskit.opflow import PauliSumOp\n",
    "from qiskit.primitives import BaseEstimator, EstimatorResult\n",
    "from qiskit.primitives.utils import init_circuit, init_observable\n",
    "from qiskit.quantum_info import Statevector\n",
    "from qiskit.quantum_info.operators.base_operator import BaseOperator\n",
    "\n",
    "from qiskit.circuit import QuantumCircuit, Parameter\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "\n",
    "from qiskit.algorithms.optimizers import SPSA\n",
    "from qiskit.algorithms.optimizers.spsa import powerseries\n",
    "\n",
    "from qiskit_nature.drivers import Molecule, QMolecule\n",
    "from qiskit_nature.properties.second_quantization.electronic.bases import ElectronicBasis\n",
    "from qiskit_nature.transformers.second_quantization.electronic.active_space_transformer import ActiveSpaceTransformer\n",
    "from qiskit_nature.drivers.second_quantization import PySCFDriver, HDF5Driver\n",
    "from qiskit_nature.problems.second_quantization import ElectronicStructureProblem\n",
    "from qiskit_nature.mappers.second_quantization import JordanWignerMapper, ParityMapper\n",
    "from qiskit_nature.converters.second_quantization import QubitConverter\n",
    "from qiskit_nature.algorithms.ground_state_solvers import (\n",
    "    GroundStateEigensolver,\n",
    "    NumPyMinimumEigensolverFactory,\n",
    ")\n",
    "\n",
    "from circuit_knitting_toolbox.entanglement_forging import (\n",
    "    EntanglementForgingKnitter,\n",
    "    EntanglementForgingDriver,\n",
    ")\n",
    "from circuit_knitting_toolbox.decompose import CholeskyDecomposition\n",
    "\n",
    "class CachingEstimator(BaseEstimator):\n",
    "    \"\"\"\n",
    "    Reference implementation of :class:`BaseEstimator`.\n",
    "    :Run Options:\n",
    "        - **shots** (None or int) --\n",
    "          The number of shots. If None, it calculates the exact expectation\n",
    "          values. Otherwise, it samples from normal distributions with standard errors as standard\n",
    "          deviations using normal distribution approximation.\n",
    "        - **seed** (np.random.Generator or int) --\n",
    "          Set a fixed seed or generator for the normal distribution. If shots is None,\n",
    "          this option is ignored.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        circuits: QuantumCircuit | Iterable[QuantumCircuit],\n",
    "        observables: BaseOperator | PauliSumOp | Iterable[BaseOperator | PauliSumOp],\n",
    "        parameters: Iterable[Iterable[Parameter]] | None = None,\n",
    "    ):\n",
    "        if isinstance(circuits, QuantumCircuit):\n",
    "            circuits = (circuits,)\n",
    "        circuits = tuple(init_circuit(circuit) for circuit in circuits)\n",
    "\n",
    "        if isinstance(observables, (PauliSumOp, BaseOperator)):\n",
    "            observables = (observables,)\n",
    "        observables = tuple(init_observable(observable) for observable in observables)\n",
    "\n",
    "        super().__init__(\n",
    "            circuits=circuits,\n",
    "            observables=observables,\n",
    "            parameters=parameters,\n",
    "        )\n",
    "        self._is_closed = False\n",
    "\n",
    "    ################################################################################\n",
    "    ## INTERFACE\n",
    "    ################################################################################\n",
    "    def _call(\n",
    "        self,\n",
    "        circuits: Sequence[int],\n",
    "        observables: Sequence[int],\n",
    "        parameter_values: Sequence[Sequence[float]],\n",
    "        **run_options,\n",
    "    ) -> EstimatorResult:\n",
    "        if self._is_closed:\n",
    "            raise QiskitError(\"The primitive has been closed.\")\n",
    "\n",
    "        # Rename for clarity\n",
    "        circuit_indices = circuits\n",
    "        observable_indices = observables\n",
    "        parameter_values_list = parameter_values\n",
    "        del circuits, observables, parameter_values\n",
    "\n",
    "        # Parse options\n",
    "        shots = run_options.pop(\"shots\", None)\n",
    "        rng = self._parse_rng_from_seed(run_options.pop(\"seed\", None))\n",
    "\n",
    "        # Initialize\n",
    "        states = [\n",
    "            self._build_statevector(circuit_index, tuple(parameter_values))\n",
    "            for circuit_index, parameter_values in zip(\n",
    "                circuit_indices, parameter_values_list\n",
    "            )\n",
    "        ]\n",
    "        observables = [self._observables[i] for i in observable_indices]\n",
    "\n",
    "        # Solve\n",
    "        raw_results = [\n",
    "            self._compute_result(state, observable, shots, rng)\n",
    "            for state, observable in zip(states, observables)\n",
    "        ]\n",
    "        expectation_values, metadata = zip(*raw_results)\n",
    "\n",
    "        return EstimatorResult(np.array(expectation_values), metadata)\n",
    "\n",
    "    def close(self):\n",
    "        self._is_closed = True\n",
    "\n",
    "    ################################################################################\n",
    "    ## UTILS\n",
    "    ################################################################################\n",
    "    def _bind_circuit_parameters(\n",
    "        self, circuit_index: int, parameter_values: tuple[float]\n",
    "    ) -> QuantumCircuit:\n",
    "        parameters = self._parameters[circuit_index]\n",
    "        if len(parameter_values) != len(parameters):\n",
    "            raise ValueError(\n",
    "                f\"The number of values ({len(parameter_values)}) does not match \"\n",
    "                f\"the number of parameters ({len(parameters)}).\"\n",
    "            )\n",
    "        circuit = self._circuits[circuit_index]\n",
    "        if not parameter_values:\n",
    "            return circuit\n",
    "        parameter_mapping = dict(zip(parameters, parameter_values))\n",
    "        return circuit.bind_parameters(parameter_mapping)\n",
    "\n",
    "    @cache  # Enables memoization (tuples are hashable)\n",
    "    def _build_statevector(\n",
    "        self, circuit_index: int, parameter_values: tuple[float]\n",
    "    ) -> Statevector:\n",
    "        circuit = self._bind_circuit_parameters(circuit_index, parameter_values)\n",
    "        instruction = circuit.to_instruction()\n",
    "        return Statevector(instruction)\n",
    "\n",
    "    def _compute_result(\n",
    "        self, state: Statevector, observable: BaseOperator | PauliSumOp, shots: int, rng\n",
    "    ) -> tuple[float, dict]:\n",
    "        if state.num_qubits != observable.num_qubits:\n",
    "            raise QiskitError(\n",
    "                f\"The number of qubits of a circuit ({state.num_qubits}) does not match \"\n",
    "                f\"the number of qubits of a observable ({observable.num_qubits}).\"\n",
    "            )\n",
    "        expectation_value = np.real_if_close(state.expectation_value(observable))\n",
    "        metadatum = {}\n",
    "        if shots is not None:\n",
    "            sq_obs = (observable @ observable).simplify()\n",
    "            sq_exp_val = np.real_if_close(state.expectation_value(sq_obs))\n",
    "            variance = sq_exp_val - expectation_value**2\n",
    "            standard_deviation = np.sqrt(variance / shots)\n",
    "            expectation_value = rng.normal(expectation_value, standard_deviation)\n",
    "            metadatum[\"variance\"] = variance\n",
    "            metadatum[\"shots\"] = shots\n",
    "        return float(expectation_value), metadatum\n",
    "\n",
    "    def _parse_rng_from_seed(self, seed: None | int | np.random.Generator):\n",
    "        if seed is None:\n",
    "            return np.random.default_rng()\n",
    "        elif isinstance(seed, np.random.Generator):\n",
    "            return seed\n",
    "        else:\n",
    "            return np.random.default_rng(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the $CH_3$ molecule, define the active space transform, and instantiate an ElectronicStructureProblem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-27T13:41:07.934705Z",
     "start_time": "2021-04-27T13:41:07.880717Z"
    }
   },
   "outputs": [],
   "source": [
    "# Define a molecular system of interest - Methyl radical \n",
    "molecule = Molecule(\n",
    "    geometry= [['C',[0.0, 0.0, 0.00]],\n",
    "                ['H',[1.0790, 0.0, 0.00]],\n",
    "                ['H',[-0.5395, -0.9344, 0.00]],\n",
    "                ['H',[-0.5395, 0.9344, 0.00]]],\n",
    "    charge=0,\n",
    "    multiplicity=2,\n",
    ")\n",
    "\n",
    "driver = PySCFDriver.from_molecule(molecule=molecule, basis=\"sto-3g\")\n",
    "converter = QubitConverter(JordanWignerMapper())\n",
    "\n",
    "# Construct an active space composed of 6 molecular orbitals \n",
    "transformer = ActiveSpaceTransformer(num_electrons=(3,2), num_molecular_orbitals=6)\n",
    "problem_reduced = ElectronicStructureProblem(driver, [transformer])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieve the one and two-body integrals and the nuclear repulsion energy. These will be used to decompose the operator into a bipartite system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_fermionic = problem_reduced.second_q_ops()[0]\n",
    "electronic_energy_object = problem_reduced.grouped_property_transformed.get_property(\n",
    "    \"ElectronicEnergy\"\n",
    ")\n",
    "energy_shift = (\n",
    "    electronic_energy_object._shift[\"ActiveSpaceTransformer\"]\n",
    "    + electronic_energy_object._nuclear_repulsion_energy\n",
    ")\n",
    "\n",
    "# These are the integrals in the molecular orbital basis retrieved from the 6 orbital active space.\n",
    "one_body_integrals_alpha = electronic_energy_object.get_electronic_integral(\n",
    "    ElectronicBasis.MO, 1\n",
    ")._matrices[0]\n",
    "one_body_integrals_beta = electronic_energy_object.get_electronic_integral(\n",
    "    ElectronicBasis.MO, 1\n",
    ")._matrices[1]\n",
    "\n",
    "two_body_integrals_alpha_alpha = electronic_energy_object.get_electronic_integral(\n",
    "    ElectronicBasis.MO, 2\n",
    ")._matrices[0]\n",
    "two_body_integrals_beta_alpha = electronic_energy_object.get_electronic_integral(\n",
    "    ElectronicBasis.MO, 2\n",
    ")._matrices[1]\n",
    "two_body_integrals_beta_beta = electronic_energy_object.get_electronic_integral(\n",
    "    ElectronicBasis.MO, 2\n",
    ")._matrices[2]\n",
    "two_body_integrals_alpha_beta = electronic_energy_object.get_electronic_integral(\n",
    "    ElectronicBasis.MO, 2\n",
    ")._matrices[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an ElectronicStructureProblem from our EF Driver and perform second quantization transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver = EntanglementForgingDriver(\n",
    "    hcore=one_body_integrals_alpha,\n",
    "    mo_coeff=np.eye(6, 6),\n",
    "    eri=two_body_integrals_alpha_alpha,\n",
    "    num_alpha=3,\n",
    "    num_beta=2,\n",
    "    nuclear_repulsion_energy=energy_shift,\n",
    ")\n",
    "problem = ElectronicStructureProblem(driver)\n",
    "ops = problem.second_q_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare the bitstrings and the ansatz. \n",
    "\n",
    "The ansatz for Entanglement Forging consists of a set of input bitstrings and a parameterized ansatz. If only one set of bitstrings is passed, it will be used for both subsystems. For this demo, we will specify different bitstrings for each subsystem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-27T13:41:08.939346Z",
     "start_time": "2021-04-27T13:41:08.501552Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                                                                         ┌───────────────┐                                                                        \n",
       "q_0: ────────────────────────────────────────────────────────────────────┤0              ├────────────────────────────────────────────────────────────────────────\n",
       "                                                        ┌───────────────┐│  Hop gate(θ8) │┌───────────────┐                                                       \n",
       "q_1: ───────────────────────────────────────────────────┤0              ├┤1              ├┤0              ├───────────────────────────────────────────────────────\n",
       "                                       ┌───────────────┐│  Hop gate(θ4) │├───────────────┤│  Hop gate(θ9) │ ┌────────────────┐                                    \n",
       "q_2: ──────────────────────────────────┤0              ├┤1              ├┤0              ├┤1              ├─┤0               ├────────────────────────────────────\n",
       "                      ┌───────────────┐│  Hop gate(θ2) │├───────────────┤│  Hop gate(θ7) │├───────────────┴┐│  Hop gate(θ11) │┌────────────────┐                  \n",
       "q_3: ─────────────────┤0              ├┤1              ├┤0              ├┤1              ├┤0               ├┤1               ├┤0               ├──────────────────\n",
       "     ┌───────────────┐│  Hop gate(θ1) │├───────────────┤│  Hop gate(θ5) │├───────────────┤│  Hop gate(θ10) │├────────────────┤│  Hop gate(θ13) │┌────────────────┐\n",
       "q_4: ┤0              ├┤1              ├┤0              ├┤1              ├┤0              ├┤1               ├┤0               ├┤1               ├┤0               ├\n",
       "     │  Hop gate(θ0) │└───────────────┘│  Hop gate(θ3) │└───────────────┘│  Hop gate(θ6) │└────────────────┘│  Hop gate(θ12) │└────────────────┘│  Hop gate(θ14) │\n",
       "q_5: ┤1              ├─────────────────┤1              ├─────────────────┤1              ├──────────────────┤1               ├──────────────────┤1               ├\n",
       "     └───────────────┘                 └───────────────┘                 └───────────────┘                  └────────────────┘                  └────────────────┘</pre>"
      ],
      "text/plain": [
       "                                                                         ┌───────────────┐                                                                        \n",
       "q_0: ────────────────────────────────────────────────────────────────────┤0              ├────────────────────────────────────────────────────────────────────────\n",
       "                                                        ┌───────────────┐│  Hop gate(θ8) │┌───────────────┐                                                       \n",
       "q_1: ───────────────────────────────────────────────────┤0              ├┤1              ├┤0              ├───────────────────────────────────────────────────────\n",
       "                                       ┌───────────────┐│  Hop gate(θ4) │├───────────────┤│  Hop gate(θ9) │ ┌────────────────┐                                    \n",
       "q_2: ──────────────────────────────────┤0              ├┤1              ├┤0              ├┤1              ├─┤0               ├────────────────────────────────────\n",
       "                      ┌───────────────┐│  Hop gate(θ2) │├───────────────┤│  Hop gate(θ7) │├───────────────┴┐│  Hop gate(θ11) │┌────────────────┐                  \n",
       "q_3: ─────────────────┤0              ├┤1              ├┤0              ├┤1              ├┤0               ├┤1               ├┤0               ├──────────────────\n",
       "     ┌───────────────┐│  Hop gate(θ1) │├───────────────┤│  Hop gate(θ5) │├───────────────┤│  Hop gate(θ10) │├────────────────┤│  Hop gate(θ13) │┌────────────────┐\n",
       "q_4: ┤0              ├┤1              ├┤0              ├┤1              ├┤0              ├┤1               ├┤0               ├┤1               ├┤0               ├\n",
       "     │  Hop gate(θ0) │└───────────────┘│  Hop gate(θ3) │└───────────────┘│  Hop gate(θ6) │└────────────────┘│  Hop gate(θ12) │└────────────────┘│  Hop gate(θ14) │\n",
       "q_5: ┤1              ├─────────────────┤1              ├─────────────────┤1              ├──────────────────┤1               ├──────────────────┤1               ├\n",
       "     └───────────────┘                 └───────────────┘                 └───────────────┘                  └────────────────┘                  └────────────────┘"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bitstrings_u = [\n",
    "    [1, 1, 1, 0, 0, 0],\n",
    "    [0, 1, 1, 0, 0, 1],\n",
    "    [1, 0, 1, 0, 1, 0],\n",
    "    [1, 0, 1, 1, 0, 0],\n",
    "    [0, 1, 1, 1, 0, 0],\n",
    "]\n",
    "bitstrings_v = [\n",
    "    [1, 1, 0, 0, 0, 0],\n",
    "    [0, 1, 0, 0, 0, 1],\n",
    "    [1, 0, 0, 0, 1, 0],\n",
    "    [1, 0, 0, 1, 0, 0],\n",
    "    [0, 1, 0, 1, 0, 0],\n",
    "]\n",
    "\n",
    "# Define ansatz parameters:\n",
    "brickwall =[(4,5),(3,4),(2,3),(4,5),(1,2),(3,4),(4,5),(2,3),(0,1),(1,2),(3,4),(2,3),(4,5),(3,4),(4,5)]\n",
    "\n",
    "n_theta    = len(brickwall)\n",
    "nqubit = len(bitstrings_u[0])\n",
    "theta    = Parameter('θ')\n",
    "hop_gate = QuantumCircuit(2, name=\"Hop gate\")\n",
    "hop_gate.h(0)\n",
    "hop_gate.cx(1, 0)\n",
    "hop_gate.cx(0, 1)\n",
    "hop_gate.ry(-theta, 0)\n",
    "hop_gate.ry(-theta, 1)\n",
    "hop_gate.cx(0, 1)\n",
    "hop_gate.h(0)\n",
    "\n",
    "theta_vec = [Parameter('θ%d'%i) for i in range(n_theta)]\n",
    "\n",
    "# Create the parametrized circuit (ansatz). The same circuit will be used for both subsystems, U and V\n",
    "ansatz = QuantumCircuit(nqubit)\n",
    "for m,(i,j) in enumerate(brickwall):\n",
    "    ansatz.append(hop_gate.to_gate({theta:theta_vec[m]}),[i,j])\n",
    "\n",
    "ansatz.draw('text', justify='right', fold=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decompose the operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "cholesky = CholeskyDecomposition(problem)\n",
    "decomposed_operator = cholesky.decompose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instantiate an EntanglementForgingKnitter to provide our decomposed ansatze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "forging_knitter = EntanglementForgingKnitter(ansatz, bitstrings_u=bitstrings_u, bitstrings_v=bitstrings_v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up our circuits and observables for the Estimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.primitives import Estimator\n",
    "\n",
    "# Assign some random parameters to our ansatz. Normally these would be passed in from the optimizer\n",
    "ansatz.assign_parameters(np.random.random(len(ansatz.parameters)), inplace=True)\n",
    "\n",
    "tensor_ansatze_u = [\n",
    "    prep_circ.compose(ansatz) for prep_circ in forging_knitter._tensor_circuits_u\n",
    "]\n",
    "superposition_ansatze_u = [\n",
    "    prep_circ.compose(ansatz) for prep_circ in forging_knitter._superposition_circuits_u\n",
    "]\n",
    "tensor_ansatze_v = [\n",
    "    prep_circ.compose(ansatz) for prep_circ in forging_knitter._tensor_circuits_v\n",
    "]\n",
    "superposition_ansatze_v = [\n",
    "    prep_circ.compose(ansatz) for prep_circ in forging_knitter._superposition_circuits_v\n",
    "]\n",
    "\n",
    "tensor_ansatze = tensor_ansatze_u + tensor_ansatze_v\n",
    "superposition_ansatze = superposition_ansatze_u + superposition_ansatze_v\n",
    "\n",
    "tensor_observables = decomposed_operator.tensor_paulis\n",
    "superpos_observables = decomposed_operator.superposition_paulis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor_estimator = Estimator(tensor_ansatze, tensor_observables)\n",
    "superposition_estimator = Estimator(superposition_ansatze, superpos_observables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate all expvals for one iteration of entanglement forging using Qiskit's Estimator and time it.\n",
    "\n",
    "### For this algorithm, we need expvals for every circuit, evaluated on every observable. The circuits have already had their parameters bound ahead of time, as they all share identical parameters and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "tensor_expvals = []\n",
    "for circ, i in enumerate(tensor_ansatze):\n",
    "    circuit_indices = [i] * len(tensor_observables)\n",
    "    observable_indices = range(len(tensor_observables))\n",
    "    expvals = tensor_estimator(circuit_indices, observable_indices)\n",
    "    tensor_expvals.append(expvals)\n",
    "    \n",
    "superposition_expvals = []\n",
    "for circ, i in enumerate(superposition_ansatze):\n",
    "    circuit_indices = [i] * len(superpos_observables)\n",
    "    observable_indices = range(len(superpos_observables))\n",
    "    expvals = superposition_estimator(circuit_indices, observable_indices)\n",
    "    superposition_expvals.append(expvals)\n",
    "    \n",
    "end_time = time.time()\n",
    "\n",
    "runtime = end_time - start_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Runtime: 60.69519782066345 seconds\n"
     ]
    }
   ],
   "source": [
    "print(f\"Runtime: {runtime} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now use the caching estimator and observe the speedup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tensor_estimator = CachingEstimator(tensor_ansatze, tensor_observables)\n",
    "superposition_estimator = CachingEstimator(superposition_ansatze, superpos_observables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "tensor_expvals = []\n",
    "for circ, i in enumerate(tensor_ansatze):\n",
    "    circuit_indices = [i] * len(tensor_observables)\n",
    "    observable_indices = range(len(tensor_observables))\n",
    "    expvals = tensor_estimator(circuit_indices, observable_indices)\n",
    "    tensor_expvals.append(expvals)\n",
    "    \n",
    "superposition_expvals = []\n",
    "for circ, i in enumerate(superposition_ansatze):\n",
    "    circuit_indices = [i] * len(superpos_observables)\n",
    "    observable_indices = range(len(superpos_observables))\n",
    "    expvals = superposition_estimator(circuit_indices, observable_indices)\n",
    "    superposition_expvals.append(expvals)\n",
    "    \n",
    "end_time = time.time()\n",
    "\n",
    "runtime = end_time - start_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Runtime: 1.2748117446899414 seconds\n"
     ]
    }
   ],
   "source": [
    "print(f\"Runtime: {runtime} seconds\")"
   ]
  }
 ],
 "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.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "987cdf5eeb33585dc719bb9ff4378c2f5c2124692c306f8bea7b3d839af38946"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}