From 2c1a57a74cdcaff4f38a7f76627853ef7149d5a7 Mon Sep 17 00:00:00 2001
From: Jonhas Saul Colina <jonhas@lanl.gov>
Date: Thu, 21 Nov 2024 15:17:48 -0700
Subject: [PATCH 1/5] made qchem script singlethreaded

---
 scripts/AP-RE.py | 197 +++++++++++++++++++++++++++--------------------
 1 file changed, 114 insertions(+), 83 deletions(-)

diff --git a/scripts/AP-RE.py b/scripts/AP-RE.py
index 4d4af3a..0dd4d7d 100644
--- a/scripts/AP-RE.py
+++ b/scripts/AP-RE.py
@@ -1,7 +1,6 @@
 import os
 from dataclasses import dataclass
 from argparse import ArgumentParser, Namespace
-from concurrent.futures import ThreadPoolExecutor, as_completed, ProcessPoolExecutor
 from qca.utils.chemistry_utils import load_pathway, generate_electronic_hamiltonians, gsee_molecular_hamiltonian
 
 
@@ -17,7 +16,63 @@ def grab_arguments() -> Namespace:
         '--active_space_reduction',
         type=int,
         help='Factor to reduce the active space',
-        default=10
+        default=1
+    )
+    parser.add_argument(
+        '-F',
+        '--fname',
+        type=str,
+        help='absolute filepath pointing to xyz file for extracting molecular hamiltonian along a reaction pathway',
+        required=True
+    )
+    parser.add_argument(
+        '-B',
+        '--basis',
+        type=str,
+        help='basis working in',
+        default='sto-3g'
+    )
+    parser.add_argument(
+        '-T',
+        '--evolution_time',
+        type=float,
+        help='Float representing total evolution time if approximating exp^{iHt} for phase estimation',
+        default=1
+    )
+    parser.add_argument(
+        '-O',
+        '--trotter_order',
+        type=int,
+        help='specify trotter order if using a trotter subprocess for phase estimation',
+        default=2
+    )
+    parser.add_argument(
+        '-S',
+        '--trotter_steps',
+        type=int,
+        help='Number of trotter steps if using a trotter subprocess for phase estimation',
+        default=1
+    )
+    parser.add_argument(
+        '-P',
+        '--pathway',
+        metavar='N',
+        type=int,
+        nargs='*',
+        help='reaction pathway of interest'
+    )
+    parser.add_argument(
+        '-D',
+        '--dir',
+        type=str,
+        default=os.path.dirname(os.path.realpath(__file__)),
+        help='directory to store generated resource estimates')
+    parser.add_argument(
+        '-BP',
+        '--bits_prec',
+        type=int,
+        default=10,
+        help='Number of bits to estimate phase to'
     )
     parser.add_argument(
         '-d', 
@@ -29,92 +84,68 @@ def grab_arguments() -> Namespace:
     args = parser.parse_args()
     return args
 
-def generate_ap_re(
-        catalyst_name:str,
-        num_processes:int,
-        hamiltonians: list,
-        gsee_args:dict,
-        trotter_steps:int,
-        bits_precision: int
-    ):
-    results = []
-    with ProcessPoolExecutor(max_workers=num_processes) as executor:
-        for idx, hamiltonian in enumerate(hamiltonians):
-            future = executor.submit(
-                gsee_molecular_hamiltonian,
-                f'pathway({idx})_{catalyst_name}',
-                gsee_args,
-                trotter_steps,
-                bits_precision,
-                hamiltonian
-            )
-            results.append(future)
-        for future in as_completed(results):
-            print(f'completed')
-
-def grab_molecular_hamiltonians_pool(
+def trotter_subprocess(
+        outdir:str,
+        fname:str,
+        pathway: list[int],
+        basis:str,
+        ev_time:float,
         active_space_reduc:float,
-        num_processes:int,
-        pathways: list,
-        basis:str
-    ) -> list:
-    hamiltonians = []
-    results = []
-    with ThreadPoolExecutor(max_workers=num_processes) as executor:
-        for coords in pathways:
-            future = executor.submit(
-                generate_electronic_hamiltonians,
-                basis, active_space_reduc, coords, 1
-            )
-            results.append(future)
-        for future in as_completed(results):
-            hamiltonians.append(future.result())
-    return hamiltonians
+        trotter_order:int,
+        trotter_steps:int,
+        bits_precision:int
+):
+    coords_pathways = load_pathway(fname, pathway)
+    molecular_hamiltonians = generate_electronic_hamiltonians(
+        basis=basis,
+        active_space_frac=active_space_reduc,
+        coordinates_pathway=coords_pathways,
+        run_scf=1
+    )
+    catalyst_name = fname.split('.xyz')[0]
+    gsee_args = {
+        'trotterize' : True,
+        'ev_time'    : ev_time,
+        'trot_ord'   : trotter_order,
+        'trot_num'   : trotter_steps
+    }
+    gsee_molecular_hamiltonian(
+        outdir=outdir,
+        catalyst_name=catalyst_name,
+        gse_args=gsee_args,
+        trotter_steps=trotter_steps,
+        bits_precision=bits_precision,
+        molecular_hamiltonians=molecular_hamiltonians
+    )
 
 
 if __name__ == '__main__':
     pid = os.getpid()
     args = grab_arguments()
+    pathway = args.pathway
+    if not pathway:
+        raise LookupError('Unspecified reaction pathway')
+    
+    outdir = args.outdir
+    if not os.path.exists(outdir):
+        os.makedirs(outdir)
+
+    fname = args.fname
+    bits_precision = args.bits_prec
     active_space_reduc = args.active_space_reduction
-    pathway_directory= args.directory
-    pathways = [
-        pathway_info(
-            pathway=[27, 1, 14, 15, 16, 24, 25, 26],
-            fname=f'{pathway_directory}water_oxidation_Co2O9H12.xyz'
-        ),
-        pathway_info(
-            pathway=[3, 1, 14, 15, 16, 20, 21, 22, 23],
-            fname=f'{pathway_directory}water_oxidation_Co2O9H12.xyz'
-        ),
-        pathway_info(
-            pathway=[2, 1, 14, 15, 16, 17, 18, 19],
-            fname='{pathway_directory}water_oxidation_Co2O9H12.xyz'
-        ),
-        pathway_info(
-            pathway=[5, 10, 28, 29, 30, 31, 32, 33],
-            fname='{pathway_directory}water_oxidation_Co2O9H12.xyz'
-        )
-    ]
-    coords_pathways = [
-        load_pathway(pathway.fname, pathway.pathway) for pathway in pathways
-    ]
-    molecular_hamiltonians = grab_molecular_hamiltonians_pool(
+    basis = args.basis
+    evolution_time = args.evolution_time
+    trotter_order = args.trotter_order
+    trotter_steps = args.trotter_steps 
+    
+    trotter_subprocess(
+        outdir=outdir,
+        fname=fname,
+        pathway=pathway,
+        basis=basis,
+        ev_time=evolution_time,
         active_space_reduc=active_space_reduc,
-        num_processes=len(pathways),
-        pathways=coords_pathways,
-        basis='sto-3g'
-    )
-    gsee_args = {
-        'trotterize' : True,
-        'ev_time'    : 1,
-        'trot_ord'   : 2,
-        'trot_num'   : 1
-    }
-    generate_ap_re(
-        catalyst_name='Co2O9H12',
-        num_processes=len(pathways),
-        hamiltonians=molecular_hamiltonians,
-        gsee_args=gsee_args,
-        trotter_steps=1,
-        bits_precision=10
-    )
+        trotter_order=trotter_order,
+        trotter_steps=trotter_steps,
+        bits_precision=bits_precision
+    )    

From 4ccad005518696a0d6d66bdf16c98bd9569bca11 Mon Sep 17 00:00:00 2001
From: Jonhas Saul Colina <jonhas@lanl.gov>
Date: Wed, 4 Dec 2024 13:52:11 -0700
Subject: [PATCH 2/5] further clean up for verifying resources are scaled
 properly

---
 ...HighTemperatureSuperConductorExample.ipynb | 148 ++++---
 notebooks/MagneticLattices.ipynb              | 212 +++++-----
 notebooks/PhotosynthesisExample.ipynb         | 361 ++----------------
 notebooks/RuClExample.ipynb                   |   8 +-
 scripts/DickeModel.py                         |   2 +-
 scripts/QCD-RE.py                             |   1 -
 src/qca/utils/algo_utils.py                   | 141 +++----
 src/qca/utils/chemistry_utils.py              |  54 ++-
 src/qca/utils/utils.py                        | 135 ++++---
 9 files changed, 403 insertions(+), 659 deletions(-)

diff --git a/notebooks/HighTemperatureSuperConductorExample.ipynb b/notebooks/HighTemperatureSuperConductorExample.ipynb
index 8e9a045..4ad2795 100644
--- a/notebooks/HighTemperatureSuperConductorExample.ipynb
+++ b/notebooks/HighTemperatureSuperConductorExample.ipynb
@@ -54,16 +54,7 @@
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gsgrattan/.conda/envs/qc-apps/lib/python3.11/site-packages/cotengra/hyperoptimizers/hyper.py:33: UserWarning: Couldn't import `kahypar` - skipping from default hyper optimizer and using basic `labels` method instead.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import time\n",
     "\n",
@@ -160,8 +151,8 @@
     "    category='scientific',\n",
     "    size=f'{n}x{n}',\n",
     "    task='Ground State Energy Estimation',\n",
-    "\n",
     "    evolution_time=t_one_band,\n",
+    "    is_extrapolated=True,\n",
     "    trotter_order=trotter_order_one_band,\n",
     "    bits_precision=bits_precision_one_band,\n",
     "    nsteps=trotter_steps_one_band,\n",
@@ -188,18 +179,18 @@
      "output_type": "stream",
      "text": [
       "Estimating one_band\n",
-      "Time to generate circuit for GSEE: 7.358298171311617e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 0.0002579170395620167 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00040374998934566975 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 2.0458013750612736e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 9.665964171290398e-06 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 9.662494994699955e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.0001105000264942646 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 0.0451331670046784 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 0.3732286249869503 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.0001948749995790422 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 3.7833990063518286e-05 seconds\n",
-      "Time to estimate one_band: 0.7837549999821931\n"
+      "Time to generate circuit for GSEE: 8.829217404127121e-05 seconds\n",
+      "   Time to decompose high level HPowGate circuit: 0.0002071247436106205 seconds \n",
+      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0005226251669228077 seconds\n",
+      "   Time to decompose high level IdentityGate circuit: 1.4707911759614944e-05 seconds \n",
+      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 4.082918167114258e-06 seconds\n",
+      "   Time to decompose high level PhaseOffset circuit: 8.604209870100021e-05 seconds \n",
+      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00012337509542703629 seconds\n",
+      "   Time to decompose high level Trotter_Unitary circuit: 0.08032337483018637 seconds \n",
+      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 0.27045220835134387 seconds\n",
+      "   Time to decompose high level MeasurementGate circuit: 0.000187666155397892 seconds \n",
+      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.083290696144104e-05 seconds\n",
+      "Time to estimate one_band: 0.6402935408987105\n"
      ]
     }
    ],
@@ -216,6 +207,7 @@
     "    phase_offset=one_band_phase_offset,\n",
     "    circuit_name='one_band',\n",
     "    metadata=one_band_metadata,\n",
+    "    include_nested_resources=True,\n",
     "    write_circuits=True\n",
     ")\n",
     "t1 = time.perf_counter()\n",
@@ -513,12 +505,11 @@
     "    category='scientific',\n",
     "    size=f'{6}x{7}',\n",
     "    task='Ground State Energy Estimation',\n",
-    "\n",
     "    evolution_time=t_current_limit,\n",
+    "    is_extrapolated=True,\n",
     "    trotter_order=trotter_order_current_limit,\n",
     "    bits_precision=bits_precision_current_limit,\n",
     "    nsteps=trotter_steps_current_limit,\n",
-    "\n",
     ")\n",
     "\n",
     "metadata_ideal = GSEEMetaData(\n",
@@ -531,7 +522,6 @@
     "    trotter_order=trotter_order_ideal,\n",
     "    bits_precision=bits_precision_ideal,\n",
     "    nsteps=trotter_steps_ideal,\n",
-    "\n",
     ")"
    ]
   },
@@ -545,31 +535,31 @@
      "output_type": "stream",
      "text": [
       "Estimating Current Limit\n",
-      "Time to generate circuit for GSEE: 9.895797120407224e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 0.0002941249986179173 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0009380419505760074 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.6625039279460907e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 4.499976057559252e-06 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 8.404103573411703e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00010008300887420774 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 0.25881625001784414 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 0.9029138330370188 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.001000499993097037 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.299997817724943e-05 seconds\n",
-      "Time to estimate Current Limit: 2.4191256249905564\n",
+      "Time to generate circuit for GSEE: 3.21660190820694e-05 seconds\n",
+      "   Time to decompose high level HPowGate circuit: 0.00010754214599728584 seconds \n",
+      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00019329087808728218 seconds\n",
+      "   Time to decompose high level IdentityGate circuit: 1.3499986380338669e-05 seconds \n",
+      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.708992153406143e-06 seconds\n",
+      "   Time to decompose high level PhaseOffset circuit: 7.729092612862587e-05 seconds \n",
+      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 8.945818990468979e-05 seconds\n",
+      "   Time to decompose high level Trotter_Unitary circuit: 0.1907161669805646 seconds \n",
+      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 0.922632624860853 seconds\n",
+      "   Time to decompose high level MeasurementGate circuit: 0.0007120422087609768 seconds \n",
+      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.1250139474868774e-05 seconds\n",
+      "Time to estimate Current Limit: 2.1353615829721093\n",
       "Estimating Ideal\n",
-      "Time to generate circuit for GSEE: 3.4584023524075747e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 6.941700121387839e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 9.016698459163308e-05 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.0707997716963291e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.5830307751893997e-06 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 7.508299313485622e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 3.8833997678011656e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 0.27210870798444375 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 0.6658007500227541 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.0008316660532727838 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.2208004742860794e-05 seconds\n",
-      "Time to estimate Ideal: 2.424980083014816\n"
+      "Time to generate circuit for GSEE: 2.8833281248807907e-05 seconds\n",
+      "   Time to decompose high level HPowGate circuit: 6.658397614955902e-05 seconds \n",
+      "   Time to transform decomposed HPowGate circuit to Clifford+T: 7.66250304877758e-05 seconds\n",
+      "   Time to decompose high level IdentityGate circuit: 1.0250136256217957e-05 seconds \n",
+      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 2.9583461582660675e-06 seconds\n",
+      "   Time to decompose high level PhaseOffset circuit: 6.0750171542167664e-05 seconds \n",
+      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 3.5291071981191635e-05 seconds\n",
+      "   Time to decompose high level Trotter_Unitary circuit: 0.2048220420256257 seconds \n",
+      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 0.5036598341539502 seconds\n",
+      "   Time to decompose high level MeasurementGate circuit: 0.0007734578102827072 seconds \n",
+      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.216702654957771e-05 seconds\n",
+      "Time to estimate Ideal: 1.7194426669739187\n"
      ]
     }
    ],
@@ -587,6 +577,7 @@
     "    phase_offset=phase_offset_current_limit,\n",
     "    circuit_name='two_band_current_limit',\n",
     "    metadata=metadata_current_limit,\n",
+    "    include_nested_resources=True,\n",
     "    write_circuits=True\n",
     ")\n",
     "t1 = time.perf_counter()\n",
@@ -604,6 +595,7 @@
     "    phase_offset=phase_offset_ideal,\n",
     "    circuit_name='two_band_ideal',\n",
     "    metadata=metadata_ideal,\n",
+    "    include_nested_resources=True,\n",
     "    write_circuits=True\n",
     ")\n",
     "t1 = time.perf_counter()\n",
@@ -1038,6 +1030,7 @@
     "    task='Ground State Energy Estimation',\n",
     "\n",
     "    evolution_time=t_current_limit,\n",
+    "    is_extrapolated=True,\n",
     "    trotter_order=trotter_order_current_limit,\n",
     "    bits_precision=bits_precision_current_limit,\n",
     "    nsteps=trotter_steps_current_limit,\n",
@@ -1066,31 +1059,31 @@
      "output_type": "stream",
      "text": [
       "Estimating Current Limit\n",
-      "Time to generate circuit for GSEE: 0.00012049998622387648 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 0.00010195799404755235 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00022904202342033386 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 2.5374989490956068e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 5.208014044910669e-06 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 9.14589618332684e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00010649999603629112 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 0.6369308329885826 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 2.6309287089970894 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.0021917499834671617 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.954199539497495e-05 seconds\n",
-      "Time to estimate Current Limit: 6.172279916994739\n",
+      "Time to generate circuit for GSEE: 3.4874770790338516e-05 seconds\n",
+      "   Time to decompose high level HPowGate circuit: 0.00011974992230534554 seconds \n",
+      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00022624991834163666 seconds\n",
+      "   Time to decompose high level IdentityGate circuit: 1.5125144273042679e-05 seconds \n",
+      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.7918798625469208e-06 seconds\n",
+      "   Time to decompose high level PhaseOffset circuit: 8.566631004214287e-05 seconds \n",
+      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00010370789095759392 seconds\n",
+      "   Time to decompose high level Trotter_Unitary circuit: 0.6261392920278013 seconds \n",
+      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 2.3303427919745445 seconds\n",
+      "   Time to decompose high level MeasurementGate circuit: 0.002318750135600567 seconds \n",
+      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 4.862481728196144e-05 seconds\n",
+      "Time to estimate Current Limit: 5.381249750033021\n",
       "Estimating Ideal\n",
-      "Time to generate circuit for GSEE: 4.7291978262364864e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 8.358299965038896e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0001830410328693688 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.591700129210949e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.915978595614433e-06 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 7.058301707729697e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 8.283299393951893e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 0.5475135830347426 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 2.4883924159803428 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.002176332985982299 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 5.570799112319946e-05 seconds\n",
-      "Time to estimate Ideal: 6.056912083993666\n"
+      "Time to generate circuit for GSEE: 2.8333161026239395e-05 seconds\n",
+      "   Time to decompose high level HPowGate circuit: 7.39172101020813e-05 seconds \n",
+      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00020616687834262848 seconds\n",
+      "   Time to decompose high level IdentityGate circuit: 1.041637733578682e-05 seconds \n",
+      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 2.9997900128364563e-06 seconds\n",
+      "   Time to decompose high level PhaseOffset circuit: 6.391620263457298e-05 seconds \n",
+      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 7.108272984623909e-05 seconds\n",
+      "   Time to decompose high level Trotter_Unitary circuit: 0.5104598328471184 seconds \n",
+      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 2.089019749779254 seconds\n",
+      "   Time to decompose high level MeasurementGate circuit: 0.002230667043477297 seconds \n",
+      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 5.258386954665184e-05 seconds\n",
+      "Time to estimate Ideal: 5.026830167043954\n"
      ]
     }
    ],
@@ -1108,8 +1101,10 @@
     "    phase_offset=phase_offset_current_limit,\n",
     "    circuit_name='three_band_current_limit',\n",
     "    metadata=metadata_current_limit,\n",
+    "    include_nested_resources=True,\n",
     "    write_circuits=True\n",
     ")\n",
+    "\n",
     "t1 = time.perf_counter()\n",
     "print(f'Time to estimate Current Limit: {t1-t0}')\n",
     "\n",
@@ -1125,6 +1120,7 @@
     "    phase_offset=phase_offset_ideal,\n",
     "    circuit_name='three_band_ideal',\n",
     "    metadata=metadata_ideal,\n",
+    "    include_nested_resources=True,\n",
     "    write_circuits=True\n",
     ")\n",
     "t1 = time.perf_counter()\n",
@@ -1150,7 +1146,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qc-apps",
+   "display_name": "qiskit",
    "language": "python",
    "name": "python3"
   },
@@ -1164,7 +1160,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.10"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/MagneticLattices.ipynb b/notebooks/MagneticLattices.ipynb
index d662205..58da227 100644
--- a/notebooks/MagneticLattices.ipynb
+++ b/notebooks/MagneticLattices.ipynb
@@ -47,16 +47,7 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gsgrattan/.conda/envs/qc-apps/lib/python3.11/site-packages/cotengra/hyperoptimizers/hyper.py:33: UserWarning: Couldn't import `kahypar` - skipping from default hyper optimizer and using basic `labels` method instead.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import random\n",
@@ -95,7 +86,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -115,7 +106,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -135,7 +126,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -272,51 +263,51 @@
      "output_type": "stream",
      "text": [
       "Estimating Square\n",
-      "Time to generate high level QSP circuit: 0.07294041698332876 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 4.199997056275606e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.0875013433396816e-05 seconds\n",
-      "   Time to decompose high level Rx circuit: 2.0250037778168917e-05 seconds \n",
-      "   Time to transform decomposed Rx circuit to Clifford+T: 0.006910957978107035 seconds\n",
-      "   Time to decompose high level UnitaryBlockEncode circuit: 0.3236018340103328 seconds \n",
-      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 1.4018742089974694 seconds\n",
-      "   Time to decompose high level Ry circuit: 0.0019690829794853926 seconds \n",
-      "   Time to transform decomposed Ry circuit to Clifford+T: 0.005708707962185144 seconds\n",
-      "   Time to decompose high level _InverseCompositeGate circuit: 0.25324670801637694 seconds \n",
-      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 1.350836208963301 seconds\n",
-      "   Time to decompose high level Reflect circuit: 0.006207542028278112 seconds \n",
-      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.01463116699596867 seconds\n",
+      "Time to generate high level QSP circuit: 0.06965958303771913 seconds\n",
+      "   Time to decompose high level _PauliX circuit: 5.833292379975319e-05 seconds \n",
+      "   Time to transform decomposed _PauliX circuit to Clifford+T: 3.374996595084667e-05 seconds\n",
+      "   Time to decompose high level Rx circuit: 3.554113209247589e-05 seconds \n",
+      "   Time to transform decomposed Rx circuit to Clifford+T: 0.006626832997426391 seconds\n",
+      "   Time to decompose high level UnitaryBlockEncode circuit: 0.2772244580555707 seconds \n",
+      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 1.234536041971296 seconds\n",
+      "   Time to decompose high level Ry circuit: 0.00180275016464293 seconds \n",
+      "   Time to transform decomposed Ry circuit to Clifford+T: 0.005293166963383555 seconds\n",
+      "   Time to decompose high level _InverseCompositeGate circuit: 0.3240664158947766 seconds \n",
+      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 1.1724504169542342 seconds\n",
+      "   Time to decompose high level Reflect circuit: 0.005576208001002669 seconds \n",
+      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.014132832875475287 seconds\n",
       "\n",
       "\n",
       "Estimating Triangle\n",
-      "Time to generate high level QSP circuit: 4.435369957995135 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 6.42079976387322e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.8958020266145468e-05 seconds\n",
-      "   Time to decompose high level Rx circuit: 2.358300844207406e-05 seconds \n",
-      "   Time to transform decomposed Rx circuit to Clifford+T: 0.006856874970253557 seconds\n",
-      "   Time to decompose high level UnitaryBlockEncode circuit: 4.713378958986141 seconds \n",
-      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 12.167330832977314 seconds\n",
-      "   Time to decompose high level Ry circuit: 0.023170665954239666 seconds \n",
-      "   Time to transform decomposed Ry circuit to Clifford+T: 0.005780374980531633 seconds\n",
-      "   Time to decompose high level _InverseCompositeGate circuit: 4.896896124992054 seconds \n",
-      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 13.390764708048664 seconds\n",
-      "   Time to decompose high level Reflect circuit: 0.03417441598139703 seconds \n",
-      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.01879554201150313 seconds\n",
+      "Time to generate high level QSP circuit: 4.0657045831903815 seconds\n",
+      "   Time to decompose high level _PauliX circuit: 5.762488581240177e-05 seconds \n",
+      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.7708010748028755e-05 seconds\n",
+      "   Time to decompose high level Rx circuit: 2.2458145394921303e-05 seconds \n",
+      "   Time to transform decomposed Rx circuit to Clifford+T: 0.006108333123847842 seconds\n",
+      "   Time to decompose high level UnitaryBlockEncode circuit: 4.093156208051369 seconds \n",
+      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 10.878704624949023 seconds\n",
+      "   Time to decompose high level Ry circuit: 0.022647832985967398 seconds \n",
+      "   Time to transform decomposed Ry circuit to Clifford+T: 0.005263958126306534 seconds\n",
+      "   Time to decompose high level _InverseCompositeGate circuit: 4.221154749859124 seconds \n",
+      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 11.523308167001233 seconds\n",
+      "   Time to decompose high level Reflect circuit: 0.030207333154976368 seconds \n",
+      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.016942042158916593 seconds\n",
       "\n",
       "\n",
       "Estimating Cube\n",
-      "Time to generate high level QSP circuit: 11.534532958990894 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 5.116598913446069e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.0875013433396816e-05 seconds\n",
-      "   Time to decompose high level Rx circuit: 2.31250305660069e-05 seconds \n",
-      "   Time to transform decomposed Rx circuit to Clifford+T: 0.033716583042405546 seconds\n",
-      "   Time to decompose high level UnitaryBlockEncode circuit: 9.297313249961007 seconds \n",
-      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 18.542402041959576 seconds\n",
-      "   Time to decompose high level Ry circuit: 0.039301375043578446 seconds \n",
-      "   Time to transform decomposed Ry circuit to Clifford+T: 0.0058032089727930725 seconds\n",
-      "   Time to decompose high level _InverseCompositeGate circuit: 6.9808499999926426 seconds \n",
-      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 18.716713583969977 seconds\n",
-      "   Time to decompose high level Reflect circuit: 0.05238858296070248 seconds \n",
-      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.020020500000100583 seconds\n",
+      "Time to generate high level QSP circuit: 9.836493375012651 seconds\n",
+      "   Time to decompose high level _PauliX circuit: 6.208289414644241e-05 seconds \n",
+      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.3207860067486763e-05 seconds\n",
+      "   Time to decompose high level Rx circuit: 2.6792054995894432e-05 seconds \n",
+      "   Time to transform decomposed Rx circuit to Clifford+T: 0.029946082970127463 seconds\n",
+      "   Time to decompose high level UnitaryBlockEncode circuit: 7.919939290964976 seconds \n",
+      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 16.951076458906755 seconds\n",
+      "   Time to decompose high level Ry circuit: 0.03846574993804097 seconds \n",
+      "   Time to transform decomposed Ry circuit to Clifford+T: 0.0048814581241458654 seconds\n",
+      "   Time to decompose high level _InverseCompositeGate circuit: 7.507090208120644 seconds \n",
+      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 16.57720954087563 seconds\n",
+      "   Time to decompose high level Reflect circuit: 0.048335416009649634 seconds \n",
+      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.0178060419857502 seconds\n",
       "Finished estimating\n"
      ]
     }
@@ -329,6 +320,7 @@
     "    nsteps=numsteps,\n",
     "    energy_precision=required_precision,\n",
     "    outdir='QSP/square_circuits/',\n",
+    "    is_extrapolated=True,\n",
     "    hamiltonian_name='square_qsp',\n",
     "    metadata=square_lattice_metadata,\n",
     "    write_circuits=True,\n",
@@ -343,6 +335,7 @@
     "    energy_precision=required_precision,\n",
     "    metadata=triangle_lattice_metadata,\n",
     "    outdir='QSP/triangle_circuits/',\n",
+    "    is_extrapolated=True,\n",
     "    hamiltonian_name='triangle_qsp',\n",
     "    write_circuits=True\n",
     ")\n",
@@ -356,6 +349,7 @@
     "    energy_precision=required_precision,\n",
     "    metadata=cubic_lattice_metadata,\n",
     "    outdir='QSP/cube_circuits/',\n",
+    "    is_extrapolated=True,\n",
     "    hamiltonian_name='cube_qsp',\n",
     "    write_circuits=True\n",
     ")\n",
@@ -445,19 +439,19 @@
      "output_type": "stream",
      "text": [
       "Estimating Kitaev\n",
-      "Time to generate high level QSP circuit: 9.133365333022084 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 6.0999998822808266e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.9458006136119366e-05 seconds\n",
-      "   Time to decompose high level Rx circuit: 1.899997005239129e-05 seconds \n",
-      "   Time to transform decomposed Rx circuit to Clifford+T: 0.00787954096449539 seconds\n",
-      "   Time to decompose high level UnitaryBlockEncode circuit: 2.8740033750073053 seconds \n",
-      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 12.072705541970208 seconds\n",
-      "   Time to decompose high level Ry circuit: 0.019660042016766965 seconds \n",
-      "   Time to transform decomposed Ry circuit to Clifford+T: 0.0059122079983353615 seconds\n",
-      "   Time to decompose high level _InverseCompositeGate circuit: 3.7868810829822905 seconds \n",
-      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 13.98899787501432 seconds\n",
-      "   Time to decompose high level Reflect circuit: 0.029673249984625727 seconds \n",
-      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.019305041001643986 seconds\n",
+      "Time to generate high level QSP circuit: 7.575929458020255 seconds\n",
+      "   Time to decompose high level _PauliX circuit: 6.258301436901093e-05 seconds \n",
+      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.2500054910779e-05 seconds\n",
+      "   Time to decompose high level Rx circuit: 2.5667017325758934e-05 seconds \n",
+      "   Time to transform decomposed Rx circuit to Clifford+T: 0.007690083933994174 seconds\n",
+      "   Time to decompose high level UnitaryBlockEncode circuit: 2.4533662090543658 seconds \n",
+      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 13.352491625119 seconds\n",
+      "   Time to decompose high level Ry circuit: 0.01861945795826614 seconds \n",
+      "   Time to transform decomposed Ry circuit to Clifford+T: 0.0051710831467062235 seconds\n",
+      "   Time to decompose high level _InverseCompositeGate circuit: 3.2934341658838093 seconds \n",
+      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 12.298424375010654 seconds\n",
+      "   Time to decompose high level Reflect circuit: 0.026168124983087182 seconds \n",
+      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.017014249926432967 seconds\n",
       "Finished Estimating\n"
      ]
     }
@@ -493,6 +487,7 @@
     "    energy_precision=required_precision,\n",
     "    metadata=kitaev_metadata,\n",
     "    outdir='QSP/kitaev_circuits/',\n",
+    "    is_extrapolated=True,\n",
     "    hamiltonian_name='kitaev_qsp',\n",
     "    write_circuits=True\n",
     ")\n",
@@ -551,19 +546,19 @@
      "output_type": "stream",
      "text": [
       "Estimating Directional Triangle\n",
-      "Time to generate high level QSP circuit: 4.235135082970373 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 6.212497828528285e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.120796125382185e-05 seconds\n",
-      "   Time to decompose high level Rx circuit: 2.0875013433396816e-05 seconds \n",
-      "   Time to transform decomposed Rx circuit to Clifford+T: 0.00715437502367422 seconds\n",
-      "   Time to decompose high level UnitaryBlockEncode circuit: 2.4512442080304027 seconds \n",
-      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 17.03530916699674 seconds\n",
-      "   Time to decompose high level Ry circuit: 0.0189153749961406 seconds \n",
-      "   Time to transform decomposed Ry circuit to Clifford+T: 0.00599454203620553 seconds\n",
-      "   Time to decompose high level _InverseCompositeGate circuit: 4.911995624948759 seconds \n",
-      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 14.278082708013244 seconds\n",
-      "   Time to decompose high level Reflect circuit: 0.028568209032528102 seconds \n",
-      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.018655833031516522 seconds\n",
+      "Time to generate high level QSP circuit: 3.707169875036925 seconds\n",
+      "   Time to decompose high level _PauliX circuit: 5.983281880617142e-05 seconds \n",
+      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.150004729628563e-05 seconds\n",
+      "   Time to decompose high level Rx circuit: 2.533290535211563e-05 seconds \n",
+      "   Time to transform decomposed Rx circuit to Clifford+T: 0.006716583156958222 seconds\n",
+      "   Time to decompose high level UnitaryBlockEncode circuit: 4.903565749991685 seconds \n",
+      "   Time to transform decomposed UnitaryBlockEncode circuit to Clifford+T: 16.266026666853577 seconds\n",
+      "   Time to decompose high level Ry circuit: 0.01780537492595613 seconds \n",
+      "   Time to transform decomposed Ry circuit to Clifford+T: 0.0051700829062610865 seconds\n",
+      "   Time to decompose high level _InverseCompositeGate circuit: 4.265650084009394 seconds \n",
+      "   Time to transform decomposed _InverseCompositeGate circuit to Clifford+T: 10.68878316716291 seconds\n",
+      "   Time to decompose high level Reflect circuit: 0.024908625055104494 seconds \n",
+      "   Time to transform decomposed Reflect circuit to Clifford+T: 0.017183625139296055 seconds\n",
       "Finished Estimating\n"
      ]
     }
@@ -597,6 +592,7 @@
     "    energy_precision=required_precision,\n",
     "    metadata=directional_trangle_metadata,\n",
     "    outdir='QSP/directional_triangle_circuits/',\n",
+    "    is_extrapolated=True,\n",
     "    hamiltonian_name='directional_triangle_qsp',\n",
     "    write_circuits=True\n",
     ")\n",
@@ -613,7 +609,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -715,7 +711,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -723,30 +719,30 @@
      "output_type": "stream",
      "text": [
       "Estimating Square\n",
-      "Time to estimate number of trotter steps required (5366564): 0.02420575002906844 seconds\n",
-      "Time to find term ordering: 0.001630583021324128 seconds\n",
-      "Time to generate trotter circuit from openfermion: 1.2500095181167126e-06 seconds\n",
-      "Time to generate a clifford + T circuit from trotter circuit: 3.175797624979168 seconds\n",
+      "Time to estimate number of trotter steps required (5366564): 0.016520957928150892 seconds\n",
+      "Time to find term ordering: 0.0014389159623533487 seconds\n",
+      "Time to generate trotter circuit from openfermion: 2.2498425096273422e-06 seconds\n",
+      "Time to generate a clifford + T circuit from trotter circuit: 2.6563032080885023 seconds\n",
       "Estimating Triangle\n",
-      "Time to estimate number of trotter steps required (21707142): 2.472716875025071 seconds\n",
-      "Time to find term ordering: 0.02231966599356383 seconds\n",
-      "Time to generate trotter circuit from openfermion: 1.249951310455799e-06 seconds\n",
-      "Time to generate a clifford + T circuit from trotter circuit: 43.7863163750153 seconds\n",
+      "Time to estimate number of trotter steps required (21707142): 3.013047874905169 seconds\n",
+      "Time to find term ordering: 0.02902133297175169 seconds\n",
+      "Time to generate trotter circuit from openfermion: 9.159557521343231e-07 seconds\n",
+      "Time to generate a clifford + T circuit from trotter circuit: 61.94812729093246 seconds\n",
       "Estimating Cube\n",
-      "Time to estimate number of trotter steps required (27573901): 6.365963499993086 seconds\n",
-      "Time to find term ordering: 0.03880191600183025 seconds\n",
-      "Time to generate trotter circuit from openfermion: 1.3750395737588406e-06 seconds\n",
-      "Time to generate a clifford + T circuit from trotter circuit: 69.69336341699818 seconds\n",
+      "Time to estimate number of trotter steps required (27573901): 5.7627622911240906 seconds\n",
+      "Time to find term ordering: 0.03463420900516212 seconds\n",
+      "Time to generate trotter circuit from openfermion: 1.375097781419754e-06 seconds\n",
+      "Time to generate a clifford + T circuit from trotter circuit: 86.67847820883617 seconds\n",
       "Estimating Kitaev\n",
-      "Time to estimate number of trotter steps required (222782406): 1.8363965000025928 seconds\n",
-      "Time to find term ordering: 0.01799762499285862 seconds\n",
-      "Time to generate trotter circuit from openfermion: 1.2500095181167126e-06 seconds\n",
-      "Time to generate a clifford + T circuit from trotter circuit: 36.06559366598958 seconds\n",
+      "Time to estimate number of trotter steps required (222782406): 1.547266084002331 seconds\n",
+      "Time to find term ordering: 0.015753416111692786 seconds\n",
+      "Time to generate trotter circuit from openfermion: 1.1669471859931946e-06 seconds\n",
+      "Time to generate a clifford + T circuit from trotter circuit: 44.65685283392668 seconds\n",
       "Estimating Directional Triangle\n",
-      "Time to estimate number of trotter steps required (433303589): 1.6750391669920646 seconds\n",
-      "Time to find term ordering: 0.023808708996511996 seconds\n",
-      "Time to generate trotter circuit from openfermion: 1.2080417945981026e-06 seconds\n",
-      "Time to generate a clifford + T circuit from trotter circuit: 42.000205042015295 seconds\n",
+      "Time to estimate number of trotter steps required (433303589): 1.4453202500008047 seconds\n",
+      "Time to find term ordering: 0.021794125204905868 seconds\n",
+      "Time to generate trotter circuit from openfermion: 1.1669471859931946e-06 seconds\n",
+      "Time to generate a clifford + T circuit from trotter circuit: 46.65967670897953 seconds\n",
       "Finished with estimates\n"
      ]
     }
@@ -811,7 +807,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -825,7 +821,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -850,7 +846,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -875,7 +871,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -900,7 +896,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -925,7 +921,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -958,7 +954,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qc-apps",
+   "display_name": "qca",
    "language": "python",
    "name": "python3"
   },
@@ -972,7 +968,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.10"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/PhotosynthesisExample.ipynb b/notebooks/PhotosynthesisExample.ipynb
index b613348..90745cc 100644
--- a/notebooks/PhotosynthesisExample.ipynb
+++ b/notebooks/PhotosynthesisExample.ipynb
@@ -45,28 +45,22 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/gsgrattan/.conda/envs/qc-apps/lib/python3.11/site-packages/cotengra/hyperoptimizers/hyper.py:33: UserWarning: Couldn't import `kahypar` - skipping from default hyper optimizer and using basic `labels` method instead.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import re\n",
     "import sys\n",
     "import time\n",
+    "from dataclasses import dataclass\n",
+    "\n",
     "import cirq\n",
+    "\n",
     "import numpy as np\n",
-    "from dataclasses import dataclass\n",
+    "\n",
     "from openfermionpyscf import run_pyscf\n",
     "from openfermion.chem import MolecularData\n",
-    "from pyLIQTR.PhaseEstimation.pe import PhaseEstimation\n",
     "from openfermion.ops.representations import InteractionOperator\n",
-    "from qca.utils.utils import extract_number, gen_resource_estimate, GSEEMetaData\n",
+    "\n",
+    "from qca.utils.utils import extract_number, gen_resource_estimate, CatalystMetaData\n",
     "from qca.utils.algo_utils import gsee_resource_estimation"
    ]
   },
@@ -218,142 +212,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Time to perform a HF calculation on molecule 0 : 44.94567812496098\n",
-      "Number of orbitals          : 100\n",
-      "Number of electrons         : 148\n",
-      "Number of qubits            : 200\n",
-      "Hartree-Fock energy         : -3479.3603932694523\n",
-      "Number of unoccupied Molecular orbitals are: 26\n",
-      "Number of occupied Molecular orbitals are: 74\n",
-      "active_space start : 67\n",
-      "active_space stop  : 76\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 0 : 44.95591650001006\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 1 : 59.59993424999993\n",
-      "Number of orbitals          : 99\n",
-      "Number of electrons         : 147\n",
-      "Number of qubits            : 198\n",
-      "Hartree-Fock energy         : -3478.738701637257\n",
-      "Number of unoccupied Molecular orbitals are: 26\n",
-      "Number of occupied Molecular orbitals are: 73\n",
-      "active_space start : 66\n",
-      "active_space stop  : 75\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 1 : 59.62234137498308\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 2 : 56.79980720899766\n",
-      "Number of orbitals          : 98\n",
-      "Number of electrons         : 146\n",
-      "Number of qubits            : 196\n",
-      "Hartree-Fock energy         : -3478.02605465114\n",
-      "Number of unoccupied Molecular orbitals are: 25\n",
-      "Number of occupied Molecular orbitals are: 73\n",
-      "active_space start : 66\n",
-      "active_space stop  : 75\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 2 : 56.82168937503593\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 3 : 54.94790525001008\n",
-      "Number of orbitals          : 97\n",
-      "Number of electrons         : 145\n",
-      "Number of qubits            : 194\n",
-      "Hartree-Fock energy         : -3477.364283370665\n",
-      "Number of unoccupied Molecular orbitals are: 25\n",
-      "Number of occupied Molecular orbitals are: 72\n",
-      "active_space start : 65\n",
-      "active_space stop  : 74\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 3 : 54.969166708004195\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 4 : 55.622391791956034\n",
-      "Number of orbitals          : 97\n",
-      "Number of electrons         : 145\n",
-      "Number of qubits            : 194\n",
-      "Hartree-Fock energy         : -3477.406382054496\n",
-      "Number of unoccupied Molecular orbitals are: 25\n",
-      "Number of occupied Molecular orbitals are: 72\n",
-      "active_space start : 65\n",
-      "active_space stop  : 74\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 4 : 55.64403199998196\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 5 : 54.11503083398566\n",
-      "Number of orbitals          : 97\n",
-      "Number of electrons         : 145\n",
-      "Number of qubits            : 194\n",
-      "Hartree-Fock energy         : -3477.327283895578\n",
-      "Number of unoccupied Molecular orbitals are: 25\n",
-      "Number of occupied Molecular orbitals are: 72\n",
-      "active_space start : 65\n",
-      "active_space stop  : 74\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 5 : 54.136136332992464\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 6 : 66.90098125004442\n",
-      "Number of orbitals          : 104\n",
-      "Number of electrons         : 155\n",
-      "Number of qubits            : 208\n",
-      "Hartree-Fock energy         : -3552.609731071081\n",
-      "Number of unoccupied Molecular orbitals are: 27\n",
-      "Number of occupied Molecular orbitals are: 77\n",
-      "active_space start : 70\n",
-      "active_space stop  : 79\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 6 : 66.92277670901967\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 7 : 51.68452154198894\n",
-      "Number of orbitals          : 94\n",
-      "Number of electrons         : 139\n",
-      "Number of qubits            : 188\n",
-      "Hartree-Fock energy         : -3404.694527534909\n",
-      "Number of unoccupied Molecular orbitals are: 25\n",
-      "Number of occupied Molecular orbitals are: 69\n",
-      "active_space start : 63\n",
-      "active_space stop  : 71\n",
-      "In the Molecular Orbital Basis: we have 16 qubits\n",
-      "In the Molecular Orbital Basis: we have 12 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 4 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 7 : 51.706565667001996\n",
-      "\n",
-      "Time to perform a HF calculation on molecule 8 : 61.47438433399657\n",
-      "Number of orbitals          : 101\n",
-      "Number of electrons         : 149\n",
-      "Number of qubits            : 202\n",
-      "Hartree-Fock energy         : -3479.6077232050234\n",
-      "Number of unoccupied Molecular orbitals are: 27\n",
-      "Number of occupied Molecular orbitals are: 74\n",
-      "active_space start : 67\n",
-      "active_space stop  : 76\n",
-      "In the Molecular Orbital Basis: we have 18 qubits\n",
-      "In the Molecular Orbital Basis: we have 13 qubits occupied\n",
-      "In the Molecular Orbital Basis: we have 5 qubits unoccupied\n",
-      "Time to generate a molecular hamiltonian for molecule 8 : 61.49484970798949\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "def generate_electronic_hamiltonians(coordinates_pathway:list) -> list:\n",
     "    molecular_hamiltonians = []\n",
@@ -453,42 +314,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'num_qubits': 13, 't_count': 0, 'circuit_depth': 1, 'gate_count': 13, 't_depth': 0, 'clifford_count': 13}\n",
-      "5: ────X───\n",
-      "\n",
-      "6: ────X───\n",
-      "\n",
-      "7: ────X───\n",
-      "\n",
-      "8: ────X───\n",
-      "\n",
-      "9: ────X───\n",
-      "\n",
-      "10: ───X───\n",
-      "\n",
-      "11: ───X───\n",
-      "\n",
-      "12: ───X───\n",
-      "\n",
-      "13: ───X───\n",
-      "\n",
-      "14: ───X───\n",
-      "\n",
-      "15: ───X───\n",
-      "\n",
-      "16: ───X───\n",
-      "\n",
-      "17: ───X───\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "def prepare_initial_state(mi: molecular_info) -> cirq.Circuit:\n",
     "    circuit = cirq.Circuit()\n",
@@ -542,142 +370,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Time to generate circuit for GSEE: 0.0001236249809153378 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 0.00017012498574331403 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00043766602175310254 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.8667022231966257e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 2.2082997020334005e-05 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 3.9832957554608583e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.216600114479661e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 8.141703438013792e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00010900001507252455 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 33.39688883302733 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 191.66754699999 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.10163079196354374 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00010099995415657759 seconds\n",
-      "Time to estimate Co2O9H12_step(0): 385.569837292016\n",
-      "Time to generate circuit for GSEE: 4.274997627362609e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 0.00011383299715816975 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00039770803414285183 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.4666002243757248e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 4.582980182021856e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 2.4040986318141222e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.291598891839385e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 8.141604484990239e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 7.954100146889687e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 30.226473957998678 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 196.32578545901924 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.10464495798805729 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 9.004096500575542e-05 seconds\n",
-      "Time to estimate Co2O9H12_step(1): 385.4174027919653\n",
-      "Time to generate circuit for GSEE: 4.458398325368762e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 8.320901542901993e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00022504100343212485 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.6792037058621645e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.5410048440098763e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 3.7165998946875334e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.0875013433396816e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 6.483402103185654e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 8.516700472682714e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 30.743693416996393 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 206.59496729198145 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.12303324998356402 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00011495896615087986 seconds\n",
-      "Time to estimate Co2O9H12_step(2): 397.87495870899875\n",
-      "Time to generate circuit for GSEE: 5.266699008643627e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 9.712501196190715e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0002949159825220704 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.1041993275284767e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.0840164981782436e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 3.3374992199242115e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.7040991224348545e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 7.379200542345643e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 8.50000069476664e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 30.895769333001226 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 200.4840085420292 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.12802375003229827 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00011108297621831298 seconds\n",
-      "Time to estimate Co2O9H12_step(3): 382.8127836250351\n",
-      "Time to generate circuit for GSEE: 4.51250234618783e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 0.00011333299335092306 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.00029216601978987455 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.266703475266695e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.4159747883677483e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 2.354203024879098e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.3583980035036802e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 7.599999662488699e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 9.037501877173781e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 35.75693075003801 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 177.5295288329944 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.1389064170070924 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00010887498501688242 seconds\n",
-      "Time to estimate Co2O9H12_step(4): 360.92024995799875\n",
-      "Time to generate circuit for GSEE: 5.2292016334831715e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 9.529199451208115e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0003993749851360917 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.133297337219119e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.208988346159458e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 2.3374974261969328e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.4041957911103964e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 6.620795466005802e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 8.650001836940646e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 31.192532832967117 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 215.71297658298863 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.21764633303973824 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.0001324170152656734 seconds\n",
-      "Time to estimate Co2O9H12_step(5): 415.6341856250074\n",
-      "Time to generate circuit for GSEE: 7.00420350767672e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 9.320798562839627e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0005000000237487257 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.4541961718350649e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 4.084024112671614e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 3.137503517791629e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.429201802238822e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 8.366699330508709e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 9.070796659216285e-05 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 32.02644895896083 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 196.10679354099557 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.12948616698849946 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00010850001126527786 seconds\n",
-      "Time to estimate Co2O9H12_step(6): 379.2326729579945\n",
-      "Time to generate circuit for GSEE: 4.7707988414913416e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 9.26250359043479e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0003013330278918147 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.3499986380338669e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 3.2919924706220627e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 2.8499984182417393e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 1.550000160932541e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 6.787502206861973e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00010554096661508083 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 18.41857916698791 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 135.1588185839937 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.07777683297172189 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00011062499834224582 seconds\n",
-      "Time to estimate Co2O9H12_step(7): 256.2739529579994\n",
-      "Time to generate circuit for GSEE: 6.0375023167580366e-05 seconds\n",
-      "   Time to decompose high level HPowGate circuit: 9.545800276100636e-05 seconds \n",
-      "   Time to transform decomposed HPowGate circuit to Clifford+T: 0.0003053330001421273 seconds\n",
-      "   Time to decompose high level IdentityGate circuit: 1.695897663012147e-05 seconds \n",
-      "   Time to transform decomposed IdentityGate circuit to Clifford+T: 7.916998583823442e-06 seconds\n",
-      "   Time to decompose high level _PauliX circuit: 4.012504359707236e-05 seconds \n",
-      "   Time to transform decomposed _PauliX circuit to Clifford+T: 2.1459010895341635e-05 seconds\n",
-      "   Time to decompose high level PhaseOffset circuit: 7.766700582578778e-05 seconds \n",
-      "   Time to transform decomposed PhaseOffset circuit to Clifford+T: 0.00010412500705569983 seconds\n",
-      "   Time to decompose high level Trotter_Unitary circuit: 40.498850084026344 seconds \n",
-      "   Time to transform decomposed Trotter_Unitary circuit to Clifford+T: 200.93332266696962 seconds\n",
-      "   Time to decompose high level MeasurementGate circuit: 0.15808679099427536 seconds \n",
-      "   Time to transform decomposed MeasurementGate circuit to Clifford+T: 0.00011716695735231042 seconds\n",
-      "Time to estimate Co2O9H12_step(8): 395.24409108399414\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "trotter_order = 2\n",
     "trotter_steps = 1\n",
@@ -695,7 +390,7 @@
     "for idx, molecular_hamiltonian_info in enumerate(molecular_hamiltonians):\n",
     "    molecular_hamiltonian = molecular_hamiltonian_info.molecular_hamiltonian\n",
     "    molecular_hf_energy = molecular_hamiltonian_info.hf_energy\n",
-    "    \n",
+    "    occupied_orbitals = molecular_hamiltonian_info.occupied_\n",
     "    n_qubits = molecular_hamiltonian.n_qubits\n",
     "    gse_args['mol_ham'] = molecular_hamiltonian\n",
     "    phase_offset = grab_molecular_phase_offset(molecular_hf_energy)\n",
@@ -703,16 +398,19 @@
     "\n",
     "\n",
     "    #TODO: Figure out Phase offset in metadata\n",
-    "    molecular_metadata = GSEEMetaData(\n",
+    "    molecular_metadata = CatalystMetaData(\n",
     "        id = time.time_ns(),\n",
     "        name=f'Co2O9H12_{idx}',\n",
     "        category='scientific',\n",
     "        size=f'{n_qubits} qubits',\n",
-    "        task='Ground State Energy Estimation', \n",
-    "        bits_precision=bits_precision,\n",
+    "        task='Ground State Energy Estimation',\n",
+    "        basis=basis,\n",
     "        evolution_time=ev_time,\n",
+    "        bits_precision=bits_precision,\n",
     "        nsteps=trotter_steps,\n",
     "        trotter_order=trotter_order,\n",
+    "        occupied_orbitals=molecular_hamiltonian.occupied_qubits,\n",
+    "        unoccupied_orbitals=molecular_hamiltonian.unoccupied_orbitals\n",
     "    )\n",
     "\n",
     "    t0 = time.perf_counter()\n",
@@ -724,8 +422,9 @@
     "        precision_order=1,\n",
     "        bits_precision=bits_precision,\n",
     "        phase_offset=phase_offset,\n",
-    "        circuit_name=f'Co2O9H12_{idx}',\n",
     "        metadata=molecular_metadata,\n",
+    "        circuit_name=f'Co2O9H12_{idx}',\n",
+    "        include_nested_resources=True,\n",
     "        write_circuits=True\n",
     "    )\n",
     "    t1 = time.perf_counter()\n",
@@ -745,17 +444,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Total time to run through this notebook: 4212.176184124999\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "t_end = time.perf_counter()\n",
     "print(f'Total time to run through this notebook: {t_end-t_init}')"
@@ -774,7 +465,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qc-apps",
+   "display_name": "qca",
    "language": "python",
    "name": "python3"
   },
@@ -788,7 +479,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.10"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/RuClExample.ipynb b/notebooks/RuClExample.ipynb
index 6c3d254..715a7ea 100644
--- a/notebooks/RuClExample.ipynb
+++ b/notebooks/RuClExample.ipynb
@@ -1045,7 +1045,7 @@
     "        outdir='Trotter/RuCl_circuits/',\n",
     "        metadata=trotter_metadata,\n",
     "        is_extrapolated=extrapolated,\n",
-    "        hamiltonian_name=f'rucl_trotter_{i}',\n",
+    "        hamiltonian_name=f'rucl_trotter_{i}_test',\n",
     "        write_circuits=True\n",
     "    )\n",
     "    t1 = time.perf_counter()\n",
@@ -1147,7 +1147,7 @@
     "        nsteps=nsteps,\n",
     "        energy_precision=energy_precision,\n",
     "        outdir='QSP/RuCl_circuits/',\n",
-    "        hamiltonian_name=f'rucl_qsp_{i}',\n",
+    "        hamiltonian_name=f'rucl_qsp_{i}_test',\n",
     "        metadata=qsp_metadata,\n",
     "        write_circuits=True\n",
     "    )\n",
@@ -1328,7 +1328,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qc-apps",
+   "display_name": "alt",
    "language": "python",
    "name": "python3"
   },
@@ -1342,7 +1342,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.10"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,
diff --git a/scripts/DickeModel.py b/scripts/DickeModel.py
index e9845e3..7bc184e 100644
--- a/scripts/DickeModel.py
+++ b/scripts/DickeModel.py
@@ -30,7 +30,7 @@ def main(args):
 
     #this scales the circuit depth proportional to 2 ^ bits_precision
 
-    #E_min_dicke = -len(ham_dicke.terms) * max(abs(n_s), abs(n_b), abs(omega_c), abs(omega_o), abs(lam))
+    # E_min_dicke = -len(ham_dicke.terms) * max(abs(n_s), abs(n_b), abs(omega_c), abs(omega_o), abs(lam))
     E_max_dicke = 0
 
     #dicke_omega = E_max_dicke-E_min_dicke
diff --git a/scripts/QCD-RE.py b/scripts/QCD-RE.py
index 99304eb..eac9900 100644
--- a/scripts/QCD-RE.py
+++ b/scripts/QCD-RE.py
@@ -97,7 +97,6 @@ def generate_forward_scattering(n_neutrinos: int, site_interactions:float=0):
     scattering_hamiltonian = nx_heisenberg_terms(flat_graph)
     return scattering_hamiltonian
 
-    
 def main():
     args = parse_args()
     n_neutrinos = args.n_neutrinos
diff --git a/src/qca/utils/algo_utils.py b/src/qca/utils/algo_utils.py
index a33539c..9049516 100644
--- a/src/qca/utils/algo_utils.py
+++ b/src/qca/utils/algo_utils.py
@@ -3,8 +3,8 @@
 import random
 import numpy as np
 import networkx as nx
-from dataclasses import asdict
 
+import cirq
 from cirq import Circuit
 from cirq.contrib import qasm_import
 
@@ -21,58 +21,15 @@
 from pyLIQTR.phase_factors.fourier_response.fourier_response import Angler_fourier_response
 
 from qca.utils.utils import (
-    re_as_json,
+    gen_json,
     write_qasm,
-    circuit_estimate,
+    grab_circuit_resources,
     estimate_cpt_resources,
     GSEEMetaData,
     TrotterMetaData,
     QSPMetaData
 )
 
-def estimate_qsp(
-    pyliqtr_hamiltonian: Hamiltonian,
-    evolution_time:float,
-    nsteps:int,
-    energy_precision:float,
-    outdir:str,
-    metadata: QSPMetaData | None=None,
-    hamiltonian_name:str='hamiltonian',
-    write_circuits:bool=False,
-    include_nested_resources:bool=True
-) -> Circuit:
-    timestep_of_interest=evolution_time/nsteps
-    random.seed(0)
-    np.random.seed(0)
-    t0 = time.perf_counter()
-    angles_response = Angler_fourier_response(tau=timestep_of_interest*pyliqtr_hamiltonian.alpha,
-                                              eps=energy_precision,
-                                              random=True,
-                                              silent=True)
-    angles_response.generate()
-    angles = angles_response.phases
-    qsp_circuit = generate_QSP_circuit(pyliqtr_hamiltonian, angles, pyliqtr_hamiltonian.problem_size)
-    t1 = time.perf_counter()
-    elapsed = t1 - t0
-    print(f'Time to generate high level QSP circuit: {elapsed} seconds')
-    outfile = f'{outdir}{hamiltonian_name}_re.json'
-
-    gate_synth_accuracy=metadata.gate_synth_accuracy
-    logical_re = circuit_estimate(
-        circuit=qsp_circuit,
-        outdir=outdir,
-        numsteps=nsteps,
-        algo_name='QSP',
-        gate_synth_accuracy=gate_synth_accuracy,
-        write_circuits=write_circuits,
-        include_nested_resources=include_nested_resources
-    )
-    if metadata:
-        re_metadata = asdict(metadata)
-        logical_re = re_metadata | logical_re
-    re_as_json(logical_re, outfile)
-    return qsp_circuit
-
 def find_hamiltonian_ordering(of_hamiltonian: QubitOperator) -> list:
     """
     Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.
@@ -108,19 +65,63 @@ def find_hamiltonian_ordering(of_hamiltonian: QubitOperator) -> list:
         two_body_terms_ordered.append(new_item)
     return one_body_terms_ordered + two_body_terms_ordered
 
+def estimate_qsp(
+    pyliqtr_hamiltonian: Hamiltonian,
+    evolution_time:float,
+    nsteps:int,
+    energy_precision:float,
+    outdir:str,
+    is_extrapolated:bool=False,
+    metadata: QSPMetaData | None=None,
+    hamiltonian_name:str='hamiltonian',
+    write_circuits:bool=False,
+    include_nested_resources:bool=True
+) -> Circuit:
+    timestep_of_interest=evolution_time/nsteps
+    random.seed(0)
+    np.random.seed(0)
+    t0 = time.perf_counter()
+    angles_response = Angler_fourier_response(tau=timestep_of_interest*pyliqtr_hamiltonian.alpha,
+                                              eps=energy_precision,
+                                              random=True,
+                                              silent=True)
+    angles_response.generate()
+    angles = angles_response.phases
+    qsp_circuit = generate_QSP_circuit(pyliqtr_hamiltonian, angles, pyliqtr_hamiltonian.problem_size)
+    t1 = time.perf_counter()
+    elapsed = t1 - t0
+    print(f'Time to generate high level QSP circuit: {elapsed} seconds')
+
+    if nsteps and not is_extrapolated:
+        is_extrapolated=True
+
+    gate_synth_accuracy=metadata.gate_synth_accuracy
+    grab_circuit_resources(
+        circuit=qsp_circuit,
+        outdir=outdir,
+        algo_name='QSP',
+        fname=hamiltonian_name,
+        is_extrapolated=is_extrapolated,
+        numsteps=nsteps,
+        metadata=metadata,
+        write_circuits=write_circuits,
+        include_nested_resources=include_nested_resources,
+        gate_synth_accuracy=gate_synth_accuracy
+    )
+
+    return qsp_circuit
+
 
 def estimate_trotter(
     openfermion_hamiltonian: QubitOperator,
     evolution_time: float,
     energy_precision: float,
     outdir:str,
+    is_extrapolated: bool=True,
     trotter_order: int = 2,
     metadata: TrotterMetaData | None=None,
-
     hamiltonian_name:str='hamiltonian',
-    is_extrapolated: bool = True,
     write_circuits:bool=False,
-
     nsteps:int|None=None,
     include_nested_resources:bool=True
 ) -> Circuit:
@@ -137,6 +138,7 @@ def estimate_trotter(
         t1 = time.perf_counter()
         elapsed = t1 - t0
         print(f'Time to estimate number of trotter steps required ({nsteps}): {elapsed} seconds')
+
     metadata.nsteps=nsteps
 
     t0 = time.perf_counter()
@@ -145,6 +147,7 @@ def estimate_trotter(
     elapsed = t1 - t0
     print(f'Time to find term ordering: {elapsed} seconds')
     t0 = time.perf_counter()
+
     #generates the circuit for a single trotter step and extrapolates the rest
     trotter_circuit_of = trotterize_exp_qubop_to_qasm(openfermion_hamiltonian,
                                                       trotter_order=trotter_order,
@@ -157,6 +160,7 @@ def estimate_trotter(
     gate_synth_accuracy = metadata.gate_synth_accuracy
     qasm_str_trotter = open_fermion_to_qasm(count_qubits(openfermion_hamiltonian), trotter_circuit_of)
     trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)
+
     t0 = time.perf_counter()
     cpt_trotter = clifford_plus_t_direct_transform(circuit=trotter_circuit_qasm, gate_precision=gate_synth_accuracy)
     t1 = time.perf_counter()
@@ -177,18 +181,14 @@ def estimate_trotter(
 
     logical_re = estimate_cpt_resources(
         cpt_circuit=cpt_trotter,
-        outdir=outdir,
         is_extrapolated=is_extrapolated,
         algo_name= 'TrotterStep',
-        trotter_steps=nsteps,
+        total_steps=nsteps,
         include_nested_resources=include_nested_resources
     )
-
     outfile = f'{outdir}{hamiltonian_name}_re.json'
-    if metadata:
-        re_metadata = asdict(metadata)
-        logical_re = re_metadata | logical_re
-    re_as_json(logical_re, outfile)
+
+    gen_json(logical_re, outfile, metadata )
     return cpt_trotter
 
 def gsee_resource_estimation(
@@ -199,11 +199,12 @@ def gsee_resource_estimation(
         precision_order:int,
         bits_precision:int,
         phase_offset:float,
+        is_extrapolated:bool=False,
         metadata:GSEEMetaData | None =None,
         circuit_name:str='Hamiltonian',
-        include_nested_resources:bool=True,
+        include_nested_resources:bool=False,
         include_classical_bits:bool=False,
-        write_circuits:bool=False
+        write_circuits:bool=False,
 ) -> Circuit:
     t0 = time.perf_counter()
     gse_circuit = PhaseEstimation(
@@ -219,23 +220,23 @@ def gsee_resource_estimation(
 
     gse_circuit.generate_circuit()
     pe_circuit = gse_circuit.pe_circuit
-
     gate_synth_accuracy=metadata.gate_synth_accuracy
 
-    t0 = time.perf_counter()
-    logical_re = circuit_estimate(
+    if (nsteps or bits_precision) and not is_extrapolated:
+        is_extrapolated = True
+
+    grab_circuit_resources(
         circuit=pe_circuit,
         outdir=outdir,
-        numsteps=nsteps,
         algo_name='GSEE',
+        fname=circuit_name,
+        is_extrapolated=is_extrapolated,
+        numsteps=nsteps,
+        bits_precision=bits_precision,
+        metadata=metadata,
+        write_circuits=write_circuits,
         include_nested_resources=include_nested_resources,
-        gate_synth_accuracy=gate_synth_accuracy,
-        bits_precision=bits_precision, 
-        write_circuits=write_circuits
+        gate_synth_accuracy=gate_synth_accuracy
     )
-    outfile = f'{outdir}{circuit_name}_re.json'
-    if metadata:
-        re_metadata = asdict(metadata)
-        logical_re = re_metadata | logical_re
-    re_as_json(logical_re, outfile)
+
     return pe_circuit
\ No newline at end of file
diff --git a/src/qca/utils/chemistry_utils.py b/src/qca/utils/chemistry_utils.py
index c5df3b2..9f23f9a 100644
--- a/src/qca/utils/chemistry_utils.py
+++ b/src/qca/utils/chemistry_utils.py
@@ -11,9 +11,8 @@
 
 from pyLIQTR.PhaseEstimation.pe import PhaseEstimation
 
-from qca.utils.utils import circuit_estimate, EstimateMetaData
+from qca.utils.utils import grab_circuit_resources, CatalystMetaData
 
-import random
 @dataclass
 class molecular_info:
     """Class for keeping track of information for a given state in the molecular orbital basis"""
@@ -186,34 +185,48 @@ def generate_electronic_hamiltonians(
     return molecular_hamiltonians
 
 def gsee_molecular_hamiltonian(
+        outdir: str,
         catalyst_name:str,
         gse_args: dict,
         trotter_steps: int,
         bits_precision: int,
         molecular_hamiltonians: list[molecular_info],
-        value_per_circuit:float=None,
-        repetitions_per_application:int=None
+        value_per_circuit:float|None=None,
+        repetitions_per_application:int|None=None,
+        write_circuits:bool=False,
+        include_nested_resources:bool=False,
+        gate_synth_accuracy: int|float = 10,
     ) -> int:
-    uid = random.randint(0, 1000)
     for idx, molecular_hamiltonian_info in enumerate(molecular_hamiltonians):
+        uid = time.time_ns()
         molecular_hamiltonian = molecular_hamiltonian_info.molecular_hamiltonian
         molecular_hf_energy = molecular_hamiltonian_info.hf_energy
         active_space_frac = molecular_hamiltonian_info.active_space_reduction
         basis = molecular_hamiltonian_info.basis
         gse_args['mol_ham'] = molecular_hamiltonian
+        
         phase_offset = grab_molecular_phase_offset(molecular_hf_energy)
         init_state = molecular_hamiltonian_info.initial_state
-        molecular_metadata = EstimateMetaData(
+
+        ev_time = gse_args['ev_time']
+        trotter_order = gse_args['trot_ord']
+        trotter_steps = gse_args['trot_num']
+
+        molecular_metadata = CatalystMetaData(
             id = uid,
-            name=f'{catalyst_name}_molecule({idx})',
-            category='scientific',
-            size=f'{molecular_hamiltonian.n_qubits}',
-            task='Ground State Energy Estimation',
-            implementations=f'trotterization subprocess, basis={basis}, active_space_reduction={active_space_frac}, bits_precision={bits_precision}',
+            name=f'{catalyst_name}[{idx}]',
+            category='Scientific',
+            size=f'{molecular_hamiltonian.n_qubits} qubits',
+            task='GSEE',
+            gate_synth_accuracy=gate_synth_accuracy,
             value_per_circuit=value_per_circuit,
-            repetitions_per_application=repetitions_per_application
+            repetitions_per_application=repetitions_per_application,
+            basis=basis,
+            evolution_time=ev_time,
+            bits_precision=bits_precision,
+            trotter_order=trotter_order,
+            nsteps=trotter_steps
         )
-        uid += 1
 
         t0 = time.perf_counter()
         gse_inst = PhaseEstimation(
@@ -230,14 +243,17 @@ def gsee_molecular_hamiltonian(
         gse_circuit = gse_inst.pe_circuit
         
         t0 = time.perf_counter()
-        circuit_estimate(
+        grab_circuit_resources(
             circuit=gse_circuit,
-            metadata=molecular_metadata,
-            outdir='GSE/Quantum_Chemistry/',
+            outdir=outdir,
+            algo_name='GSEE',
+            fname=f'{catalyst_name}[{idx}]_active_space{active_space_frac}',
             numsteps=trotter_steps,
-            circuit_name=f'{catalyst_name}_{idx}_active_space{active_space_frac}',
             bits_precision=bits_precision,
-            write_circuits=False
+            metadata=molecular_metadata,
+            write_circuits=write_circuits,
+            include_nested_resources=include_nested_resources,
+            gate_synth_accuracy=gate_synth_accuracy
         )
         t1 = time.perf_counter()
-        print(f'Time to estimate Co2O9H12_step({idx}): {t1-t0}')
+        print(f'Time to estimate state {idx}: {t1-t0}')
diff --git a/src/qca/utils/utils.py b/src/qca/utils/utils.py
index 827720f..7b18906 100644
--- a/src/qca/utils/utils.py
+++ b/src/qca/utils/utils.py
@@ -3,7 +3,7 @@
 import json
 import time
 from statistics import median
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, asdict
 
 import pandas as pd
 
@@ -33,6 +33,13 @@ class GSEEMetaData(EstimateMetaData):
     bits_precision: int
     trotter_order: int
     nsteps: int
+
+@dataclass
+class CatalystMetaData(GSEEMetaData):
+    basis: str
+    occupied_orbitals:int
+    unoccupied_orbitals:int
+
 @dataclass
 class TrotterMetaData(EstimateMetaData):
     evolution_time: float #NOTE: This is JT in the current implementation
@@ -117,17 +124,14 @@ def get_T_depth(cpt_circuit: cirq.AbstractCircuit):
     for moment in cpt_circuit:
         for operator in moment:
             opstr = str(operator)
-            if opstr[0] == 'T':
+            if opstr.startswith('T'):
                 t_depth += 1
                 break
     return t_depth
 
 def gen_resource_estimate(
         cpt_circuit: cirq.AbstractCircuit,
-        is_extrapolated: bool,
-        circ_occurences:int=-1,
-        total_steps:int = -1,
-        bits_precision:int=1
+        circ_occurences:int | None=None,
     ) -> dict:
     '''
     Given some clifford + T circuit and a given filename, we grab the logical resource estimates
@@ -143,7 +147,7 @@ def gen_resource_estimate(
     t_depth = get_T_depth(cpt_circuit)
     clifford_count = gate_count - t_count
     circuit_depth = len(cpt_circuit)
-
+    
     resource_estimate = {
         'num_qubits': num_qubits,
         't_count': t_count,
@@ -153,48 +157,51 @@ def gen_resource_estimate(
         'clifford_count': clifford_count,
     }
 
-    if total_steps > 0 and is_extrapolated:
-        scaling_factor = total_steps
-    elif bits_precision > 0:
-        scaling_factor = pow(2, bits_precision - 1)
-    else:
-        scaling_factor = None
-
-    if scaling_factor:
-        resource_estimate['t_depth'] = resource_estimate['t_depth'] * scaling_factor
-        resource_estimate['t_count'] = resource_estimate['t_count'] * scaling_factor
-        resource_estimate['gate_count'] = resource_estimate['gate_count'] * scaling_factor
-        resource_estimate['circuit_depth'] = resource_estimate['circuit_depth'] * scaling_factor
-        resource_estimate['clifford_count'] = resource_estimate['clifford_count'] * scaling_factor
-
-    if circ_occurences > 0:
+    if circ_occurences:
         resource_estimate['subcircuit_occurences'] = circ_occurences
 
     return resource_estimate
 
+def scale_resource(resource: int, total_steps: int | None=None, bits_precision: float | None = None) -> int:
+    scaling_factor = 0
+    if resource != 0:
+        scaled_steps = 0
+        scaled_bits = 0
+        if total_steps and total_steps > 0:
+            scaled_steps = total_steps
+        if bits_precision and bits_precision > 0:
+            scaled_bits = pow(2, bits_precision - 1)
+        
+        if scaled_steps and scaled_bits:
+            scaling_factor = scaled_steps * scaled_bits
+        elif scaled_steps and not scaled_bits:
+            scaling_factor = scaled_steps
+        elif scaled_bits and not scaled_steps:
+            scaling_factor = scaled_bits
+        if scaling_factor:
+            return int(resource * scaling_factor)
+    return resource
+
 
 def estimate_cpt_resources(
         cpt_circuit: cirq.AbstractCircuit,
-        outdir: str,
-        is_extrapolated:bool,
         algo_name:str,
+        is_extrapolated:bool,
         include_nested_resources:bool,
-        magnus_steps:int=1,
-        trotter_steps:int=1
+        total_steps: int|None=None
     ):
-    if not os.path.exists(outdir):
-        os.makedirs(outdir)
-
-    total_steps = trotter_steps * magnus_steps
     logical_re = {
         'Logical_Abstract':  gen_resource_estimate(
             cpt_circuit=cpt_circuit,
-            is_extrapolated=is_extrapolated,
-            total_steps=total_steps
         )
     }
+    if total_steps and is_extrapolated:
+        highest_scope = logical_re['Logical_Abstract']
+        for key in highest_scope:
+            highest_scope[key] = scale_resource(highest_scope[key], total_steps)
+
     logical_re['Logical_Abstract']['subcircuit_occurences'] = 1
-    if include_nested_resources:
+    if include_nested_resources and total_steps:
         logical_re['Logical_Abstract']['subcircuit_info'] = grab_single_step_estimates(
             len(cpt_circuit.all_qubits()),
             logical_re['Logical_Abstract'],
@@ -237,6 +244,7 @@ def circuit_estimate(
         numsteps: int,
         algo_name: str,
         include_nested_resources:bool,
+        is_extrapolated:bool,
         gate_synth_accuracy: int | float = 10,
         bits_precision:int=1,
         write_circuits:bool = False
@@ -283,14 +291,12 @@ def circuit_estimate(
     total_clifford_count = 0
     subcircuit_re = []
     for gate in subcircuit_counts:
-        occurence = subcircuit_counts[gate][0]
+        subcircuit_occurences = subcircuit_counts[gate][0]
         subcircuit = subcircuit_counts[gate][1]
         subcircuit_name = subcircuit_counts[gate][2]
         resource_estimate = gen_resource_estimate(
             subcircuit,
-            is_extrapolated=False,
-            circ_occurences=occurence,
-            bits_precision=bits_precision
+            circ_occurences=subcircuit_occurences,
         )
         subcircuit_info = {subcircuit_name:resource_estimate}
         subcircuit_re.append(subcircuit_info)
@@ -300,13 +306,20 @@ def circuit_estimate(
         t_depth = resource_estimate['t_depth']
         t_count = resource_estimate['t_count']
         clifford_count = resource_estimate['clifford_count']
-
-        total_gate_count += subcircuit_counts[gate][0] * gate_count * numsteps
-        total_gate_depth += subcircuit_counts[gate][0] * gate_depth * numsteps
-        total_T_depth += subcircuit_counts[gate][0] * t_depth * numsteps
-        total_T_count += subcircuit_counts[gate][0] * t_count * numsteps
-        total_clifford_count += subcircuit_counts[gate][0] * clifford_count * numsteps
-
+        
+        curr_gate_count = subcircuit_occurences * gate_count
+        curr_gate_depth = subcircuit_occurences * gate_depth 
+        curr_t_depth = subcircuit_occurences * t_depth
+        curr_t_count = subcircuit_occurences * t_count
+        curr_clifford_count = subcircuit_occurences * clifford_count
+
+        if (numsteps or bits_precision) and is_extrapolated:
+            total_gate_count += scale_resource(curr_gate_count, numsteps, bits_precision)
+            total_gate_depth += scale_resource(curr_gate_depth, numsteps, bits_precision)
+            total_T_depth += scale_resource(curr_t_depth, numsteps, bits_precision)
+            total_T_count += scale_resource(curr_t_count, numsteps, bits_precision)
+            total_clifford_count += scale_resource(curr_clifford_count, numsteps, bits_precision)
+ 
     main_estimates = {
         'Logical_Abstract': {
             'num_qubits': len(circuit.all_qubits()),
@@ -319,7 +332,7 @@ def circuit_estimate(
             'subcircuit_info': {}
         }
     }
-    if include_nested_resources and subcircuit_re:
+    if include_nested_resources and subcircuit_re and numsteps:
         main_estimates['Logical_Abstract']['subcircuit_info'] = grab_single_step_estimates(
             len(circuit.all_qubits()),
             main_estimates['Logical_Abstract'],
@@ -337,3 +350,35 @@ def re_as_json(main_estimate:dict, outdir:str) -> None:
         json.dump(main_estimate, f,
             indent=4,
             separators=(',', ': '))
+
+def gen_json(main_estimate: dict, outfile:str, metadatata: EstimateMetaData|None=None):
+    if metadatata:
+        re_metadata = asdict(metadatata)
+        main_estimate = re_metadata | main_estimate
+    re_as_json(main_estimate, outfile)
+
+def grab_circuit_resources(circuit: cirq.AbstractCircuit,
+                           outdir: str,
+                           algo_name: str,
+                           fname: str,
+                           is_extrapolated:bool,
+                           numsteps: int|None=None,
+                           bits_precision:int|None=None,
+                           metadata: EstimateMetaData|None=None,
+                           write_circuits:bool=False,
+                           include_nested_resources:bool=False,
+                           gate_synth_accuracy: int | float=10) -> None:
+    estimates = circuit_estimate(
+        circuit=circuit,
+        outdir=outdir,
+        numsteps=numsteps,
+        algo_name=algo_name,
+        is_extrapolated=is_extrapolated,
+        include_nested_resources=include_nested_resources,
+        gate_synth_accuracy=gate_synth_accuracy,
+        bits_precision=bits_precision,
+        write_circuits=write_circuits,
+    )
+    
+    outfile = f'{outdir}{fname}_re.json'
+    gen_json(estimates, outfile, metadata)
\ No newline at end of file

From 03185793831ce4ff2652264d5c1d755dad7b367d Mon Sep 17 00:00:00 2001
From: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 4 Dec 2024 20:58:35 +0000
Subject: [PATCH 3/5] Updated pylint badge

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9f8e7e8..4e6008b 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-![pylint](https://img.shields.io/badge/PyLint-9.24-yellow?logo=python&logoColor=white)
+![pylint](https://img.shields.io/badge/PyLint-9.15-yellow?logo=python&logoColor=white)
 
 # Quantum Computing Application Specifications
 

From 825427c15db14c628765d404f8eb1a1381847612 Mon Sep 17 00:00:00 2001
From: Jonhas Saul Colina <jonhas@lanl.gov>
Date: Thu, 12 Dec 2024 23:32:51 -0700
Subject: [PATCH 4/5] renamed total_steps and numsteps -> nsteps

---
 notebooks/ExoticPhasesExample.ipynb |  8 ++--
 notebooks/MagneticLattices.ipynb    | 26 ++++++-------
 src/qca/utils/algo_utils.py         |  6 +--
 src/qca/utils/chemistry_utils.py    |  2 +-
 src/qca/utils/utils.py              | 58 ++++++++++++++---------------
 5 files changed, 48 insertions(+), 52 deletions(-)

diff --git a/notebooks/ExoticPhasesExample.ipynb b/notebooks/ExoticPhasesExample.ipynb
index 6a1c4f3..18de6ae 100644
--- a/notebooks/ExoticPhasesExample.ipynb
+++ b/notebooks/ExoticPhasesExample.ipynb
@@ -521,7 +521,7 @@
    "source": [
     "energy_precision = 1e-3\n",
     "evolution_time=100\n",
-    "numsteps=68"
+    "nsteps=68"
    ]
   },
   {
@@ -547,7 +547,7 @@
     "    outdir='trotter/triangular_heisenberg/',\n",
     "    hamiltonian_name='triangular_heisenberg',\n",
     "    write_circuits=True,\n",
-    "    nsteps=numsteps\n",
+    "    nsteps=nsteps\n",
     ")"
    ]
   },
@@ -561,7 +561,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "qc-apps",
+   "display_name": "qca",
    "language": "python",
    "name": "python3"
   },
@@ -575,7 +575,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.10"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/MagneticLattices.ipynb b/notebooks/MagneticLattices.ipynb
index 58da227..0d7879b 100644
--- a/notebooks/MagneticLattices.ipynb
+++ b/notebooks/MagneticLattices.ipynb
@@ -180,7 +180,7 @@
    "source": [
     "uid = 1000\n",
     "evolution_time=1000\n",
-    "numsteps=1000\n",
+    "nsteps=1000\n",
     "required_precision = 1e-16\n",
     "\n",
     "#feeding square Hamiltonian to PyLIQTR for circuit generation\n",
@@ -222,7 +222,7 @@
     "    size=f'lattice_size: {square_lattice_size}',\n",
     "    task='Time Dependent Dynamics',\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision\n",
     ")\n",
     "uid += 1\n",
@@ -234,7 +234,7 @@
     "    size=f'lattice_size: {triangle_lattice_size}',\n",
     "    task='Time Dependent Dynamics',\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision\n",
     ")\n",
     "\n",
@@ -247,7 +247,7 @@
     "    size=f'lattice_size: {cubic_lattice_size}',\n",
     "    task='Time Dependent Dynamics',\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision\n",
     ")\n",
     "uid += 1"
@@ -317,7 +317,7 @@
     "qsp_circ_square = estimate_qsp(\n",
     "    pyliqtr_hamiltonian=H_square,\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision,\n",
     "    outdir='QSP/square_circuits/',\n",
     "    is_extrapolated=True,\n",
@@ -331,7 +331,7 @@
     "qsp_circ_triangle = estimate_qsp(\n",
     "    pyliqtr_hamiltonian=H_triangle,\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision,\n",
     "    metadata=triangle_lattice_metadata,\n",
     "    outdir='QSP/triangle_circuits/',\n",
@@ -345,7 +345,7 @@
     "qsp_circ_cube = estimate_qsp(\n",
     "    pyliqtr_hamiltonian=H_cube,\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision,\n",
     "    metadata=cubic_lattice_metadata,\n",
     "    outdir='QSP/cube_circuits/',\n",
@@ -462,7 +462,7 @@
     "kitaev_hamiltonian = generate_kitaev_hamiltonian(lattice_size_kitaev)\n",
     "\n",
     "evolution_time = 1000\n",
-    "numsteps=1000\n",
+    "nsteps=1000\n",
     "required_precision = 1e-16\n",
     "\n",
     "H_kitaev = pyH(kitaev_hamiltonian)\n",
@@ -475,7 +475,7 @@
     "    task='Time Dependent Dynamics',\n",
     "\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision\n",
     ")\n",
     "uid +=1 \n",
@@ -483,7 +483,7 @@
     "qsp_circ_kitaev = estimate_qsp(\n",
     "    pyliqtr_hamiltonian=H_kitaev,\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision,\n",
     "    metadata=kitaev_metadata,\n",
     "    outdir='QSP/kitaev_circuits/',\n",
@@ -569,7 +569,7 @@
     "directional_triangle_hamiltonian = generate_directional_triangular_hamiltonian(lattice_size_directional_triangle)\n",
     "\n",
     "evolution_time = 1000\n",
-    "numsteps = 1000\n",
+    "nsteps = 1000\n",
     "required_precision = 1e-16\n",
     "H_directional_triangle = pyH(directional_triangle_hamiltonian)\n",
     "\n",
@@ -580,7 +580,7 @@
     "    size=f'lattice_size: {lattice_size_directional_triangle}',\n",
     "    task='Time Dependent Dynamics', \n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision\n",
     ")\n",
     "uid += 1\n",
@@ -588,7 +588,7 @@
     "qsp_circ_directional_triangle = estimate_qsp(\n",
     "    pyliqtr_hamiltonian=H_directional_triangle,\n",
     "    evolution_time=evolution_time,\n",
-    "    nsteps=numsteps,\n",
+    "    nsteps=nsteps,\n",
     "    energy_precision=required_precision,\n",
     "    metadata=directional_trangle_metadata,\n",
     "    outdir='QSP/directional_triangle_circuits/',\n",
diff --git a/src/qca/utils/algo_utils.py b/src/qca/utils/algo_utils.py
index 9049516..e5a8111 100644
--- a/src/qca/utils/algo_utils.py
+++ b/src/qca/utils/algo_utils.py
@@ -102,7 +102,7 @@ def estimate_qsp(
         algo_name='QSP',
         fname=hamiltonian_name,
         is_extrapolated=is_extrapolated,
-        numsteps=nsteps,
+        nsteps=nsteps,
         metadata=metadata,
         write_circuits=write_circuits,
         include_nested_resources=include_nested_resources,
@@ -183,7 +183,7 @@ def estimate_trotter(
         cpt_circuit=cpt_trotter,
         is_extrapolated=is_extrapolated,
         algo_name= 'TrotterStep',
-        total_steps=nsteps,
+        nsteps=nsteps,
         include_nested_resources=include_nested_resources
     )
     outfile = f'{outdir}{hamiltonian_name}_re.json'
@@ -231,7 +231,7 @@ def gsee_resource_estimation(
         algo_name='GSEE',
         fname=circuit_name,
         is_extrapolated=is_extrapolated,
-        numsteps=nsteps,
+        nsteps=nsteps,
         bits_precision=bits_precision,
         metadata=metadata,
         write_circuits=write_circuits,
diff --git a/src/qca/utils/chemistry_utils.py b/src/qca/utils/chemistry_utils.py
index 9f23f9a..d1733e1 100644
--- a/src/qca/utils/chemistry_utils.py
+++ b/src/qca/utils/chemistry_utils.py
@@ -248,7 +248,7 @@ def gsee_molecular_hamiltonian(
             outdir=outdir,
             algo_name='GSEE',
             fname=f'{catalyst_name}[{idx}]_active_space{active_space_frac}',
-            numsteps=trotter_steps,
+            nsteps=trotter_steps,
             bits_precision=bits_precision,
             metadata=molecular_metadata,
             write_circuits=write_circuits,
diff --git a/src/qca/utils/utils.py b/src/qca/utils/utils.py
index 7b18906..678c0bc 100644
--- a/src/qca/utils/utils.py
+++ b/src/qca/utils/utils.py
@@ -135,11 +135,7 @@ def gen_resource_estimate(
     ) -> dict:
     '''
     Given some clifford + T circuit and a given filename, we grab the logical resource estimates
-    from the circuit and then write it to disk. The function also returns the resource dictionary
-    if the user needs it.
-
-    total_steps is a flag denoting if the circuit was estimated through trotterization. If so, the
-    user should specify the number of steps required.
+    from the circuit and returns the resource dictionary 
     '''
     num_qubits = len(cpt_circuit.all_qubits())
     gate_count = count_gates(cpt_circuit)
@@ -162,13 +158,13 @@ def gen_resource_estimate(
 
     return resource_estimate
 
-def scale_resource(resource: int, total_steps: int | None=None, bits_precision: float | None = None) -> int:
+def scale_resource(resource: int, nsteps: int | None=None, bits_precision: float | None = None) -> int:
     scaling_factor = 0
     if resource != 0:
         scaled_steps = 0
         scaled_bits = 0
-        if total_steps and total_steps > 0:
-            scaled_steps = total_steps
+        if nsteps and nsteps > 0:
+            scaled_steps = nsteps
         if bits_precision and bits_precision > 0:
             scaled_bits = pow(2, bits_precision - 1)
         
@@ -188,40 +184,40 @@ def estimate_cpt_resources(
         algo_name:str,
         is_extrapolated:bool,
         include_nested_resources:bool,
-        total_steps: int|None=None
+        nsteps: int|None=None
     ):
     logical_re = {
         'Logical_Abstract':  gen_resource_estimate(
             cpt_circuit=cpt_circuit,
         )
     }
-    if total_steps and is_extrapolated:
+    if nsteps and is_extrapolated:
         highest_scope = logical_re['Logical_Abstract']
         for key in highest_scope:
-            highest_scope[key] = scale_resource(highest_scope[key], total_steps)
+            highest_scope[key] = scale_resource(highest_scope[key], nsteps)
 
     logical_re['Logical_Abstract']['subcircuit_occurences'] = 1
-    if include_nested_resources and total_steps:
+    if include_nested_resources and nsteps:
         logical_re['Logical_Abstract']['subcircuit_info'] = grab_single_step_estimates(
             len(cpt_circuit.all_qubits()),
             logical_re['Logical_Abstract'],
             algo_name,
-            total_steps
+            nsteps
         )
     else:
         logical_re['Logical_Abstract']['subcircuit_info'] = {}
     return logical_re
 
-def grab_single_step_estimates(num_qubits: int, main_estimates: dict, algo_name:str, total_steps: int) -> dict:
+def grab_single_step_estimates(num_qubits: int, main_estimates: dict, algo_name:str, nsteps: int) -> dict:
     return {
         f'{algo_name}': {
             'num_qubits': num_qubits,
-            't_count': main_estimates['t_count']//total_steps,
-            'circuit_depth': main_estimates['circuit_depth']//total_steps,
-            'gate_count': main_estimates['gate_count']//total_steps,
-            't_depth': main_estimates['t_depth']//total_steps,
-            'clifford_count': main_estimates['clifford_count']//total_steps,
-            'subcircuit_occurences': total_steps,
+            't_count': main_estimates['t_count']//nsteps,
+            'circuit_depth': main_estimates['circuit_depth']//nsteps,
+            'gate_count': main_estimates['gate_count']//nsteps,
+            't_depth': main_estimates['t_depth']//nsteps,
+            'clifford_count': main_estimates['clifford_count']//nsteps,
+            'subcircuit_occurences': nsteps,
             'subcircuit_info': {}
         }
     }
@@ -241,7 +237,7 @@ def write_qasm(
 def circuit_estimate(
         circuit: cirq.AbstractCircuit,
         outdir: str,
-        numsteps: int,
+        nsteps: int,
         algo_name: str,
         include_nested_resources:bool,
         is_extrapolated:bool,
@@ -313,12 +309,12 @@ def circuit_estimate(
         curr_t_count = subcircuit_occurences * t_count
         curr_clifford_count = subcircuit_occurences * clifford_count
 
-        if (numsteps or bits_precision) and is_extrapolated:
-            total_gate_count += scale_resource(curr_gate_count, numsteps, bits_precision)
-            total_gate_depth += scale_resource(curr_gate_depth, numsteps, bits_precision)
-            total_T_depth += scale_resource(curr_t_depth, numsteps, bits_precision)
-            total_T_count += scale_resource(curr_t_count, numsteps, bits_precision)
-            total_clifford_count += scale_resource(curr_clifford_count, numsteps, bits_precision)
+        if (nsteps or bits_precision) and is_extrapolated:
+            total_gate_count += scale_resource(curr_gate_count, nsteps, bits_precision)
+            total_gate_depth += scale_resource(curr_gate_depth, nsteps, bits_precision)
+            total_T_depth += scale_resource(curr_t_depth, nsteps, bits_precision)
+            total_T_count += scale_resource(curr_t_count, nsteps, bits_precision)
+            total_clifford_count += scale_resource(curr_clifford_count, nsteps, bits_precision)
  
     main_estimates = {
         'Logical_Abstract': {
@@ -332,12 +328,12 @@ def circuit_estimate(
             'subcircuit_info': {}
         }
     }
-    if include_nested_resources and subcircuit_re and numsteps:
+    if include_nested_resources and subcircuit_re and nsteps:
         main_estimates['Logical_Abstract']['subcircuit_info'] = grab_single_step_estimates(
             len(circuit.all_qubits()),
             main_estimates['Logical_Abstract'],
             algo_name,
-            numsteps
+            nsteps
         )
         for op in subcircuit_re:
             for op_key in op.keys():
@@ -362,7 +358,7 @@ def grab_circuit_resources(circuit: cirq.AbstractCircuit,
                            algo_name: str,
                            fname: str,
                            is_extrapolated:bool,
-                           numsteps: int|None=None,
+                           nsteps: int|None=None,
                            bits_precision:int|None=None,
                            metadata: EstimateMetaData|None=None,
                            write_circuits:bool=False,
@@ -371,7 +367,7 @@ def grab_circuit_resources(circuit: cirq.AbstractCircuit,
     estimates = circuit_estimate(
         circuit=circuit,
         outdir=outdir,
-        numsteps=numsteps,
+        nsteps=nsteps,
         algo_name=algo_name,
         is_extrapolated=is_extrapolated,
         include_nested_resources=include_nested_resources,

From 0912af14f45d19ca6ff160ff639c393a7bba3917 Mon Sep 17 00:00:00 2001
From: Jonhas Saul Colina <jonhas@lanl.gov>
Date: Fri, 13 Dec 2024 12:10:32 -0700
Subject: [PATCH 5/5] include some test cases for scale_resources funciton call

---
 tests/utils_test.py | 46 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 43 insertions(+), 3 deletions(-)

diff --git a/tests/utils_test.py b/tests/utils_test.py
index f3dd3c1..fb47509 100644
--- a/tests/utils_test.py
+++ b/tests/utils_test.py
@@ -1,9 +1,22 @@
-import cirq
 import unittest
+from math import pow
+
+import cirq
+
 import numpy as np
-from qca.utils.utils import count_gates, count_T_gates, get_T_depth, get_T_depth_wire, gen_resource_estimate
+
 from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform
 
+from qca.utils.utils import (
+    count_gates,
+    count_T_gates,
+    get_T_depth,
+    get_T_depth_wire,
+    gen_resource_estimate,
+    scale_resource
+)
+
+
 class UtilsTest(unittest.TestCase):
     def test_count_gates(self):
         qubits = [cirq.LineQubit(i) for i in range(4)]
@@ -64,7 +77,7 @@ def test_get_resource_estimate(self):
         circuit.append(layer_rx)
         circuit.append(layer_measurement)
         circ_cpt =  clifford_plus_t_direct_transform(circuit)
-        circ_estimate = gen_resource_estimate(circ_cpt, is_extrapolated=False)
+        circ_estimate = gen_resource_estimate(circ_cpt)
         correct_estimate = {'num_qubits': 4,
                             't_count': 8,
                             't_depth': 2,
@@ -73,5 +86,32 @@ def test_get_resource_estimate(self):
                             'circuit_depth': 5}
         self.assertEqual(circ_estimate, correct_estimate)
 
+    def test_scale_t_count(self):
+        t_count = 100
+        nsteps = 2 
+        bits_precision = 4
+        scaled_t_count = scale_resource(t_count, nsteps, bits_precision)
+        
+        expect = t_count * nsteps * pow(2, bits_precision -1)
+        self.assertEqual(scaled_t_count, expect)
+
+    def scale_toffolis(self):
+        tofolli_count = 30
+        t_count = tofolli_count * 4
+        bits_precision = 10
+        scaled_t_count = scale_resource(resource=t_count, bits_precision=bits_precision)
+        
+        expect = t_count * pow(2, bits_precision-1) 
+        self.assertEqual(scaled_t_count, expect)
+    
+    def verify_nop_scaler(self):
+        t_count = 0
+        nsteps = 2
+        bits_precision = 10
+        scaled_t_count = scale_resource(resource=t_count, bits_precision=bits_precision, nsteps=nsteps)
+
+        expect = 0
+        self.assertEqual(scaled_t_count, expect)
+
 if __name__ == '__main__':
     unittest.main()