MIN_CLIQUE_COVER_scaling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from term_grouping import *\n",
    "from print_cliques import print_cliques\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "import time\n",
    "import numpy as np\n",
    "import glob\n",
    "from openfermion.hamiltonians import MolecularData\n",
    "from openfermion.transforms import get_fermion_operator, get_interaction_operator\n",
    "#from openfermionpsi4 import run_psi4\n",
    "from openfermion.transforms import (jordan_wigner, bravyi_kitaev, bravyi_kitaev_fast, bravyi_kitaev_tree,\n",
    "                                    binary_code_transform, reverse_jordan_wigner)\n",
    "from openfermion.utils import group_into_tensor_product_basis_sets\n",
    "from openfermion.transforms._binary_codes import parity_code\n",
    "from scipy.optimize import curve_fit\n",
    "\n",
    "plt.rcParams[\"font.size\"] = 13\n",
    "plt.rcParams[\"axes.labelsize\"] = 15\n",
    "plt.rcParams[\"axes.titlesize\"] = 15\n",
    "plt.rcParams[\"font.family\"] = 'STIXGeneral'\n",
    "plt.rcParams[\"xtick.labelsize\"] = 18\n",
    "plt.rcParams[\"ytick.labelsize\"] = 18"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate benchmark hamiltonians for the OpenFermion algorithm\n",
    "OpenFermion's minclique cover takes a QubitHamiltonian as input so these need to be generated \n",
    "separately from the hamiltonians in the the hamiltonians/ directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_transform_group(filename, encoding_AS_dict):\n",
    "    # Load molecule from file\n",
    "    print('--- loading molecule ---')\n",
    "    molecule = MolecularData(filename=filename)\n",
    "    print('filename: {}'.format(molecule.filename))\n",
    "    print('--- compute integrals ---')\n",
    "    molecule = run_psi4(molecule,run_mp2=True,run_cisd=True,run_ccsd=True,run_fci=True)\n",
    "    \n",
    "    #print(molecule.two_body_integrals)\n",
    "    #print(molecule.canonical_orbitals)\n",
    "    #print('n_atoms: {}'.format(molecule.n_atoms))\n",
    "    #print('n_electrons: {}'.format(molecule.n_electrons))\n",
    "    #print('n_orbitals: {}'.format(molecule.n_orbitals))\n",
    "    #print('Canonical Orbitals: {}'.format(molecule.canonical_orbitals))\n",
    "    #print('n_qubits: {}'.format(molecule.n_qubits))\n",
    "    \n",
    "    # construct Hamiltonian for each pair of transform-AS in encoding_AS_dict\n",
    "    data = []\n",
    "    for transform in encoding_AS_dict.keys():\n",
    "        print('\\n>>>> Using {} transform'.format(transform))\n",
    "        all_orbital_pairs = encoding_AS_dict[transform]\n",
    "        for orbital_pair in all_orbital_pairs:\n",
    "            \n",
    "            occupied_num, active_num = orbital_pair\n",
    "            print('ActiveSpace = {}'.format(active_num))\n",
    "            \n",
    "            # Construct Hamiltonian\n",
    "            molecular_hamiltonian = molecule.get_molecular_hamiltonian(\n",
    "                                    occupied_indices=range(occupied_num),\n",
    "                                    active_indices=range(active_num))\n",
    "    \n",
    "            # map the operator to fermions and then qubits\n",
    "            fermion_hamiltonian = get_fermion_operator(molecular_hamiltonian)\n",
    "    \n",
    "            # get interaction operator (needed for BKSF)\n",
    "            interaction_hamiltonian = get_interaction_operator(fermion_hamiltonian)\n",
    "    \n",
    "            if transform is 'JW':\n",
    "                qubit_h = jordan_wigner(fermion_hamiltonian)\n",
    "                qubit_h.compress()\n",
    "            elif transform is 'BK':\n",
    "                qubit_h = bravyi_kitaev(fermion_hamiltonian)\n",
    "                qubit_h.compress()\n",
    "            elif transform is 'BKSF':\n",
    "                qubit_h = bravyi_kitaev_fast(interaction_hamiltonian)\n",
    "                qubit_h.compress()\n",
    "            elif transform is 'BKT':\n",
    "                qubit_h = bravyi_kitaev_tree(fermion_hamiltonian)\n",
    "                qubit_h.compress()\n",
    "            elif transform is 'PC':\n",
    "                qubit_h = binary_code_transform(fermion_hamiltonian, parity_code(2*active_num))\n",
    "                qubit_h.compress()\n",
    "            else:\n",
    "                print('ERROR: Unrecognized qubit transformation: {}'.format(transform))\n",
    "                sys.exit(2)\n",
    "                \n",
    "            num_terms = len(qubit_h.terms.keys()) - 1\n",
    "            print('OPENFERMION: generated Hamiltonian with {} terms (excluding Identity)'.format(num_terms))\n",
    "                \n",
    "            # Use OpenFermion function to group into commuting sets using QWC\n",
    "            # time the computation\n",
    "            start_time = time.time()\n",
    "            cliques = group_into_tensor_product_basis_sets(qubit_h)\n",
    "            end_time = time.time()\n",
    "            \n",
    "            print('OPENFERMION: group_into_tensor_product_basis_sets found {} unique circuits'.format(len(cliques)))\n",
    "            et = end_time - start_time\n",
    "            print('OPENFERMION: Elapsed time: {:.6f}s'.format(et))\n",
    "            \n",
    "            data.append((num_terms,len(cliques),et))\n",
    "            \n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- loading molecule ---\n",
      "filename: molecule_data/CH4_sto-3g_singlet_grnd\n",
      "--- compute integrals ---\n",
      "\n",
      ">>>> Using BK transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.001992s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 26 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 8 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002163s\n",
      "ActiveSpace = 3\n",
      "OPENFERMION: generated Hamiltonian with 93 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 33 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.003411s\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 240 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 70 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.010487s\n",
      "ActiveSpace = 5\n",
      "OPENFERMION: generated Hamiltonian with 591 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 205 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.055145s\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 1518 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 525 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.344102s\n",
      "ActiveSpace = 7\n",
      "OPENFERMION: generated Hamiltonian with 3005 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 969 unique circuits\n",
      "OPENFERMION: Elapsed time: 1.418339s\n",
      "ActiveSpace = 8\n",
      "OPENFERMION: generated Hamiltonian with 5236 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1694 unique circuits\n",
      "OPENFERMION: Elapsed time: 3.875576s\n",
      "ActiveSpace = 9\n",
      "OPENFERMION: generated Hamiltonian with 8483 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 2672 unique circuits\n",
      "OPENFERMION: Elapsed time: 10.612451s\n",
      "--- loading molecule ---\n",
      "filename: molecule_data/H2_6-31g_singlet_0.7\n",
      "--- compute integrals ---\n",
      "\n",
      ">>>> Using BK transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002045s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 14 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 3 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002218s\n",
      "ActiveSpace = 3\n",
      "OPENFERMION: generated Hamiltonian with 61 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 19 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002986s\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 184 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 58 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.008114s\n",
      "\n",
      ">>>> Using BKSF transform\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 460 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 30 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.024721s\n",
      "\n",
      ">>>> Using BKT transform\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 184 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 57 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.008288s\n",
      "\n",
      ">>>> Using JW transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.001581s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 14 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 5 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.001682s\n",
      "ActiveSpace = 3\n",
      "OPENFERMION: generated Hamiltonian with 61 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 17 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002475s\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 184 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 73 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.008556s\n",
      "\n",
      ">>>> Using PC transform\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 184 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 64 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.008394s\n",
      "--- loading molecule ---\n",
      "filename: molecule_data/H2_sto-3g_singlet_0.7\n",
      "--- compute integrals ---\n",
      "\n",
      ">>>> Using BK transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002100s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 14 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 3 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002093s\n",
      "--- loading molecule ---\n",
      "filename: molecule_data/H2O_6-31g_singlet_104\n",
      "--- compute integrals ---\n",
      "\n",
      ">>>> Using BK transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.001996s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 26 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 8 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002213s\n",
      "ActiveSpace = 3\n",
      "OPENFERMION: generated Hamiltonian with 61 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 12 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002339s\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 192 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 45 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.006459s\n",
      "ActiveSpace = 5\n",
      "OPENFERMION: generated Hamiltonian with 275 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 47 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.008933s\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 630 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 140 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.041733s\n",
      "\n",
      ">>>> Using BKSF transform\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 1494 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 115 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.236102s\n",
      "\n",
      ">>>> Using BKT transform\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 630 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 211 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.062394s\n",
      "\n",
      ">>>> Using JW transform\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 630 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 178 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.051198s\n",
      "\n",
      ">>>> Using PC transform\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 630 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 233 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.074312s\n",
      "--- loading molecule ---\n",
      "filename: molecule_data/H2O_sto-3g_singlet_104\n",
      "--- compute integrals ---\n",
      "\n",
      ">>>> Using BK transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.001981s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 26 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 8 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002259s\n",
      "ActiveSpace = 3\n",
      "OPENFERMION: generated Hamiltonian with 61 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 12 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002284s\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 192 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 44 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.006724s\n",
      "ActiveSpace = 5\n",
      "OPENFERMION: generated Hamiltonian with 275 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 50 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.009301s\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 630 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 140 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.041137s\n",
      "--- loading molecule ---\n",
      "filename: molecule_data/LiH_sto-3g_singlet_1.45\n",
      "--- compute integrals ---\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      ">>>> Using BK transform\n",
      "ActiveSpace = 1\n",
      "OPENFERMION: generated Hamiltonian with 3 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 1 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002077s\n",
      "ActiveSpace = 2\n",
      "OPENFERMION: generated Hamiltonian with 26 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 8 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.002313s\n",
      "ActiveSpace = 3\n",
      "OPENFERMION: generated Hamiltonian with 117 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 40 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.004573s\n",
      "ActiveSpace = 4\n",
      "OPENFERMION: generated Hamiltonian with 192 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 55 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.007850s\n",
      "ActiveSpace = 5\n",
      "OPENFERMION: generated Hamiltonian with 275 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 65 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.013059s\n",
      "ActiveSpace = 6\n",
      "OPENFERMION: generated Hamiltonian with 630 terms (excluding Identity)\n",
      "OPENFERMION: group_into_tensor_product_basis_sets found 170 unique circuits\n",
      "OPENFERMION: Elapsed time: 0.047431s\n"
     ]
    }
   ],
   "source": [
    "ch4filename = 'molecule_data/CH4_sto-3g_singlet_grnd.hdf5'\n",
    "ch4dict = {'BK': [(9,1),(9,2),(9,3),(9,4),(9,5),(9,6),(9,7),(9,8),(9,9)]}\n",
    "\n",
    "h2filename1 = 'molecule_data/H2_6-31g_singlet_0.7.hdf5'\n",
    "h2dict1 = {'BK': [(4,1),(4,2),(4,3),(4,4)],\n",
    "           'BKSF': [(4,4)], 'BKT': [(4,4)],\n",
    "           'JW': [(4,1),(4,2),(4,3),(4,4)],\n",
    "           'PC': [(4,4)]}\n",
    "\n",
    "h2filename2 = 'molecule_data/H2_sto-3g_singlet_0.7.hdf5'\n",
    "h2dict2 = {'BK': [(2,1),(2,2)]}\n",
    "\n",
    "h2ofilename1 = 'molecule_data/H2O_6-31g_singlet_104.hdf5'\n",
    "h2odict1 = {'BK': [(6,1),(6,2),(6,3),(6,4),(6,5),(6,6)],\n",
    "           'BKSF': [(6,6)], 'BKT': [(6,6)],\n",
    "           'JW': [(6,6)],\n",
    "           'PC': [(6,6)]}\n",
    "\n",
    "h2ofilename2 = 'molecule_data/H2O_sto-3g_singlet_104.hdf5'\n",
    "h2odict2 = {'BK': [(6,1),(6,2),(6,3),(6,4),(6,5),(6,6)]}\n",
    "\n",
    "lihfilename = 'molecule_data/LiH_sto-3g_singlet_1.45.hdf5'\n",
    "lihdict = {'BK': [(6,1),(6,2),(6,3),(6,4),(6,5),(6,6)]}\n",
    "\n",
    "filelist = [ch4filename, h2filename1, h2filename2, h2ofilename1, h2ofilename2, lihfilename]\n",
    "dictlist = [ch4dict,     h2dict1,     h2dict2,     h2odict1,     h2odict2,     lihdict]\n",
    "\n",
    "all_data = []\n",
    "for fname, encode_dict in zip(filelist,dictlist):\n",
    "    cur_data = load_transform_group(fname, encode_dict)\n",
    "    all_data.append(cur_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write results to file\n",
    "with open('Data/openfermion_clique_cover_results.txt', 'w') as fn:\n",
    "    for dset in all_data:\n",
    "        for run in dset:\n",
    "            nterms, ncliques, runtime = run\n",
    "            fn.write('{0} {1} {2:.6f}\\n'.format(str(nterms).ljust(5), str(ncliques).ljust(5), runtime))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot benchmarks\n",
    "Benchmarks are organized:\n",
    "--------------------------------\n",
    "0 -> BH_QWC\n",
    "\n",
    "1 -> BH_FULL\n",
    "\n",
    "2 -> BK_QWC\n",
    "\n",
    "3 -> BK_FULL\n",
    "\n",
    "4 -> OP_QWC\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "bh_qwc_bmarks_fn = glob.glob('Data/Bopp*QWC*')\n",
    "bh_full_bmarks_fn = glob.glob('Data/Bopp*FULL*')\n",
    "bk_qwc_bmarks_fn = glob.glob('Data/Bron*QWC*')\n",
    "bk_full_bmarks_fn = glob.glob('Data/Bron*FULL*')\n",
    "op_qwc_bmarks_fn = glob.glob('Data/openfermion*clique*')\n",
    "bmarks_fn = [bh_qwc_bmarks_fn, bh_full_bmarks_fn, bk_qwc_bmarks_fn, bk_full_bmarks_fn, op_qwc_bmarks_fn]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Data/BoppanaHalldorsson_QWC_5237term_results.txt', 'Data/BoppanaHalldorsson_QWC_1519term_results.txt', 'Data/BoppanaHalldorsson_QWC_1495term_results.txt', 'Data/BoppanaHalldorsson_QWC_1495term_results1.txt', 'Data/BoppanaHalldorsson_QWC_3006term_results.txt', 'Data/BoppanaHalldorsson_QWC_results.txt', 'Data/BoppanaHalldorsson_QWC_8484term_results.txt']\n",
      "['Data/BoppanaHalldorsson_FULL_results.txt', 'Data/BoppanaHalldorsson_FULL_5237term_results.txt', 'Data/BoppanaHalldorsson_FULL_6term_results.txt', 'Data/BoppanaHalldorsson_FULL_1519term_results.txt', 'Data/BoppanaHalldorsson_FULL_1495term_results.txt', 'Data/BoppanaHalldorsson_FULL_163term_results.txt', 'Data/BoppanaHalldorsson_FULL_100term_results.txt', 'Data/BoppanaHalldorsson_FULL_3006term_results.txt', 'Data/BoppanaHalldorsson_FULL_15term_results.txt', 'Data/BoppanaHalldorsson_FULL_164term_results.txt', 'Data/BoppanaHalldorsson_FULL_5term_results.txt', 'Data/BoppanaHalldorsson_FULL_8484term_results.txt', 'Data/BoppanaHalldorsson_FULL_165term_results.txt', 'Data/BoppanaHalldorsson_FULL_4term_results.txt', 'Data/BoppanaHalldorsson_FULL_3term_results.txt']\n",
      "['Data/BronKerbosch_QWC_1519term_results.txt', 'Data/BronKerbosch_QWC_results.txt', 'Data/BronKerbosch_QWC_22term_results.txt']\n",
      "['Data/BronKerbosch_FULL_15term_results.txt', 'Data/BronKerbosch_FULL_5term_results.txt', 'Data/BronKerbosch_FULL_100term_results.txt', 'Data/BronKerbosch_FULL_results.txt', 'Data/BronKerbosch_FULL_22term_results.txt', 'Data/BronKerbosch_FULL_165term_results.txt', 'Data/BronKerbosch_FULL_6term_results.txt']\n",
      "['Data/openfermion_clique_cover_results.txt']\n"
     ]
    }
   ],
   "source": [
    "for bm in bmarks_fn:\n",
    "    print(bm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data/BoppanaHalldorsson_QWC_5237term_results.txt\n",
      "Data/BoppanaHalldorsson_QWC_1519term_results.txt\n",
      "Data/BoppanaHalldorsson_QWC_1495term_results.txt\n",
      "Data/BoppanaHalldorsson_QWC_1495term_results1.txt\n",
      "Data/BoppanaHalldorsson_QWC_3006term_results.txt\n",
      "Data/BoppanaHalldorsson_QWC_results.txt\n",
      "Data/BoppanaHalldorsson_QWC_8484term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_5237term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_6term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_1519term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_1495term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_163term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_100term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_3006term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_15term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_164term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_5term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_8484term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_165term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_4term_results.txt\n",
      "Data/BoppanaHalldorsson_FULL_3term_results.txt\n",
      "Data/BronKerbosch_QWC_1519term_results.txt\n",
      "Data/BronKerbosch_QWC_results.txt\n",
      "Data/BronKerbosch_QWC_22term_results.txt\n",
      "Data/BronKerbosch_FULL_15term_results.txt\n",
      "Data/BronKerbosch_FULL_5term_results.txt\n",
      "Data/BronKerbosch_FULL_100term_results.txt\n",
      "Data/BronKerbosch_FULL_results.txt\n",
      "Data/BronKerbosch_FULL_22term_results.txt\n",
      "Data/BronKerbosch_FULL_165term_results.txt\n",
      "Data/BronKerbosch_FULL_6term_results.txt\n",
      "Data/openfermion_clique_cover_results.txt\n"
     ]
    }
   ],
   "source": [
    "bmarks = []\n",
    "for bm in bmarks_fn:\n",
    "    first = True\n",
    "    for fn in bm:\n",
    "        print(fn)\n",
    "        if first == True:\n",
    "            temp_bm = np.array(np.genfromtxt(fn))\n",
    "            first = False\n",
    "        else:\n",
    "            temp_bm = np.vstack((temp_bm,np.genfromtxt(fn)))\n",
    "    bmarks.append((temp_bm))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(len(bmarks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, a, b, c):\n",
    "    return a * np.exp(-b * x) + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_with_errors(xvals, yvals):\n",
    "    val_dict = {}\n",
    "    for x1,y1 in zip(xvals, yvals):\n",
    "        try:\n",
    "            val_dict[str(x1)].append(y1)\n",
    "        except KeyError:\n",
    "            val_dict[str(x1)] = [y1]\n",
    "            \n",
    "    real_xvals, real_yvals, min_err, max_err = [], [], [], []\n",
    "    for k in sorted(val_dict.keys(), key=lambda term: float(term)):\n",
    "        #print('{}: {}'.format(k,val_dict[k]))\n",
    "        real_xvals.append(float(k))\n",
    "        mean = np.mean(val_dict[k])\n",
    "        real_yvals.append(mean)\n",
    "        min_err.append(mean - min(val_dict[k]))\n",
    "        max_err.append(max(val_dict[k]) - mean)\n",
    "    err = np.stack((min_err,max_err))\n",
    "    \n",
    "    return real_xvals, real_yvals, err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lin_func(x, m):\n",
    "    return [m * xx for xx in x]\n",
    "\n",
    "def lin_log_func(x, m, b):\n",
    "    return [(m * xx) / (b * np.log2(xx)**2) for xx in x]\n",
    "\n",
    "def quad_func(x, a, b):\n",
    "    return [a * xx**2 + b * xx for xx in x]\n",
    "\n",
    "def exp_func(x, a, b, c, d, e):\n",
    "    return [a * b**(c * xx + d) for xx in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_clique_fit_func(label):\n",
    "    if label in ['BK_QWC', 'BK_FULL', 'OP_QWC', 'BH_FULL', 'BH_QWC']:\n",
    "        return lin_func\n",
    "    \n",
    "def get_runtime_fit_func(label):\n",
    "    if label in ['BH_FULL', 'OP_QWC']:\n",
    "        return quad_func\n",
    "    elif label in ['BH_QWC', 'BK_QWC', 'BK_FULL']:\n",
    "        return exp_func\n",
    "    if label in ['OP_QWC']:\n",
    "        return lin_func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PLOTTING: BH_QWC\n",
      "PLOTTING: BH_FULL\n",
      "PLOTTING: BK_QWC\n",
      "PLOTTING: BK_FULL\n",
      "PLOTTING: OP_QWC\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/pranavgokhale/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:34: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/Users/pranavgokhale/anaconda3/lib/python3.7/site-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n",
      "  category=OptimizeWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1440 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Same plot but throwing away data for |H| > some_limit\n",
    "fig, ax = plt.subplots(nrows=3,ncols=1,figsize=(10,20))\n",
    "\n",
    "labels = ['BH_QWC','BH_FULL','BK_QWC','BK_FULL','OP_QWC']\n",
    "color = ['blue','orange','green','red','purple']\n",
    "actual_labels = ['BoppanaH QWC', 'BoppanaH GC', 'BronK QWC', 'BronK GC', 'OpenF QWC']\n",
    "\n",
    "for i, bm in enumerate(bmarks):\n",
    "    print('PLOTTING: {}'.format(labels[i]))\n",
    "    #if labels[i] not in ['OP_QWC']:\n",
    "    #    continue\n",
    "    terms_temp = bm[:,0]\n",
    "    cliques_temp = bm[:,1]\n",
    "    runtime_temp = bm[:,2]\n",
    "    \n",
    "    # Sort the benchmarks and get their errors\n",
    "    terms_temp2, cliques_temp2, clique_err_temp2 = return_with_errors(terms_temp, cliques_temp)\n",
    "    _, runtime_temp2, runtime_err_temp2 = return_with_errors(terms_temp, runtime_temp)\n",
    "        \n",
    "    # truncate the data for |H| > my_limit\n",
    "    my_limit = 630\n",
    "    terms, cliques, clique_err, runtime, runtime_err = [], [], [[],[]], [], [[],[]]\n",
    "    for m in range(len(terms_temp2)):\n",
    "        if terms_temp2[m] <= my_limit:\n",
    "            terms.append(terms_temp2[m])\n",
    "            cliques.append(cliques_temp2[m])\n",
    "            clique_err[0].append(clique_err_temp2[0][m])\n",
    "            clique_err[1].append(clique_err_temp2[1][m])\n",
    "            runtime.append(runtime_temp2[m])\n",
    "            runtime_err[0].append(runtime_err_temp2[0][m])\n",
    "            runtime_err[1].append(runtime_err_temp2[1][m])\n",
    "    \n",
    "    # compute reduction factors cliques_found / naive\n",
    "    reduction = [nterm/cliq for cliq, nterm in zip(cliques,terms)]\n",
    "    \n",
    "    # print the benchmarks\n",
    "    #for n in range(len(terms)):\n",
    "    #    print('{}: {} [{},{}]'.format(terms[n], cliques[n], clique_err[0][n], clique_err[1][n]))\n",
    "    \n",
    "    # Fit the benchmarks\n",
    "    clique_fit_func = get_clique_fit_func(labels[i])\n",
    "    runtime_fit_func = get_runtime_fit_func(labels[i])\n",
    "    \n",
    "    fit_x = np.arange(0,terms[-1],2)\n",
    "    \n",
    "    cpopt, cpcov = curve_fit(clique_fit_func, terms, cliques)\n",
    "    ax[0].plot(fit_x, clique_fit_func(fit_x, *cpopt),c=color[i],ls='-',lw=2,alpha=0.6)\n",
    "               #label='fit: {:.2f} x + {:.2f}'.format(*cpopt))\n",
    "    \n",
    "    if labels[i] in ['BH_FULL']:\n",
    "        runtime_bounds = [0,1000]\n",
    "    else:\n",
    "        runtime_bounds = [-np.inf,np.inf]\n",
    "    rpopt, rpcov = curve_fit(runtime_fit_func, terms, runtime, bounds=runtime_bounds)\n",
    "    ax[1].plot(fit_x, runtime_fit_func(fit_x, *rpopt),c=color[i],ls='-',lw=2,alpha=0.6)\n",
    "               #label='fit: {:.2f} * x**(2) + {:.2f} * x'.format(*rpopt))\n",
    "    \n",
    "    # Plot #terms vs #cliques\n",
    "    #ax[0].errorbar(terms,cliques,yerr=[clique_err[0],clique_err[1]],fmt='o',ms=8,label=actual_labels[i])\n",
    "    ax[0].scatter(terms,cliques,s=90,label=actual_labels[i])\n",
    "    \n",
    "    \n",
    "    # Plot #terms vs runtime\n",
    "    #ax[1].errorbar(terms,runtime,yerr=[runtime_err[0],runtime_err[1]],fmt='o',ms=8,label=actual_labels[i])\n",
    "    ax[1].scatter(terms,runtime,s=90,label=actual_labels[i])\n",
    "    \n",
    "    # Plot reduction factor\n",
    "    ax[2].scatter(terms,reduction,s=70,label=actual_labels[i])\n",
    "    ax[2].plot(terms,reduction,c=color[i])\n",
    "    \n",
    "num_terms = [262.275106726364, 305.41813444398167, 353.67686466055795, 407.4405534360682, 467.11273138275715, 533.1112036651396, 605.8680500000002, 648.0]\n",
    "reduction_factors = [19.142857142857142, 19.885714285714286, 20.628571428571426, 21.37142857142857, 22.114285714285714, 22.857142857142858, 23.6, 24.0]\n",
    "\n",
    "ax[2].scatter(num_terms, reduction_factors, s=70,label='Baranyai GC')\n",
    "ax[2].plot(num_terms, reduction_factors, c='brown')\n",
    "    \n",
    "# plot Naive clique partitioning\n",
    "ax[0].plot(np.arange(terms[-1]),np.arange(terms[-1]),ls='--',c='k',label='Naive')\n",
    "# set ax0 settings\n",
    "ax[0].legend(fontsize=15)\n",
    "ax[0].set_ylabel('Number of Partitions',fontsize=19)\n",
    "ax[0].set_xlabel('Hamiltonian Size (Number of Pauli Strings)',fontsize=19)\n",
    "ax[0].set_xlim(0,5500)\n",
    "ax[0].set_ylim(0,1800)\n",
    "ax[0].locator_params(axis='y',tight=True, nbins=6)\n",
    "ax[0].locator_params(axis='x',tight=True, nbins=6)\n",
    "\n",
    "# set ax1 settings\n",
    "#ax[1].set_yscale('log')\n",
    "ax[1].set_ylabel('Runtime (s)',fontsize=20)\n",
    "ax[1].set_xlabel('Hamiltonian Size (Number of Pauli Strings)',fontsize=20)\n",
    "ax[1].legend(fontsize=16)\n",
    "ax[1].set_xlim(0,630)\n",
    "ax[1].set_ylim(0,40)\n",
    "ax[1].locator_params(axis='y',tight=True, nbins=6)\n",
    "ax[1].locator_params(axis='x',tight=True, nbins=6)\n",
    "\n",
    "# set ax2 settings\n",
    "ax[2].set_ylabel('Reduction Factor in Number of Partitions w.r.t. Naive',fontsize=18)\n",
    "ax[2].set_xlabel('Hamiltonian Size (Number of Pauli Strings)',fontsize=20)\n",
    "ax[2].legend(loc='upper left',fontsize=16)\n",
    "ax[2].set_xlim(0,630)\n",
    "ax[2].set_ylim(0,40)\n",
    "ax[2].locator_params(axis='y',tight=True, nbins=6)\n",
    "ax[2].locator_params(axis='x',tight=True, nbins=6)\n",
    "    \n",
    "plt.tight_layout()\n",
    "plt.savefig('Figures/scaling.pdf',format='pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00317 * 1.02**(3.04 * x + -349.47)\n"
     ]
    }
   ],
   "source": [
    "#print(bmarks[3])\n",
    "\n",
    "bk_terms = bmarks[3][:,0]\n",
    "bk_times = bmarks[3][:,2]\n",
    "    \n",
    "# Fit the benchmarks\n",
    "runtime_fit_func = get_runtime_fit_func('BK_FULL')\n",
    "\n",
    "rpopt, rpcov = curve_fit(runtime_fit_func, bk_terms, bk_times)\n",
    "eqn = '{:.5f} * {:.2f}**({:.2f} * x + {:.2f})'.format(*rpopt)\n",
    "print(eqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}