QEOM_statevector_qasm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.chemistry.algorithms.ground_state_solvers import (GroundStateEigensolver,\n",
    "                                                              VQEUCCSDFactory)\n",
    "from qiskit.chemistry.algorithms import NumPyEigensolverFactory\n",
    "from qiskit.chemistry.algorithms.excited_states_solvers import QEOM\n",
    "\n",
    "from qiskit.circuit import QuantumCircuit, Parameter, ParameterExpression\n",
    "from qiskit.aqua.operators.state_fns.circuit_state_fn import CircuitStateFn\n",
    "from qiskit.aqua.operators.state_fns import OperatorStateFn\n",
    "from qiskit.aqua.operators.list_ops.list_op import ListOp\n",
    "from functools import partial\n",
    "from typing import List, Union, Optional, Tuple, Dict, cast\n",
    "from qiskit.aqua.operators import OperatorBase, WeightedPauliOperator, StateFn, CircuitSampler\n",
    "from qiskit.chemistry.transformations import FermionicTransformation, FermionicTransformationType, FermionicQubitMappingType\n",
    "from qiskit.circuit import ParameterVector\n",
    "import numpy as np\n",
    "from collections import namedtuple\n",
    "\n",
    "from qiskit.chemistry.drivers import PySCFDriver, UnitsType, Molecule\n",
    "\n",
    "from qiskit.aqua.algorithms import NumPyMinimumEigensolver\n",
    "from qiskit.chemistry.algorithms.ground_state_solvers import GroundStateEigensolver\n",
    "from qiskit import BasicAer, Aer\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from qiskit.aqua.components.optimizers import SLSQP\n",
    "from qiskit.chemistry.algorithms.ground_state_solvers.minimum_eigensolver_factories import VQEUCCSDFactory\n",
    "from qiskit.aqua.operators.state_fns.vector_state_fn import VectorStateFn\n",
    "from qiskit.result.counts import Counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "geometry = [['H', [0., 0., 0.]],\n",
    "            ['H', [0., 0., 0.735]]]\n",
    "charge = 0\n",
    "multiplicity = 1\n",
    "inp_molecule = Molecule(geometry = geometry,\n",
    "                        charge = charge, \n",
    "                        multiplicity = multiplicity)\n",
    "\n",
    "driver = PySCFDriver(molecule = inp_molecule, \n",
    "                     unit = UnitsType.ANGSTROM, \n",
    "                     basis='sto3g')\n",
    "\n",
    "molecule = driver.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "qubit_op_transformation = FermionicTransformation(transformation = FermionicTransformationType.FULL,\n",
    "                                                qubit_mapping = FermionicQubitMappingType.JORDAN_WIGNER,\n",
    "                                                two_qubit_reduction = False,\n",
    "                                                freeze_core = False, \n",
    "                                                orbital_reduction = None,\n",
    "                                                z2symmetry_reduction = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set computational details\n",
    "backend1 = BasicAer.get_backend('statevector_simulator')\n",
    "quantum_instance1 = QuantumInstance(backend1)\n",
    "\n",
    "shots = 10000\n",
    "backend2 = Aer.get_backend('qasm_simulator')\n",
    "quantum_instance2 = QuantumInstance(backend2, seed_simulator = 12, shots = shots, noise_model = None)\n",
    "optimizer = SLSQP(maxiter = 100, disp = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "method_singles = 'both'\n",
    "method_doubles = 'ucc'\n",
    "excitation_type = 'sd'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "vqe_solver1 = VQEUCCSDFactory(quantum_instance1, \n",
    "                             optimizer, \n",
    "                             initial_point = None,\n",
    "                             method_singles = method_singles,\n",
    "                             method_doubles = method_doubles,\n",
    "                             excitation_type = excitation_type\n",
    "                            )\n",
    "vqe_solver2 = VQEUCCSDFactory(quantum_instance2, \n",
    "                             optimizer, \n",
    "                             initial_point = None,\n",
    "                             method_singles = method_singles,\n",
    "                             method_doubles = method_doubles,\n",
    "                             excitation_type = excitation_type,\n",
    "                             include_custom = True\n",
    "                            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "gsc1 = GroundStateEigensolver(qubit_op_transformation, vqe_solver1)\n",
    "gsc2 = GroundStateEigensolver(qubit_op_transformation, vqe_solver2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "qeom_solver1 = QEOM(gsc1, 'sd')\n",
    "qeom_solver2 = QEOM(gsc2, 'sd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "qeom_results1 = qeom_solver1.solve(driver)\n",
    "qeom_results2 = qeom_solver2.solve(driver)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Results differ for Statevector simulator and Qasm simulator.\n",
    "Statevector energies are equal to exact diagonalization results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector results\n",
      "[-1.85727503 -1.24458675 -0.88272435 -0.22491345]\n",
      "Qasm results\n",
      "[-1.85727503 -1.29327233 -0.92030485 -0.26552533]\n"
     ]
    }
   ],
   "source": [
    "print('Statevector results')\n",
    "print(qeom_results1['computed_energies'])\n",
    "print('Qasm results')\n",
    "print(qeom_results2['computed_energies'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seems like the problem starts in QEOM.solve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "groundstate_result1 = qeom_solver1._gsc.solve(driver)\n",
    "groundstate_result2 = qeom_solver2._gsc.solve(driver)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix_operators_dict are equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix_operators_dict1, size1 = qeom_solver1._prepare_matrix_operators()\n",
    "matrix_operators_dict2, size2 = qeom_solver2._prepare_matrix_operators()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "state1 = groundstate_result1.raw_result['eigenstate']\n",
    "state2 = groundstate_result2.raw_result['eigenstate']\n",
    "if not isinstance(state1, StateFn):\n",
    "    state1 = StateFn(state1)\n",
    "if not isinstance(state2, StateFn):\n",
    "    state2 = StateFn(state2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But QEOM._gsc.evaluate_operators() -> .eval_op() does not work the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "if isinstance(matrix_operators_dict1, dict):\n",
    "    results1 = {}  # type: ignore\n",
    "    for name, op in matrix_operators_dict1.items():\n",
    "        results1[name] = gsc1._eval_op(state1, op, quantum_instance1)\n",
    "if isinstance(matrix_operators_dict2, dict):\n",
    "    results2 = {}  # type: ignore\n",
    "    for name, op in matrix_operators_dict2.items():\n",
    "        results2[name] = gsc2._eval_op(state2, op, quantum_instance2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some elements differ significantly: e.g. 'q_0_0', 'q_1_1'. Seems like the problem lies somewhere in eval().\n",
    "Also, matrix element values depend on the number of shots - maybe it would be better to normalize them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector results:\n",
      "{'q_0_0': [(-0.6417078302259717-3.88e-16j)], 'm_0_0': [(12.697946881857368-8.74e-16j)], 'v_0_0': [(15.601953488949055+0j)], 'q_0_1': [(-2.8148850117566964-1.76e-16j)], 'm_0_1': [(2.894899196547648+2.24e-16j)], 'q_0_2': [(-3.96482681784e-07+4.68e-16j)], 'm_0_2': [(-6.78714980176e-06-9.696e-15j)], 'v_0_2': [(-5.96700007046e-06-8.04e-15j)], 'q_1_1': [(-0.6417078302259717-3.88e-16j)], 'm_1_1': [(12.697946881857215-8.74e-16j)], 'v_1_1': [(15.601953488948867+0j)], 'q_1_2': [(-9.64870180268e-07+1.52e-15j)], 'm_1_2': [(-3.189871369396e-06-9e-16j)], 'v_1_2': [(-3.45952461506e-06-7.32e-16j)], 'q_2_2': [(-10.267325283615914-6.664e-15j)], 'm_2_2': [(407.6178016942031+2.4871e-14j)], 'v_2_2': [(249.63125582318338+0j)]}\n",
      "-----\n",
      "Qasm results:\n",
      "{'q_0_0': [0j], 'm_0_0': [(1210569251.3265479+0j)], 'v_0_0': [(1565440000+0j)], 'q_0_1': [(-283304469.59868443+0j)], 'm_0_1': [(283304469.59868443+0j)], 'q_0_2': [0j], 'm_0_2': [0j], 'v_0_2': [0j], 'q_1_1': [0j], 'm_1_1': [(1210569251.3265479+0j)], 'v_1_1': [(1565440000+0j)], 'q_1_2': [0j], 'm_1_2': [0j], 'v_1_2': [0j], 'q_2_2': [0j], 'm_2_2': [(39868618390.17654+0j)], 'v_2_2': [(25047040000+0j)]}\n"
     ]
    }
   ],
   "source": [
    "print('Statevector results:')\n",
    "print(results1)\n",
    "print('-----')\n",
    "print('Qasm results:')\n",
    "print(results2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}