Qiskit-FCI.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "71d2cb0b",
      "metadata": {},
      "outputs": [],
      "source": [
        "import os\n",
        "import yaml\n",
        "from yaml import SafeLoader\n",
        "\n",
        "from qiskit.aqua.algorithms import NumPyEigensolver\n",
        "import numpy as np\n",
        "from qiskit.chemistry import FermionicOperator\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "9b4ce39a",
      "metadata": {},
      "outputs": [],
      "source": [
        "def get_spatial_integrals(one_electron,two_electron,n_orb):\n",
        "    one_electron_spatial_integrals = np.zeros((n_orb, n_orb))\n",
        "    two_electron_spatial_integrals = np.zeros((n_orb, n_orb, n_orb, n_orb))\n",
        "\n",
        "    for ind, val in enumerate(one_electron):\n",
        "        # This is because python index starts at 0\n",
        "        i = int(val[0] - 1)\n",
        "        j = int(val[1] - 1)\n",
        "        one_electron_spatial_integrals[i, j] = val[2]\n",
        "        if i != j:\n",
        "            one_electron_spatial_integrals[j, i] = val[2]\n",
        "\n",
        "    for ind, val in enumerate(two_electron):\n",
        "        i = int(val[0]-1)\n",
        "        j = int(val[1]-1)\n",
        "        k = int(val[2]-1)\n",
        "        l = int(val[3]-1)\n",
        "        two_electron_spatial_integrals[i, j, k, l] = val[4]\n",
        "        if two_electron_spatial_integrals[k, l, i, j] == 0:\n",
        "            two_electron_spatial_integrals[k, l, i, j] = val[4]\n",
        "        if two_electron_spatial_integrals[i, j, l, k] == 0:\n",
        "            two_electron_spatial_integrals[i, j, l, k] = val[4]\n",
        "        if two_electron_spatial_integrals[l, k, i, j] == 0:\n",
        "            two_electron_spatial_integrals[l, k, i, j] = val[4]\n",
        "        if two_electron_spatial_integrals[j, i, k, l] == 0:\n",
        "            two_electron_spatial_integrals[j, i, k, l] = val[4]\n",
        "        if two_electron_spatial_integrals[k, l, j, i] == 0:\n",
        "            two_electron_spatial_integrals[k, l, j, i] = val[4]\n",
        "        if two_electron_spatial_integrals[j, i, l, k] == 0:\n",
        "            two_electron_spatial_integrals[j, i, l, k] = val[4]\n",
        "        if two_electron_spatial_integrals[l, k, j, i] == 0:\n",
        "            two_electron_spatial_integrals[l, k, j, i] = val[4]\n",
        "\n",
        "    return one_electron_spatial_integrals, two_electron_spatial_integrals\n",
        "\n",
        "def convert_to_spin_index(one_electron, two_electron,n_orb):\n",
        "    h1 = np.block([[one_electron, np.zeros((int(n_orb), int(n_orb)))],\n",
        "                   [np.zeros((int(n_orb), int(n_orb))), one_electron]])\n",
        "    h2 = np.zeros((2 * n_orb, 2 * n_orb, 2 * n_orb, 2 * n_orb))\n",
        "\n",
        "    for i in range(len(two_electron)):\n",
        "        for j in range(len(two_electron)):\n",
        "            for k in range(len(two_electron)):\n",
        "                for l in range(len(two_electron)):\n",
        "\n",
        "                    h2[i,j, k + n_orb, l + n_orb] = two_electron[i, j, k, l]\n",
        "                    h2[i + n_orb, j + n_orb,k, l] = two_electron[i, j, k, l]\n",
        "\n",
        "                    if i!=k and j!=l:\n",
        "                        h2[i,j,k,l] = two_electron[i,j,k,l]\n",
        "                        h2[i + n_orb, j + n_orb, k + n_orb, l + n_orb] = two_electron[i, j, k, l]\n",
        "    return h1, 0.5*h2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "61197fb2",
      "metadata": {},
      "outputs": [],
      "source": [
        "data = yaml.load(open(\"LiH.yaml\",\"r\"),SafeLoader)\n",
        "n_electrons = data['integral_sets'][0]['n_electrons']\n",
        "n_spatial_orbitals = data['integral_sets'][0]['n_orbitals']\n",
        "nuclear_repulsion_energy = data['integral_sets'][0]['coulomb_repulsion']['value']\n",
        "\n",
        "one_electron_import = data['integral_sets'][0]['hamiltonian']['one_electron_integrals']['values']\n",
        "two_electron_import = data['integral_sets'][0]['hamiltonian']['two_electron_integrals']['values']\n",
        "\n",
        "one_electron_spatial_integrals, two_electron_spatial_integrals = get_spatial_integrals(one_electron_import,two_electron_import,n_spatial_orbitals)\n",
        "\n",
        "h1, h2 = convert_to_spin_index(one_electron_spatial_integrals,two_electron_spatial_integrals,n_spatial_orbitals)\n",
        "\n",
        "# Mapping can be “jordan_wigner”, “parity”, “bravyi_kitaev”, “bksf”\n",
        "qubitOp = FermionicOperator(h1, h2).mapping(map_type='jordan_wigner')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5118b0a5",
      "metadata": {},
      "source": [
        "Print the lowest eigenvalue. To get the eigenvalues of the excited states, more eigen values need to be requested by the NumPyEigensolver."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "4d528ec6-ff49-4a92-a54a-ff15493894e8",
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Exact Result: [-7.88232438]\n"
          ]
        }
      ],
      "source": [
        "exact_solution = NumPyEigensolver(qubitOp).run()\n",
        "print(\"Exact Result:\", np.real(exact_solution.eigenvalues) + nuclear_repulsion_energy)"
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "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.7.13"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}