From 90d5e82b86cf5a49a372620adb2dcba43af0e86b Mon Sep 17 00:00:00 2001
From: dominicrufa <dominic.rufa@gmail.com>
Date: Fri, 13 Nov 2020 16:23:17 -0500
Subject: [PATCH 1/5] add notebook (not yet well documented) and issues

---
 melange/csmc.py              |    2 +
 melange/notebooks/csmc.ipynb | 2288 ++++++++++++++++++++++++++++++++++
 2 files changed, 2290 insertions(+)
 create mode 100644 melange/notebooks/csmc.ipynb

diff --git a/melange/csmc.py b/melange/csmc.py
index a018bc7..74bd18b 100644
--- a/melange/csmc.py
+++ b/melange/csmc.py
@@ -438,6 +438,8 @@ def ADP(Xs,
             """
             conduct ADP
 
+            ISSUE : there is a discrepancy between the initial value of the loss function (scipy_loss) when computed inside/outside the scipy's minimize function.
+
             WARNING : this function CANNOT be jit'd
             """
             from scipy.optimize import minimize #import the optimizer
diff --git a/melange/notebooks/csmc.ipynb b/melange/notebooks/csmc.ipynb
new file mode 100644
index 0000000..e800574
--- /dev/null
+++ b/melange/notebooks/csmc.ipynb
@@ -0,0 +1,2288 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "cSMC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax.numpy as jnp\n",
+    "from jax import random\n",
+    "from jax import grad, vmap, jit\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from jax.config import config; config.update(\"jax_enable_x64\", True)\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "DEBUG:absl:Initializing backend 'interpreter'\n",
+      "DEBUG:absl:Initializing backend 'cpu'\n",
+      "DEBUG:absl:Initializing backend 'gpu'\n",
+      "DEBUG:absl:Error initializing backend 'gpu': Not found: Could not find registered platform with name: \"cuda\". Available platform names are: Host Interpreter\n",
+      "/home/dominic/anaconda3/envs/openmm/lib/python3.6/site-packages/jax/lib/xla_bridge.py:130: UserWarning: No GPU/TPU found, falling back to CPU.\n",
+      "  warnings.warn('No GPU/TPU found, falling back to CPU.')\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1])).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[2]),).\n",
+      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[2]),).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[], weak_type=True)).\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[])).\n",
+      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[100,2]),).\n",
+      "DEBUG:absl:Compiling _cumulative_reduction for args (ShapedArray(float64[1]),).\n",
+      "DEBUG:absl:Compiling _uniform for args (ShapedArray(uint32[100,2]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[], weak_type=True)).\n",
+      "DEBUG:absl:Compiling _searchsorted for args (ShapedArray(float64[1]), ShapedArray(float64[100])).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _normal for args (ShapedArray(uint32[100,2]),).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _cumulative_reduction for args (ShapedArray(float64[10,100]),).\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "the estimated logZ is -0.3309316707090595; the True logZ is -0.3465\n"
+     ]
+    }
+   ],
+   "source": [
+    "from melange.tests.utils import get_nondefault_potential_initializer, checker_function\n",
+    "from melange.smc import vSIS_lower_bound, SIS, generate_trajs, SIS_logW\n",
+    "import tqdm\n",
+    "from jax.lax import cond\n",
+    "import numpy as np\n",
+    "from melange.csmc import *\n",
+    "\n",
+    "#define some parameters\n",
+    "N,T,Dx = 100, 10, 1\n",
+    "potential, (mu, cov), dG = get_nondefault_potential_initializer(Dx)\n",
+    "cov = cov[0]\n",
+    "dt=1e-2\n",
+    "\n",
+    "#define some _vanilla_ A, b fns\n",
+    "A_fn = lambda x, params: params\n",
+    "b_fn = lambda x, params: params\n",
+    "\n",
+    "#create the csmc container object\n",
+    "smc_obj= StaticULAControlledSMC(N, \n",
+    "                            potential=potential,\n",
+    "                            forward_potential=potential, \n",
+    "                            backward_potential=potential, \n",
+    "                            A_fn = A_fn, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
+    "                            b_fn = b_fn, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
+    "                            A_params_len=1,\n",
+    "                            b_params_len=1,\n",
+    "                            Dx=1,\n",
+    "                            T=T\n",
+    "                           ) #create a controlled smc class\n",
+    "\n",
+    "#create SMC parameters/functions\n",
+    "prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
+    "potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis] #define the potential parameters\n",
+    "\n",
+    "prop_params = {\n",
+    "               'potential_params': potential_params,\n",
+    "               'forward_potential_params': potential_params,\n",
+    "               'backward_potential_params': potential_params[1:],\n",
+    "               'dt': dt\n",
+    "               } #potential parameters dictionary goes here\n",
+    "init_params = {'mus': jnp.array([mu]), \n",
+    "               'covs': jnp.array([cov]),\n",
+    "               'mixture_weights': jnp.array([1.])} #define the initial params\n",
+    "model_params=None #there are no model parameters\n",
+    "y=jnp.arange(T) #the y data aren't important. just know that there are the same number of them as there are data\n",
+    "rs = random.PRNGKey(6) #define a random number \n",
+    "\n",
+    "#create the trajectories\n",
+    "Xs = generate_trajs(prop_params, model_params, y, rs, init_params, init_Xs, prop)\n",
+    "logWs = SIS_logW(Xs, prop_params, model_params, y, init_params, logw, init_logws, aggregate_works=False)\n",
+    "aggregated_logWs = jnp.cumsum(logWs, axis=0)\n",
+    "logZ = logsumexp(aggregated_logWs[-1,:]) - jnp.log(N)\n",
+    "print(f\"the estimated logZ is {logZ}; the True logZ is {dG}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "let's see if we can't get the twisting functions..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['utilities', 'ADP'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "ADP_dict = smc_obj.get_ADP_fn()\n",
+    "print(ADP_dict.keys())\n",
+    "ADP_fn = ADP_dict['ADP']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/9 [00:00<?, ?it/s]Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[1,1]), ShapedArray(float64[1,1]), ShapedArray(float64[1,1])).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "100%|██████████| 9/9 [00:04<00:00,  1.85it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "out_dict = ADP_fn(Xs, logWs, prop_params, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'losses': array([[2.63589304e-01, 1.80213411e-06],\n",
+       "        [1.72694117e+00, 1.47119806e+02],\n",
+       "        [1.75937544e+00, 1.50572245e+02],\n",
+       "        [1.82587472e+00, 1.56879640e+02],\n",
+       "        [1.77235697e+00, 1.52702972e+02],\n",
+       "        [1.74360282e+00, 1.51124501e+02],\n",
+       "        [1.70710334e+00, 1.47776157e+02],\n",
+       "        [1.51841437e+00, 1.30487521e+02],\n",
+       "        [1.17127262e+00, 1.00474560e+02],\n",
+       "        [6.32672756e-01, 5.47277550e+01]]),\n",
+       " 'out_A_params': array([[0.        ],\n",
+       "        [0.01714386],\n",
+       "        [0.01636685],\n",
+       "        [0.0165804 ],\n",
+       "        [0.01635617],\n",
+       "        [0.0160494 ],\n",
+       "        [0.01611148],\n",
+       "        [0.01605162],\n",
+       "        [0.01428961],\n",
+       "        [0.00999279]]),\n",
+       " 'out_b_params': array([[ 0.00000000e+00],\n",
+       "        [ 4.77967698e-04],\n",
+       "        [ 2.81921784e-04],\n",
+       "        [-1.87274466e-04],\n",
+       "        [-8.60159443e-04],\n",
+       "        [ 5.85031529e-05],\n",
+       "        [-6.78506955e-04],\n",
+       "        [-9.85206710e-04],\n",
+       "        [-1.46550472e-03],\n",
+       "        [-5.96509005e-04]]),\n",
+       " 'out_A0': array([0.01707836]),\n",
+       " 'out_b0': array([0.00047673]),\n",
+       " 'loss_trace': [[DeviceArray(54.73520582, dtype=float64),\n",
+       "   DeviceArray(54.73246888, dtype=float64),\n",
+       "   DeviceArray(54.72775501, dtype=float64),\n",
+       "   DeviceArray(54.72775501, dtype=float64)],\n",
+       "  [DeviceArray(100.51752116, dtype=float64),\n",
+       "   DeviceArray(100.50117051, dtype=float64),\n",
+       "   DeviceArray(100.47455996, dtype=float64),\n",
+       "   DeviceArray(100.47455996, dtype=float64)],\n",
+       "  [DeviceArray(130.50454908, dtype=float64),\n",
+       "   DeviceArray(130.49806639, dtype=float64),\n",
+       "   DeviceArray(130.48752097, dtype=float64)],\n",
+       "  [DeviceArray(147.78666381, dtype=float64),\n",
+       "   DeviceArray(147.7828206, dtype=float64),\n",
+       "   DeviceArray(147.77615651, dtype=float64),\n",
+       "   DeviceArray(147.77615651, dtype=float64)],\n",
+       "  [DeviceArray(151.12468516, dtype=float64),\n",
+       "   DeviceArray(151.12461876, dtype=float64),\n",
+       "   DeviceArray(151.12450085, dtype=float64),\n",
+       "   DeviceArray(151.12450085, dtype=float64)],\n",
+       "  [DeviceArray(152.71687149, dtype=float64),\n",
+       "   DeviceArray(152.71185237, dtype=float64),\n",
+       "   DeviceArray(152.70297236, dtype=float64),\n",
+       "   DeviceArray(152.70297236, dtype=float64)],\n",
+       "  [DeviceArray(156.88072878, dtype=float64),\n",
+       "   DeviceArray(156.88033712, dtype=float64),\n",
+       "   DeviceArray(156.87963972, dtype=float64),\n",
+       "   DeviceArray(156.87963972, dtype=float64)],\n",
+       "  [DeviceArray(150.57331098, dtype=float64),\n",
+       "   DeviceArray(150.57292777, dtype=float64),\n",
+       "   DeviceArray(150.57224453, dtype=float64),\n",
+       "   DeviceArray(150.57224453, dtype=float64)],\n",
+       "  [DeviceArray(147.12275986, dtype=float64),\n",
+       "   DeviceArray(147.12165056, dtype=float64),\n",
+       "   DeviceArray(147.11980568, dtype=float64),\n",
+       "   DeviceArray(147.11980568, dtype=float64)]]}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[2.63589304e-01, 1.80213411e-06],\n",
+       "       [1.72694117e+00, 1.47119806e+02],\n",
+       "       [1.75937544e+00, 1.50572245e+02],\n",
+       "       [1.82587472e+00, 1.56879640e+02],\n",
+       "       [1.77235697e+00, 1.52702972e+02],\n",
+       "       [1.74360282e+00, 1.51124501e+02],\n",
+       "       [1.70710334e+00, 1.47776157e+02],\n",
+       "       [1.51841437e+00, 1.30487521e+02],\n",
+       "       [1.17127262e+00, 1.00474560e+02],\n",
+       "       [6.32672756e-01, 5.47277550e+01]])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out_dict['losses']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from melange.csmc import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_uncontrolled_csmc(dim=1):\n",
+    "    \"\"\"\n",
+    "    test a vanilla implementation of uncontrolled sequential monte carlo of a static model with an Euler Maruyama forward/backward kernel.\n",
+    "    the cSMC twisted weights should be the same as the uncontrolled SMC weights\n",
+    "    \"\"\"\n",
+    "    from melange.tests.utils import get_nondefault_potential_initializer, checker_function\n",
+    "    from melange.smc import generate_trajs, SIS_logW\n",
+    "    from melange.smc_objects import StaticULA\n",
+    "    \n",
+    "    N,T,Dx = 10000, 1000, dim #define some smc parameters\n",
+    "    potential, (mu, cov), dG = get_nondefault_potential_initializer(Dx) #get the potential and the starting distribution parameters\n",
+    "    cov = cov[0] #rework the covariance matrix so that it is a vector (squashed diagonal)\n",
+    "    dt=1e-2 #timestep\n",
+    "    \n",
+    "    dummy_A = lambda x, param: jnp.zeros(Dx) #create a dummy A function\n",
+    "    dummy_b = lambda x, param: jnp.zeros(Dx) #create adummy b function\n",
+    "    \n",
+    "    base_smc_obj = StaticULA(N, potential, potential, potential) #define a static ULA object so we can pull the _compute_log_work_function\n",
+    "    base_twisted_logW_fn = base_smc_obj.log_weights_fn() #pull out the log weight function of the uncontrolled SMC\n",
+    "    \n",
+    "    smc_obj= StaticULAControlledSMC(N, \n",
+    "                                potential=potential,\n",
+    "                                forward_potential=potential, \n",
+    "                                backward_potential=potential, \n",
+    "                                A_fn = dummy_A, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
+    "                                b_fn = dummy_b, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
+    "                                A_params_len=1,\n",
+    "                                b_params_len=1,\n",
+    "                                Dx=1,\n",
+    "                                T=T\n",
+    "                               ) #create a controlled smc class\n",
+    "    \n",
+    "    prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
+    "    potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis] #define the potential parameters\n",
+    "    \n",
+    "    prop_params = {\n",
+    "                   'potential_params': potential_params,\n",
+    "                   'forward_potential_params': potential_params,\n",
+    "                   'backward_potential_params': potential_params[1:],\n",
+    "                   'dt': dt\n",
+    "                   } #potential parameters dictionary goes here\n",
+    "\n",
+    "    init_params = {'mus': jnp.array([mu]), \n",
+    "                   'covs': jnp.array([cov]),\n",
+    "                   'mixture_weights': jnp.array([1.])} #define the initial params\n",
+    "    \n",
+    "    model_params=None #there are no model parameters\n",
+    "    y=jnp.arange(T) #the y data aren't important. just know that there are the same number of them as there are data\n",
+    "    rs = random.PRNGKey(5) #define a random number \n",
+    "    \n",
+    "    #generate trajectories and assert that (with sufficiently long annealing), the initial and final distributions are appropriately placed\n",
+    "    Xs = generate_trajs(prop_params, model_params, y, rs, init_params, init_Xs, prop)\n",
+    "    assert np.isclose(Xs[0,:,:].var(), 2., atol=2e-1)\n",
+    "    assert np.isclose(Xs[-1,:,:].var(), 1., atol=1e-1)\n",
+    "    \n",
+    "    #compute weights (there is a problem here because twisting should give me constant offsets that i dont want)\n",
+    "    vtwist_fn = smc_obj.vtwist_fn\n",
+    "    untwisted_logW_fn = smc_obj.log_weights_fn()\n",
+    "    twisted_mus, twisted_covs, logK_Zs, (As, bs) = vtwist_fn(Xs[0], \n",
+    "                                                             smc_obj.forward_potential, \n",
+    "                                                             prop_params['dt'], \n",
+    "                                                             prop_params['forward_potential_params'][0],\n",
+    "                                                             smc_obj.A_fn, \n",
+    "                                                             smc_obj.b_fn,\n",
+    "                                                             smc_obj.A_params_cache[:smc_obj.twisting_iteration],\n",
+    "                                                             smc_obj.b_params_cache[:smc_obj.twisting_iteration],\n",
+    "                                                             True)\n",
+    "    \n",
+    "    # assert all of the logK_Zs are close to zero\n",
+    "    assert np.allclose(logK_Zs, 0.)\n",
+    "    \n",
+    "    # assert all twists are zeros\n",
+    "    assert np.allclose(As.flatten(), 0.)\n",
+    "    assert np.allclose(bs.flatten(), 0.)\n",
+    "    \n",
+    "    #_just_ do the twisting potential and make sure it is zero\n",
+    "    log_psi_ts = smc_obj.vlog_psi_twist(Xs[0], As, bs)\n",
+    "    assert np.allclose(log_psi_ts, 0.)\n",
+    "    \n",
+    "    #compute twisted log weights:\n",
+    "    logWs = SIS_logW(Xs, prop_params, model_params, y, init_params, logw, init_logws)\n",
+    "    assert np.isclose(logsumexp(logWs[-1,:]) - jnp.log(N), )\n",
+    "    \n",
+    "    return Xs, logsumexp(logWs[-1,:]) - jnp.log(N)\n",
+    "    \n",
+    "Xs, logWs = test_null_twist(dim=1)   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray(-0.34411429, dtype=float64)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "logWs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9f3c200208>"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.distplot(Xs[0,:,:])\n",
+    "sns.distplot(Xs[-1,:,:])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "how will we minimize?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy.optimize import minimize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rosen(x):\n",
+    "    \"\"\"The Rosenbrock function\"\"\"\n",
+    "    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)\n",
+    "jit_rosen=jit(rosen)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "848.22"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rosen(x0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "energy_history = []\n",
+    "x_values = []\n",
+    "def callback(x):\n",
+    "    fobj = jit_rosen(x)\n",
+    "    energy_history.append(fobj)\n",
+    "    x_values.append(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "out = minimize(jit_rosen,x0 = x0, method='L-BFGS-B', options={'disp':1}, callback = callback)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['fun', 'hess_inv', 'jac', 'message', 'nfev', 'nit', 'status', 'success', 'x']"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dir(out)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dtype('float64')"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out['x'].dtype"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = jnp.asarray(np.random.randn(3,3))\n",
+    "b = jnp.asarray(np.random.randn(3))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray([[-0.6738118 , -0.71250094, -0.02713342],\n",
+       "             [-0.19548071, -0.69893683,  0.36365833],\n",
+       "             [-0.39087161,  0.04401595, -1.06750039],\n",
+       "             [ 0.09134596,  1.10062331,  1.62327804]], dtype=float64)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jnp.vstack((a,b))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def square(x):\n",
+    "    return (x-1)**2\n",
+    "vsquare = vmap(square)\n",
+    "out_fn = lambda x: vsquare(x).sum()\n",
+    "\n",
+    "out = minimize(out_fn, x0 = np.random.randn(3,3)*100, method='L-BFGS-B', options={'disp':True})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "      fun: DeviceArray(2.69886881e-16, dtype=float64)\n",
+       " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>\n",
+       "      jac: array([ 1.51797942e-09, -2.24263495e-09,  8.80799771e-10, -2.55183650e-09,\n",
+       "       -4.71546471e-10, -3.77173283e-09,  5.62467847e-10,  2.73691290e-10,\n",
+       "       -1.57714653e-09])\n",
+       "  message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+       "     nfev: 60\n",
+       "      nit: 3\n",
+       "   status: 0\n",
+       "  success: True\n",
+       "        x: array([1.        , 0.99999999, 1.        , 0.99999999, 0.99999999,\n",
+       "       0.99999999, 1.        , 1.        , 0.99999999])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.        , 0.99999999, 1.        ],\n",
+       "       [0.99999999, 0.99999999, 0.99999999],\n",
+       "       [1.        , 1.        , 0.99999999]])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out['x'].reshape(3,3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1/1 [00:05<00:00,  5.02s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "doing base SIS\n",
+      "done\n"
+     ]
+    }
+   ],
+   "source": [
+    "smc_obj= StaticULAControlledSMC(N, \n",
+    "                                potential=potential,\n",
+    "                                forward_potential=potential, \n",
+    "                                backward_potential=potential, \n",
+    "                                A_fn = A_twist_fn, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
+    "                                b_fn = b_twist_fn, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
+    "                                A_params_len=1,\n",
+    "                                b_params_len=1,\n",
+    "                                Dx=1\n",
+    "                               )\n",
+    "prop, logw, inits = smc_obj.get_fns()\n",
+    "potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis]\n",
+    "prop_params = {\n",
+    "               'potential_params': potential_params,\n",
+    "               'forward_potential_params': potential_params,\n",
+    "               'backward_potential_params': potential_params[1:],\n",
+    "               'dt': dt\n",
+    "               }\n",
+    "\n",
+    "init_params = {'mus': jnp.array([mu]), \n",
+    "               'covs': jnp.array([cov]),\n",
+    "               'mixture_weights': jnp.array([1.])}\n",
+    "\n",
+    "model_params=None\n",
+    "y=jnp.zeros(T)\n",
+    "rs = random.PRNGKey(10)\n",
+    "jSIS_lower_bound = jit(vSIS_lower_bound, static_argnums=(5,6,7))\n",
+    "jSIS = jit(SIS, static_argnums=(5,6,7)) #SIS(prop_params, model_params, y,  rs, init_params, prop_fn, logW_fn, init_fns)\n",
+    "logZs = []\n",
+    "\n",
+    "for i in tqdm.trange(1):\n",
+    "    rs, run_rs = random.split(rs, 2)\n",
+    "    logZ = vSIS_lower_bound(prop_params, model_params, y, run_rs, init_params, prop, logw, inits)\n",
+    "    logZs.append(logZ)\n",
+    "\n",
+    "print(f\"doing base SIS\")\n",
+    "Xs, untwisted_logWs = jSIS(prop_params, model_params, y, rs, init_params, prop, logw, inits, aggregate_works=False)\n",
+    "print('done')\n",
+    "    \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-0.3465"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dG"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray(-21.059101, dtype=float32)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jnp.array(logZs).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in range(1000):\n",
+    "    plt.plot(Xs[:,i,:])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/dominic/anaconda3/envs/openmm/lib/python3.6/site-packages/seaborn/distributions.py:288: UserWarning: Data must have variance to compute a kernel density estimate.\n",
+      "  warnings.warn(msg, UserWarning)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x7f1d2db79fd0>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.distplot(random.normal(key=random.PRNGKey(0), shape=(10000,))*jnp.sqrt(cov))\n",
+    "sns.distplot(Xs[0,i,:])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ok, so this looks ok"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## for the ADP (lord help me)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "losses, grad_losses, optimize_fn, ADP_fn = smc_obj.get_ADP_fn()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/9 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "iterating backward...\n",
+      "t: 9; initial loss: 90.28929138183594\n",
+      "optimized parameters: {'A_params': DeviceArray([-56.194862], dtype=float32), 'b_params': DeviceArray([-0.14679931], dtype=float32)}\n",
+      "twisting A params: [[  0.      ]\n",
+      " [-56.194862]]\n",
+      "twist b params: [[ 0.        ]\n",
+      " [-0.14679931]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█         | 1/9 [00:01<00:13,  1.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 8; initial loss: 72244168.0\n",
+      "optimized parameters: {'A_params': DeviceArray([-55.792953], dtype=float32), 'b_params': DeviceArray([0.01488524], dtype=float32)}\n",
+      "twisting A params: [[  0.      ]\n",
+      " [-55.792953]]\n",
+      "twist b params: [[0.        ]\n",
+      " [0.01488524]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▏       | 2/9 [00:01<00:08,  1.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 7; initial loss: 73184264.0\n",
+      "optimized parameters: {'A_params': DeviceArray([-62.749123], dtype=float32), 'b_params': DeviceArray([0.07351948], dtype=float32)}\n",
+      "twisting A params: [[  0.      ]\n",
+      " [-62.749123]]\n",
+      "twist b params: [[0.        ]\n",
+      " [0.07351948]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 33%|███▎      | 3/9 [00:02<00:05,  1.07it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 6; initial loss: 73946816.0\n",
+      "optimized parameters: {'A_params': DeviceArray([-68.571884], dtype=float32), 'b_params': DeviceArray([0.12859744], dtype=float32)}\n",
+      "twisting A params: [[  0.      ]\n",
+      " [-68.571884]]\n",
+      "twist b params: [[0.        ]\n",
+      " [0.12859744]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 44%|████▍     | 4/9 [00:02<00:03,  1.38it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 5; initial loss: 74741664.0\n",
+      "optimized parameters: {'A_params': DeviceArray([-74.96388], dtype=float32), 'b_params': DeviceArray([0.06939767], dtype=float32)}\n",
+      "twisting A params: [[  0.     ]\n",
+      " [-74.96388]]\n",
+      "twist b params: [[0.        ]\n",
+      " [0.06939767]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 56%|█████▌    | 5/9 [00:02<00:02,  1.74it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 4; initial loss: 75185112.0\n",
+      "optimized parameters: {'A_params': DeviceArray([-78.34155], dtype=float32), 'b_params': DeviceArray([0.23034683], dtype=float32)}\n",
+      "twisting A params: [[  0.     ]\n",
+      " [-78.34155]]\n",
+      "twist b params: [[0.        ]\n",
+      " [0.23034683]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 67%|██████▋   | 6/9 [00:02<00:01,  2.14it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 3; initial loss: 75328984.0\n",
+      "optimized parameters: {'A_params': DeviceArray([-78.976166], dtype=float32), 'b_params': DeviceArray([0.65710646], dtype=float32)}\n",
+      "twisting A params: [[  0.      ]\n",
+      " [-78.976166]]\n",
+      "twist b params: [[0.        ]\n",
+      " [0.65710646]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 78%|███████▊  | 7/9 [00:03<00:00,  2.50it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 2; initial loss: 75302760.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 89%|████████▉ | 8/9 [00:03<00:00,  2.78it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "optimized parameters: {'A_params': DeviceArray([-78.01529], dtype=float32), 'b_params': DeviceArray([0.8420237], dtype=float32)}\n",
+      "twisting A params: [[  0.     ]\n",
+      " [-78.01529]]\n",
+      "twist b params: [[0.       ]\n",
+      " [0.8420237]]\n",
+      "t: 1; initial loss: 75218032.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 9/9 [00:03<00:00,  2.55it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "optimized parameters: {'A_params': DeviceArray([-76.50562], dtype=float32), 'b_params': DeviceArray([0.9285487], dtype=float32)}\n",
+      "twisting A params: [[  0.     ]\n",
+      " [-76.50562]]\n",
+      "twist b params: [[0.       ]\n",
+      " [0.9285487]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "new_param_dct, losses_arr, init_losses_arr = ADP_fn(Xs, \n",
+    "                                                    random.PRNGKey(42), \n",
+    "                                                    untwisted_logWs, \n",
+    "                                                    prop_params, \n",
+    "                                                    init_params, \n",
+    "                                                    opt_steps=1000,\n",
+    "                                                    learning_rates_0={'A0': 1e-5, 'b0': 1e-5})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "smc_obj.update_twist(new_param_dct)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "let's check the smc object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "[[nan]]\n",
+      "[nan]\n",
+      "[[[  0.      ]\n",
+      "  [-76.50562 ]\n",
+      "  [-78.01529 ]\n",
+      "  [-78.976166]\n",
+      "  [-78.34155 ]\n",
+      "  [-74.96388 ]\n",
+      "  [-68.571884]\n",
+      "  [-62.749123]\n",
+      "  [-55.792953]\n",
+      "  [-56.194862]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]\n",
+      "\n",
+      " [[  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]\n",
+      "  [  0.      ]]]\n",
+      "[[[ 0.        ]\n",
+      "  [ 0.9285487 ]\n",
+      "  [ 0.8420237 ]\n",
+      "  [ 0.65710646]\n",
+      "  [ 0.23034683]\n",
+      "  [ 0.06939767]\n",
+      "  [ 0.12859744]\n",
+      "  [ 0.07351948]\n",
+      "  [ 0.01488524]\n",
+      "  [-0.14679931]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]\n",
+      "\n",
+      " [[ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]\n",
+      "  [ 0.        ]]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(smc_obj.twisting_iteration)\n",
+    "print(smc_obj.A0)\n",
+    "print(smc_obj.b0)\n",
+    "print(smc_obj.A_params_cache)\n",
+    "print(smc_obj.b_params_cache)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ok, can we try to run a twisted iteration?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prop, logw, inits = smc_obj.get_fns()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jSIS_lower_bound = jit(vSIS_lower_bound, static_argnums=(5,6,7))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [00:03<00:00, 27.90it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "doing base SIS\n",
+      "done\n"
+     ]
+    }
+   ],
+   "source": [
+    "rs = random.PRNGKey(34)\n",
+    "twist_logZs = []\n",
+    "for i in tqdm.trange(100):\n",
+    "    rs, run_rs = random.split(rs, 2)\n",
+    "    logZ = jSIS_lower_bound(prop_params, model_params, y, run_rs, init_params, prop, logw, inits)\n",
+    "    twist_logZs.append(logZ)\n",
+    "\n",
+    "print(f\"doing base SIS\")\n",
+    "Xs, twisted_logWs = jSIS(prop_params, model_params, y, rs, init_params, prop, logw, inits, aggregate_works=False)\n",
+    "print('done')\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10, 1000)"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "twisted_logWs.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray(-0.34653977, dtype=float32)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jnp.array(twist_logZs).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'density')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.distplot(logZs, label='uncontrolled SMC')\n",
+    "sns.distplot(twist_logZs, label='controlled SMC (1 twist)')\n",
+    "plt.vlines(dG, 0,800, label='true log evidence')\n",
+    "plt.ylim(0,800)\n",
+    "plt.legend()\n",
+    "plt.xlabel(f\"log evidence\")\n",
+    "plt.ylabel(f\"density\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "losses, grad_losses, optimize_fn, ADP_fn = smc_obj.get_ADP_fn()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/9 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "iterating backward...\n",
+      "t: 9; initial loss: 2.352574586868286\n",
+      "optimized parameters: {'A_params': DeviceArray([0.02777491], dtype=float32), 'b_params': DeviceArray([0.00017573], dtype=float32)}\n",
+      "twisting A params: [[0.02761868]\n",
+      " [0.02777491]]\n",
+      "twist b params: [[-0.00014188]\n",
+      " [ 0.00017573]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█         | 1/9 [00:00<00:02,  3.46it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 8; initial loss: 19.79930877685547\n",
+      "optimized parameters: {'A_params': DeviceArray([0.08117654], dtype=float32), 'b_params': DeviceArray([-0.00045195], dtype=float32)}\n",
+      "twisting A params: [[0.05527914]\n",
+      " [0.08117654]]\n",
+      "twist b params: [[-0.00018345]\n",
+      " [-0.00045195]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▏       | 2/9 [00:00<00:01,  3.67it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 7; initial loss: 76.38909912109375\n",
+      "optimized parameters: {'A_params': DeviceArray([0.1611653], dtype=float32), 'b_params': DeviceArray([-0.00200456], dtype=float32)}\n",
+      "twisting A params: [[0.0828969]\n",
+      " [0.1611653]]\n",
+      "twist b params: [[-4.7316571e-05]\n",
+      " [-2.0045561e-03]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 33%|███▎      | 3/9 [00:00<00:01,  3.78it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 6; initial loss: 210.3072967529297\n",
+      "optimized parameters: {'A_params': DeviceArray([0.2689866], dtype=float32), 'b_params': DeviceArray([-0.00059998], dtype=float32)}\n",
+      "twisting A params: [[0.11011182]\n",
+      " [0.2689866 ]]\n",
+      "twist b params: [[ 0.00012336]\n",
+      " [-0.00059998]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 44%|████▍     | 4/9 [00:01<00:01,  3.84it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 5; initial loss: 468.725830078125\n",
+      "optimized parameters: {'A_params': DeviceArray([0.39778167], dtype=float32), 'b_params': DeviceArray([-0.0009053], dtype=float32)}\n",
+      "twisting A params: [[0.1369963 ]\n",
+      " [0.39778167]]\n",
+      "twist b params: [[ 0.00011628]\n",
+      " [-0.0009053 ]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 56%|█████▌    | 5/9 [00:01<00:01,  3.99it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 4; initial loss: 872.512939453125\n",
+      "optimized parameters: {'A_params': DeviceArray([0.55107117], dtype=float32), 'b_params': DeviceArray([0.00042376], dtype=float32)}\n",
+      "twisting A params: [[0.16334553]\n",
+      " [0.55107117]]\n",
+      "twist b params: [[2.3297016e-05]\n",
+      " [4.2376152e-04]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 67%|██████▋   | 6/9 [00:01<00:00,  4.06it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 3; initial loss: 1513.4588623046875\n",
+      "optimized parameters: {'A_params': DeviceArray([0.7302874], dtype=float32), 'b_params': DeviceArray([0.00440207], dtype=float32)}\n",
+      "twisting A params: [[0.18970983]\n",
+      " [0.7302874 ]]\n",
+      "twist b params: [[0.00049331]\n",
+      " [0.00440207]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 78%|███████▊  | 7/9 [00:01<00:00,  4.04it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 2; initial loss: 2498.88427734375\n",
+      "optimized parameters: {'A_params': DeviceArray([0.92457175], dtype=float32), 'b_params': DeviceArray([0.00066601], dtype=float32)}\n",
+      "twisting A params: [[0.2155855 ]\n",
+      " [0.92457175]]\n",
+      "twist b params: [[0.00104538]\n",
+      " [0.00066601]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 89%|████████▉ | 8/9 [00:01<00:00,  4.13it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t: 1; initial loss: 3782.283935546875\n",
+      "optimized parameters: {'A_params': DeviceArray([1.1399895], dtype=float32), 'b_params': DeviceArray([-0.00361299], dtype=float32)}\n",
+      "twisting A params: [[0.24124295]\n",
+      " [1.1399895 ]]\n",
+      "twist b params: [[ 0.0016072 ]\n",
+      " [-0.00361299]]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 9/9 [00:02<00:00,  4.10it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "new_param_dct, losses_arr, init_losses_arr = ADP_fn(Xs, \n",
+    "                                                    random.PRNGKey(42), \n",
+    "                                                    twisted_logWs, \n",
+    "                                                    prop_params, \n",
+    "                                                    init_params, \n",
+    "                                                    opt_steps=1000,\n",
+    "                                                    learning_rates_0={'A0': 1e-5, 'b0': 1e-5})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray([[4.5078994e+03, 3.9918843e+03, 3.5360549e+03, ...,\n",
+       "              8.0459534e+01, 8.0459534e+01, 8.0459534e+01],\n",
+       "             [3.7822839e+03, 3.3549795e+03, 2.9760068e+03, ...,\n",
+       "              3.0151620e+00, 3.0151620e+00, 3.0151620e+00],\n",
+       "             [2.4988843e+03, 2.2155190e+03, 1.9643240e+03, ...,\n",
+       "              2.2535410e+00, 2.2535410e+00, 2.2535410e+00],\n",
+       "             ...,\n",
+       "             [7.6389099e+01, 6.7769112e+01, 6.0128262e+01, ...,\n",
+       "              4.8120111e-01, 4.8120111e-01, 4.8120111e-01],\n",
+       "             [1.9799309e+01, 1.7551268e+01, 1.5562107e+01, ...,\n",
+       "              2.7208564e-01, 2.7208564e-01, 2.7208564e-01],\n",
+       "             [2.3525746e+00, 2.0999529e+00, 1.8758588e+00, ...,\n",
+       "              1.1430583e-01, 1.1430583e-01, 1.1430583e-01]],            dtype=float32)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "losses_arr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "smc_obj.update_twist(new_param_dct)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'A0': DeviceArray([[1.2154009]], dtype=float32),\n",
+       " 'b0': DeviceArray([0.00343322], dtype=float32),\n",
+       " 'A_params': DeviceArray([[0.        ],\n",
+       "              [1.1399895 ],\n",
+       "              [0.92457175],\n",
+       "              [0.7302874 ],\n",
+       "              [0.55107117],\n",
+       "              [0.39778167],\n",
+       "              [0.2689866 ],\n",
+       "              [0.1611653 ],\n",
+       "              [0.08117654],\n",
+       "              [0.02777491]], dtype=float32),\n",
+       " 'b_params': DeviceArray([[ 0.        ],\n",
+       "              [-0.00361299],\n",
+       "              [ 0.00066601],\n",
+       "              [ 0.00440207],\n",
+       "              [ 0.00042376],\n",
+       "              [-0.0009053 ],\n",
+       "              [-0.00059998],\n",
+       "              [-0.00200456],\n",
+       "              [-0.00045195],\n",
+       "              [ 0.00017573]], dtype=float32)}"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_param_dct"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray(2.3525746, dtype=float32)"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(twisted_logWs[-1]**2).sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ok, can we twist this again?!, but for safety's sake, let's try to do it manually. but first, let's plot the twisted logWs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cum_twist_logWs = jnp.cumsum(twisted_logWs, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in range(1000):\n",
+    "    plt.plot(cum_twist_logWs[:,i])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ok, now let's try to twist these...."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_A_twist_params = smc_obj.A_params_cache[0]\n",
+    "start_b_twist_params = smc_obj.b_params_cache[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "logK_int_twists = jnp.zeros(smc_obj.N)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Vbar_ts = -twisted_logWs[9] - logK_int_twists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 't' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-33-02030d44fefa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mVbar_ts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 't' is not defined"
+     ]
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray(2.3525746, dtype=float32)"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(Vbar_ts**2).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from jax import value_and_grad\n",
+    "def loss_t(params, Xps, Xcs, Vbars):\n",
+    "    As, bs = params\n",
+    "    return ((-smc_obj.vlog_psi_t_twist(Xps, Xcs, smc_obj.base_A_fn, smc_obj.base_b_fn, As, bs) - Vbars)**2).sum()\n",
+    "val_and_grad_loss = jit(value_and_grad(loss_t))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1000/1000 [00:02<00:00, 384.48it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "start_params = (jnp.zeros(1), jnp.zeros(1))\n",
+    "lr=1e-6\n",
+    "import tqdm\n",
+    "losses = []\n",
+    "for epoch in tqdm.trange(1000):\n",
+    "    loss, grads = val_and_grad_loss(start_params, Xs[8], Xs[9], Vbar_ts)\n",
+    "    losses.append(loss)\n",
+    "    As, bs = start_params\n",
+    "    As = As - grads[0]*lr\n",
+    "    bs = bs - grads[1]*lr\n",
+    "    start_params = (As, bs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(DeviceArray([0.02768037], dtype=float32),\n",
+       " DeviceArray([-6.7175526e-05], dtype=float32))"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "start_params"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fd95e32e160>]"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 158,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def new_potential(pos, parameter):\n",
+    "    mod_parameter = parameter[0]\n",
+    "    dim = pos.shape[0]\n",
+    "    x0 = jnp.ones(pos.shape)\n",
+    "    x1 = x0*1.5\n",
+    "    k0, k1 = 0.5 * jnp.diag(jnp.ones(dim)), 4.*jnp.diag(jnp.ones(dim))\n",
+    "    start_pot = 0.5*(1. - mod_parameter) * jnp.dot(jnp.dot(pos, k0), pos)\n",
+    "    end_pot = mod_parameter*((pos**4).sum() - 8*(pos**2).sum())\n",
+    "    return start_pot + end_pot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 159,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vnew_potential = vmap(new_potential, in_axes=(0, None))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 160,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "energies = vnew_potential(supports[..., jnp.newaxis], jnp.array([0.]))\n",
+    "new_energies = vnew_potential(supports[..., jnp.newaxis], jnp.array([1.]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 182,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_gmm_potential(x, parameters):\n",
+    "    xpos = x[0]\n",
+    "    return -1.*jnp.log(0.3*jnp.exp(-0.5*(xpos+2)**2) \n",
+    "                   + 0.4*jnp.exp(-0.2*(xpos+1.)**2)\n",
+    "                   + 0.3*jnp.exp(-0.7*(xpos-4.)**2)\n",
+    "                   + jnp.exp(-1*(xpos-3.)**2)\n",
+    "                  )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 183,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vgmm = vmap(make_gmm_potential, in_axes=(0,None))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 184,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nergies = vgmm(supports[..., jnp.newaxis], jnp.array([0.]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 185,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fac94c63080>]"
+      ]
+     },
+     "execution_count": 185,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(supports, energies)\n",
+    "plt.plot(supports, nergies.flatten())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 241,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray([], dtype=float32)"
+      ]
+     },
+     "execution_count": 241,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jnp.zeros((1,1,1))[:0,5,:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 243,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "blank = jnp.array([])\n",
+    "a = jnp.zeros(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jnp.vstack((blank))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 244,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "Need at least one array to concatenate.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-244-12efcb947f1a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mblank\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/anaconda3/envs/openmm/lib/python3.6/site-packages/jax/numpy/lax_numpy.py\u001b[0m in \u001b[0;36mconcatenate\u001b[0;34m(arrays, axis)\u001b[0m\n\u001b[1;32m   2309\u001b[0m   \u001b[0m_check_arraylike\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"concatenate\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2310\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2311\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Need at least one array to concatenate.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2312\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mndim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2313\u001b[0m     \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Zero-dimensional arrays cannot be concatenated.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: Need at least one array to concatenate."
+     ]
+    }
+   ],
+   "source": [
+    "jnp.concatenate(blank, a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 245,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = jnp.zeros((3,4))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 246,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b = jnp.ones(4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 249,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeviceArray([[0., 0., 0., 0.],\n",
+       "             [0., 0., 0., 0.],\n",
+       "             [0., 0., 0., 0.],\n",
+       "             [1., 1., 1., 1.]], dtype=float32)"
+      ]
+     },
+     "execution_count": 249,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "jnp.vstack((a, b[jnp.newaxis, ...]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = (1,2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 2, 3)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a + (3,)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 102eeec171f6289e951ad2db7fb7c7c6152099c6 Mon Sep 17 00:00:00 2001
From: dominicrufa <dominic.rufa@gmail.com>
Date: Mon, 16 Nov 2020 15:05:51 -0500
Subject: [PATCH 2/5] adding tests for the `log_psi_twist` functions nd
 annotations

---
 melange/csmc.py            | 124 ++++++++++++++++++++++++++++++++-----
 melange/tests/test_csmc.py |  31 ++++++++++
 2 files changed, 141 insertions(+), 14 deletions(-)

diff --git a/melange/csmc.py b/melange/csmc.py
index 74bd18b..ac4c5ef 100644
--- a/melange/csmc.py
+++ b/melange/csmc.py
@@ -201,13 +201,94 @@ def get_twisted_gmm(mix_weights, mus, covs, A, b):
     return full_log_normalizer, log_normalized_twisted_mixtures, (twisted_mus, twisted_covs)
 
 
-"""gaussian twisting potentials"""
-log_psi_twist_A = lambda x, As: -(x*(As.sum(axis=0))).dot(x)
-log_psi_twist_b = lambda x, bs: -x.dot(bs.sum(axis=0))
-log_psi_twist = lambda x, As, bs: log_psi_twist_A(x, As) + log_psi_twist_b(x, bs)
+"""
+gaussian twisting potentials
+
+log_psi_twist_A and log_psi_twist_b are
+"""
+def log_psi_twist_A(x, As):
+    """
+    compute the log twisted potential of the A values
+    arguments
+        x : jnp.array(Dx)
+            position
+        As : jnp.array(Q, Dx)
+            Q covariance twisting matrices
+
+    returns
+        out : float
+            negative square mahalonobis distance
+    """
+    return -(x*(As.sum(axis=0))).dot(x)
+
+def log_psi_twist_b(x, bs):
+    """
+    compute the log twisted potential of the b values
+
+    arguments
+        x : jnp.array(Dx)
+            position
+        bs : jnp.array(Q, Dx)
+            Q mean twisting vector
+
+    returns
+        out : float
+            twisted b potential
+    """
+    return -x.dot(bs.sum(axis=0))
+
+def log_psi_twist(x, As, bs):
+    """
+    compute the full log twist
+
+    arguments
+        x : jnp.array(Dx)
+            position
+        As : jnp.array(Q, Dx)
+            Q mean twisting matrices (diagonal)
+        bs : jnp.array(Q, Dx)
+            Q mean twisting vector
+
+    return
+        out : float
+            full twist
+    """
+    return log_psi_twist_A(x, As) + log_psi_twist_b(x, bs)
+
+"""
+define a vlog_psi_twist to vectorize all of the log_psi_twist inputs
+
+    arguments
+        xs : jnp.array(N, Dx)
+            vectorized positions
+        N_As : jnp.array(N, Q, Dx)
+            vectorized covariance twists
+        N_bs : jnp.array(N, Q, Dx)
+            vectorized twisting vectors
+    return
+        out : jnp.array(N)
+"""
 vlog_psi_twist = vmap(log_psi_twist, in_axes=(0,0,0))
-vlog_psi_twist_mtnr = vmap(log_psi_twist, in_axes=(0,None, None))
 
+#this util is not used directly
+vlog_psi_twist_util = vmap(log_psi_twist, in_axes=(0,None, None))
+
+def vlog_psi_twist_single(xs, A, b):
+    """
+    do a twist on N different positions with a single A and b vector
+
+    arguments
+        xs : jnp.array(N, Dx)
+            vectorized positions
+        A : jnp.array(Dx)
+            vectorized covariance twists
+        b : jnp.array(Dx)
+            vectorized twisting vectors
+    return
+        out : jnp.array(N)
+
+    """
+    return vlog_psi_twist_util(xs, A[jnp.newaxis, ...], b[jnp.newaxis, ...])
 
 #########################################
 #####CSMC Classes########################
@@ -371,7 +452,7 @@ def init_logWs(X, init_params, prop_params):
                                                    self.b0) #compute twisting parameters
 
             # compute twisted weights
-            log_psi0s = log_normalizer - vlog_psi_twist_mtnr(X, self.A0[jnp.newaxis, ...], self.b0[jnp.newaxis, ...])
+            log_psi0s = log_normalizer - vlog_psi_twist_single(X, self.A0, self.b0)
 
             return log_psi0s
         return init_logWs
@@ -422,8 +503,15 @@ def callback(xk):
                 loss_logger.append(val)
             return loss_logger, callback
 
+        #jax wrapper
+        scipy_loss_grad = grad(scipy_loss, argnums=(0,))
+        t0_scipy_loss_grad = grad(t0_scipy_loss, argnums=(0,))
 
-
+        #to numpy wrapper
+        def np_scipy_loss(A_b_params, Xps, Xcs, V_bars): return float(scipy_loss(A_b_params, Xps, Xcs, V_bars))
+        def np_t0_scipy_loss(A0_b0, Xcs, V_bars): return float(t0_scipy_loss(A0_b0, Xcs, V_bars))
+        def np_scipy_loss_grad(A_b_params, Xps, Xcs, V_bars): return np.array(scipy_loss_grad(A_b_params, Xps, Xcs, V_bars), dtype=np.float64)
+        def np_t0_scipy_loss_grad(A0_b0, Xcs, V_bars): return np.array(t0_scipy_loss_grad(A0_b0, Xcs, V_bars), dtype=np.float64)
 
 
         def ADP(Xs,
@@ -461,16 +549,21 @@ def ADP(Xs,
             _logger.debug(f"iterating backward...")
             for t in tqdm.tqdm(jnp.arange(1,T)[::-1]): #do ADP backward
                 Vbar_t = -logWs[t] - logK_int_twist #define the Vbar_ts
-                init_loss = (Vbar_t**2).sum()
-                loss_reporter_container[t,0] = init_loss
+                x0 = jnp.zeros((2, self.A_params_len)).flatten() # TODO : assertion that A, b params have to same size
 
-                x0 = np.zeros((2, self.A_params_len)).flatten() # TODO : assertion that A, b params have to same size
                 # TODO : do we have to flatten an array as first argument to minimizer
                 if verbose:
                     loss_logger, callback_fn = get_callback_fn(Xs[t-1], Xs[t], Vbar_t)
-                out_containter = minimize(scipy_loss,
+                else:
+                    callback_fn=None
+
+                init_loss = np_scipy_loss(x0, Xs[t-1], Xs[t], Vbar_t)
+                loss_reporter_container[t,0] = init_loss
+
+                out_containter = minimize(np_scipy_loss,
                                           x0 = x0, #initial parameters
                                           args = (Xs[t-1], Xs[t], Vbar_t), #other args
+                                          jac = np_scipy_loss_grad,
                                           callback=callback_fn,
                                           **minimizer_params)
                 _logger.debug(f"minimizer message: {out_containter['message']}")
@@ -499,11 +592,12 @@ def ADP(Xs,
             _logger.debug(f"conducting t=0 twist...")
             Vbar0 = -logWs[0] - logK_int_twist #compute the Vbars
             loss_reporter_container[0,0] = (Vbar0**2).sum()
-            x0 = np.zeros((2, self.Dx)).flatten()
+            x0 = jnp.zeros((2, self.Dx)).flatten()
             # TODO : do we have to flatten an array as first argument to minimizer
-            out_containter = minimize(t0_scipy_loss,
+            out_containter = minimize(np_t0_scipy_loss,
                                       x0 = x0,
                                       args = (Xs[0], Vbar0),
+                                      jac = np_t0_scipy_loss_grad,
                                       **minimizer_params)
             assert out_containter['success'], f"iteration 0 failed with message {out_containter['message']}" #TODO : make this fail safe
             reshaped_out_x = out_containter['x'].reshape(2,self.Dx)
@@ -523,7 +617,9 @@ def ADP(Xs,
 
             return output
 
-        return {'utilities': (sum_square_diffs, loss, scipy_loss, t0_scipy_loss), 'ADP': ADP}
+        out_fns = [sum_square_diffs, loss, scipy_loss, t0_scipy_loss, get_callback_fn, scipy_loss_grad, t0_scipy_loss_grad, np_scipy_loss, np_t0_scipy_loss, np_scipy_loss_grad, np_t0_scipy_loss_grad, ADP]
+        output_fn_dict = {fn.__name__: fn for fn in out_fns}
+        return output_fn_dict
 
     def update_cSMC(self, new_A_params, new_b_params, new_A0, new_b0):
         """
diff --git a/melange/tests/test_csmc.py b/melange/tests/test_csmc.py
index 9195243..764671b 100644
--- a/melange/tests/test_csmc.py
+++ b/melange/tests/test_csmc.py
@@ -124,6 +124,37 @@ def test_null_do_param_twist(dim=3, num_twists=5, scale=1e3):
 
         assert np.isclose(log_normalizer, 0.), f"{log_normalizer}"
 
+def test_log_psi_twist(dim=3, num_twists=5):
+    """
+    test the log_psi_twist function
+    """
+    x = np.random.rand(dim)
+    As = np.random.randn(num_twists, dim)
+    bs = np.random.randn(num_twists, dim)
+
+    out = log_psi_twist(x, As, bs)
+    assert type(out) == np.float64
+
+    #manual
+    outs_manual = np.array([np.dot(x*A, x) + np.dot(x,b) for A,b in zip(As, bs)])
+    assert np.isclose(-outs_manual.sum(), out)
+
+def test_vlog_psi_twist_single(num_particles = 10, dim=3):
+    """
+    test the vlog_psi_twist_single function
+    """
+    xs = jnp.array(np.random.rand(num_particles, dim))
+    A = jnp.array(np.random.randn(dim))
+    b = jnp.array(np.random.randn(dim))
+
+    out_twists = vlog_psi_twist_single(xs, A, b)
+
+    #manual
+    manual_outs = np.array([log_psi_twist(x, A[jnp.newaxis, ...], b[jnp.newaxis]) for x in xs])
+
+    #make the assertions of isclose
+    assert np.allclose(out_twists, manual_outs)
+
 def test_uncontrolled_csmc(dim=1):
     """
     test a vanilla implementation of uncontrolled sequential monte carlo of a static model with an Euler Maruyama forward/backward kernel.

From 59ce42f1fb89630912cdaf66669a4917f7f926bb Mon Sep 17 00:00:00 2001
From: dominicrufa <dominic.rufa@gmail.com>
Date: Tue, 17 Nov 2020 11:17:34 -0500
Subject: [PATCH 3/5] update ADP

---
 melange/csmc.py            | 199 ++++++++++++++++++++++++++++---------
 melange/tests/test_csmc.py |   4 +-
 2 files changed, 152 insertions(+), 51 deletions(-)

diff --git a/melange/csmc.py b/melange/csmc.py
index ac4c5ef..d8240aa 100644
--- a/melange/csmc.py
+++ b/melange/csmc.py
@@ -336,8 +336,8 @@ def __init__(self,
         _logger.debug(f"define twisting parameters and parameter caches")
         self.twisting_iteration = 1
         self.max_twists = max_twists
-        self.A_params_cache = jnp.zeros((max_twists, A_params_len))
-        self.b_params_cache = jnp.zeros((max_twists, A_params_len))
+        self.A_params_cache = jnp.zeros((max_twists, T, A_params_len))
+        self.b_params_cache = jnp.zeros((max_twists, T, A_params_len))
         self.A0, self.b0 = jnp.zeros(self.Dx), jnp.zeros(self.Dx)
 
         #assert parameter lengths are the same
@@ -367,8 +367,8 @@ def prop(t, Xp, y, prop_params, model_params, rs):
                                                           prop_params['forward_potential_params'][t],
                                                           self.A_fn,
                                                           self.b_fn,
-                                                          self.A_params_cache[:self.twisting_iteration],
-                                                          self.b_params_cache[:self.twisting_iteration],
+                                                          self.A_params_cache[:self.twisting_iteration,t],
+                                                          self.b_params_cache[:self.twisting_iteration,t],
                                                           False) # twisted_mu, twisted_cov, logZ, (As, bs)
 
 
@@ -405,8 +405,8 @@ def log_weights(t, Xp, Xc, y, prop_params, model_params):
                                                  prop_params['forward_potential_params'][t],
                                                  self.A_fn,
                                                  self.b_fn,
-                                                 self.A_params_cache[:self.twisting_iteration],
-                                                 self.b_params_cache[:self.twisting_iteration],
+                                                 self.A_params_cache[:self.twisting_iteration,t],
+                                                 self.b_params_cache[:self.twisting_iteration,t],
                                                  compute_logK_Z)
 
             #compute twisting functions
@@ -470,12 +470,50 @@ def get_ADP_fn(self):
         def sum_square_diffs(Xcs, As, bs, V_bars):
             """
             compute the sum of square differences between the potential (-vlog_psi_twist) and the precomputed V_bars
+
+            arguments
+                Xcs : jnp.array(N, Dx)
+                    current positions
+                As : jnp.array(N, Dx)
+                    A twists
+                bs : jnp.array(N, Dx)
+                    b twists
+                V_bars : jnp.array(N)
+                    previously-computed potentials
+
+            returns
+                out : float
+                    sum of square differences
+
+            NOTE : vlog_psi_twist takes As, bs of dim (N, Q, Dx), but the As, bs have dim (N, Dx);
+                    since we are summing over Q=1, we have to expand the dimension of the As, bs at axis 1
             """
-            return ((-self.vlog_psi_twist(Xcs, As, bs) - V_bars)**2.).sum()
+            return (
+                    (-self.vlog_psi_twist(Xcs,
+                                          jnp.expand_dims(As, axis=1),
+                                          jnp.expand_dims(bs, axis=1)
+                                          )
+                        - V_bars)**2.).sum()
 
         def loss(Xps, Xcs, A_params, b_params, V_bars):
             """
             the loss function is the sum_square_diffs explicitly parameterized by A_params, b_params
+
+            arguments
+                Xps : jnp.array(N, Dx)
+                    previous positions
+                Xcs : jnp.array(N, Dx)
+                    current positions
+                A_params : jnp.array(Q)
+                    parameters to pass to the A twisting function
+                b_params : jnp.array(Q)
+                    parameters to pass to the b twisting function
+                V_bars : jnp.array(N)
+                    previously-computed potentials
+
+            returns
+                out : float
+                    sum of square differences
             """
             As, bs = self.vA_fn(Xps, A_params), self.vb_fn(Xps, b_params)
             return sum_square_diffs(Xcs, As, bs, V_bars)
@@ -483,6 +521,16 @@ def loss(Xps, Xcs, A_params, b_params, V_bars):
         def scipy_loss(A_b_params, Xps, Xcs, V_bars):
             """
             rewrite the loss function s.t. it is amenable to scipy.optimize.minimize library
+
+            arguments
+                A_b_params : jnp.array(Q + R)
+                    flattened A, b parameter inputs where Q is the dimension of A params and R is dimension of R params
+
+                see above functions for redundant arguments
+
+            returns
+                out : float
+                    loss
             """
             A_params, b_params = A_b_params[:self.A_params_len], A_b_params[self.A_params_len:]
             return loss(Xps, Xcs, A_params, b_params, V_bars)
@@ -491,27 +539,59 @@ def t0_scipy_loss(A0_b0, Xcs, V_bars):
             """
             the scipy loss function for the t=0 twisting iteration is slightly different since we need not compute a tensor of As, bs.
             the twisting A0, b0 arrays are specified _exclusively_ as x-independent and parameter-independent arrays
+
+            arguments
+                A0_b0 : jnp.array(2*Dx)
+                    flattened A0, b0 input parameters
+
+                see above functions for redundant arguments
+
+            returns
+                out : float
+                    loss
             """
             A0, b0 = A0_b0[:self.Dx], A0_b0[self.Dx:]
-            return ((-vlog_psi_twist_mtnr(Xcs, A0[np.newaxis, ...], b0[np.newaxis, ...]) - V_bars)**2).sum()
+            return ((-vlog_psi_twist_single(Xcs, A0, b0) - V_bars)**2).sum()
+
+        def get_callback_fn(Xps, Xcs, V_bars, t0=False):
+            """
+            utility to retrieve a callback function to pass to the scipy.optimize.minimize function for the purpose of logging outputs
+
+            arguments
+                see above functions for redundant arguments
+
+            returns
+                loss_logger : list()
+                    empty list to log the losses
+                callback : fn
+                    callback function that is supposed to be passed to the scipy.optimize.minimize function
 
-        def get_callback_fn(Xps, Xcs, V_bars):
+            """
             loss_logger = []
-            partial_scipy_loss = partial(scipy_loss, Xps=Xps, Xcs=Xcs, V_bars=V_bars)
+            if t0:
+                partial_scipy_loss = partial(t0_scipy_loss, Xcs=Xcs, V_bars=V_bars)
+            else:
+                partial_scipy_loss = partial(scipy_loss, Xps=Xps, Xcs=Xcs, V_bars=V_bars)
+
             def callback(xk):
                 val=partial_scipy_loss(xk)
                 loss_logger.append(val)
             return loss_logger, callback
 
-        #jax wrapper
+        #jax grad wrapper
         scipy_loss_grad = grad(scipy_loss, argnums=(0,))
         t0_scipy_loss_grad = grad(t0_scipy_loss, argnums=(0,))
 
         #to numpy wrapper
-        def np_scipy_loss(A_b_params, Xps, Xcs, V_bars): return float(scipy_loss(A_b_params, Xps, Xcs, V_bars))
-        def np_t0_scipy_loss(A0_b0, Xcs, V_bars): return float(t0_scipy_loss(A0_b0, Xcs, V_bars))
-        def np_scipy_loss_grad(A_b_params, Xps, Xcs, V_bars): return np.array(scipy_loss_grad(A_b_params, Xps, Xcs, V_bars), dtype=np.float64)
-        def np_t0_scipy_loss_grad(A0_b0, Xcs, V_bars): return np.array(t0_scipy_loss_grad(A0_b0, Xcs, V_bars), dtype=np.float64)
+        # def np_scipy_loss(A_b_params, Xps, Xcs, V_bars): return float(scipy_loss(A_b_params, Xps, Xcs, V_bars))
+        # def np_t0_scipy_loss(A0_b0, Xcs, V_bars): return float(t0_scipy_loss(A0_b0, Xcs, V_bars))
+        # def np_scipy_loss_grad(A_b_params, Xps, Xcs, V_bars): return np.array(scipy_loss_grad(A_b_params, Xps, Xcs, V_bars), dtype=np.float64)
+        # def np_t0_scipy_loss_grad(A0_b0, Xcs, V_bars): return np.array(t0_scipy_loss_grad(A0_b0, Xcs, V_bars), dtype=np.float64)
+
+        def np_scipy_loss(*args): return float(scipy_loss(*args))
+        def np_t0_scipy_loss(*args): return float(t0_scipy_loss(*args))
+        def np_scipy_loss_grad(*args): return np.array(scipy_loss_grad(*args), dtype=np.float64)
+        def np_t0_scipy_loss_grad(*args): return np.array(t0_scipy_loss_grad(*args), dtype=np.float64)
 
 
         def ADP(Xs,
@@ -537,45 +617,45 @@ def ADP(Xs,
             assert T == self.T
             assert N == self.N
 
-            out_A_params = np.zeros((T, self.A_params_len))
-            out_b_params = np.zeros((T, self.b_params_len))
-            loss_trace=[]
-
-            #make a reporter array
-            loss_reporter_container = np.zeros((T, 2)) #for each time, we report the initial loss and final loss
+            #initialize arrays as nan
+            out_A_params = np.empty((T, self.A_params_len)); out_A_params[:] = np.nan
+            out_b_params = np.empty((T, self.b_params_len)); out_b_params[:] = np.nan
+            loss_trace=[] #create a loss trace if we are verbose
 
             logK_int_twist = jnp.zeros(N) #initialize the logK_twist_T+1
 
             _logger.debug(f"iterating backward...")
             for t in tqdm.tqdm(jnp.arange(1,T)[::-1]): #do ADP backward
                 Vbar_t = -logWs[t] - logK_int_twist #define the Vbar_ts
-                x0 = jnp.zeros((2, self.A_params_len)).flatten() # TODO : assertion that A, b params have to same size
 
                 # TODO : do we have to flatten an array as first argument to minimizer
+                runner_args = (Xs[t-1], Xs[t], Vbar_t) #other arguments passed to minimizer
                 if verbose:
-                    loss_logger, callback_fn = get_callback_fn(Xs[t-1], Xs[t], Vbar_t)
+                    #generally, the loss loggers do not have consistent number of minimization steps at each iteration
+                    #so it is just an empty list
+                    loss_logger, callback_fn = get_callback_fn(*runner_args)
                 else:
                     callback_fn=None
 
-                init_loss = np_scipy_loss(x0, Xs[t-1], Xs[t], Vbar_t)
-                loss_reporter_container[t,0] = init_loss
-
-                out_containter = minimize(np_scipy_loss,
-                                          x0 = x0, #initial parameters
-                                          args = (Xs[t-1], Xs[t], Vbar_t), #other args
+                out_containter = minimize(np_scipy_loss, #at time t, we use the generic np scipy loss function
+                                          x0 = jnp.zeros((2, self.A_params_len)).flatten(), #initial parameters
+                                          args = runner_args, #other args
                                           jac = np_scipy_loss_grad,
                                           callback=callback_fn,
                                           **minimizer_params)
-                _logger.debug(f"minimizer message: {out_containter['message']}")
+
                 if verbose:
-                    loss_trace.append(loss_logger)
+                    _logger.debug(f"minimizer message: {out_containter['message']}")
+                    loss_trace.append(np.array(loss_logger))
                 assert out_containter['success'], f"iteration {t} failed with message {out_containter['message']}" #TODO : make this fail safe
-                reshaped_out_x = out_containter['x'].reshape(2,self.A_params_len)
+
+                #extract the output parameters
+                reshaped_out_x = out_containter['x'].reshape(2,self.A_params_len) #check to make sure this is reshaped properly
                 new_A_params, new_b_params = reshaped_out_x[0,:], reshaped_out_x[1,:]
-                final_loss = out_containter['fun']
+
+                #record the parameters
                 out_A_params[t,:] = new_A_params
                 out_b_params[t,:] = new_b_params
-                loss_reporter_container[t,1] = final_loss
 
                 #compute the logK twisting integrals for the next optimization step
                 _, _, logK_int_twist, _ = self.vtwist_fn(Xs[t-1],
@@ -584,36 +664,44 @@ def ADP(Xs,
                                                      prop_params['forward_potential_params'][t],
                                                      self.A_fn,
                                                      self.b_fn,
-                                                     jnp.vstack((self.A_params_cache[:self.twisting_iteration], jnp.asarray(new_A_params))),
-                                                     jnp.vstack((self.b_params_cache[:self.twisting_iteration], jnp.asarray(new_b_params))),
+                                                     jnp.vstack((self.A_params_cache[:self.twisting_iteration,t], jnp.asarray(new_A_params))),
+                                                     jnp.vstack((self.b_params_cache[:self.twisting_iteration,t], jnp.asarray(new_b_params))),
                                                      True)
 
             #now to do the 0th time twist
             _logger.debug(f"conducting t=0 twist...")
             Vbar0 = -logWs[0] - logK_int_twist #compute the Vbars
-            loss_reporter_container[0,0] = (Vbar0**2).sum()
-            x0 = jnp.zeros((2, self.Dx)).flatten()
             # TODO : do we have to flatten an array as first argument to minimizer
+
+            runner_args = (None, Xs[0], Vbar0) #other arguments passed to minimizer
+            if verbose:
+                loss_logger, callback_fn = get_callback_fn(*runner_args, t0=True)
+            else:
+                callback_fn=None
+
             out_containter = minimize(np_t0_scipy_loss,
-                                      x0 = x0,
-                                      args = (Xs[0], Vbar0),
+                                      x0 = jnp.zeros((2, self.Dx)).flatten(),
+                                      args = runner_args[1:], #we cannot pass 'None'
                                       jac = np_t0_scipy_loss_grad,
+                                      callback=callback_fn,
                                       **minimizer_params)
+            if verbose:
+                _logger.debug(f"minimizer message: {out_containter['message']}")
+                loss_trace.append(np.array(loss_logger))
             assert out_containter['success'], f"iteration 0 failed with message {out_containter['message']}" #TODO : make this fail safe
             reshaped_out_x = out_containter['x'].reshape(2,self.Dx)
             new_A0, new_b0 = reshaped_out_x[0,:], reshaped_out_x[1,:]
-            final_loss = out_containter['fun']
-            loss_reporter_container[0,1] = final_loss
 
-            _logger.debug(f"finished optimizations")
+            _logger.debug(f"finished optimizations; terminating...")
 
             # package the new parameters
-            output = {'losses': loss_reporter_container,
-                      'out_A_params': out_A_params,
-                      'out_b_params': out_b_params,
+            output = {
+                      'out_A_params': out_A_params[1:],
+                      'out_b_params': out_b_params[1:],
                       'out_A0': new_A0,
                       'out_b0': new_b0,
-                      'loss_trace': loss_trace}
+                      'loss_trace': loss_trace[::-1]
+                      }
 
             return output
 
@@ -621,7 +709,11 @@ def ADP(Xs,
         output_fn_dict = {fn.__name__: fn for fn in out_fns}
         return output_fn_dict
 
-    def update_cSMC(self, new_A_params, new_b_params, new_A0, new_b0):
+    def update_cSMC(self,
+                    new_A_params,
+                    new_b_params,
+                    new_A0,
+                    new_b0):
         """
         update the instance with the new twisting parameters and initial parameters
         """
@@ -632,4 +724,13 @@ def update_cSMC(self, new_A_params, new_b_params, new_A0, new_b0):
         assert new_A0.shape == (self.Dx,)
         assert new_b0.shape == (self.Dx,)
 
-        #
+        #catalogue the parameters
+        catalogue_index = self.twisting_iteration-1
+        _logger.debug(f"cacheing parameters at index {catalogue_index}")
+        self.A_params_cache[catalogue_index] = new_A_params
+        self.b_params_cache[catalogue_index] = new_b_params
+        self.A0 = new_A0
+        self.b0 = new_b0
+
+        #then update the twisting iteration
+        self.twisting_iteration += 1
diff --git a/melange/tests/test_csmc.py b/melange/tests/test_csmc.py
index 764671b..b0d8b82 100644
--- a/melange/tests/test_csmc.py
+++ b/melange/tests/test_csmc.py
@@ -128,7 +128,7 @@ def test_log_psi_twist(dim=3, num_twists=5):
     """
     test the log_psi_twist function
     """
-    x = np.random.rand(dim)
+    x = np.random.randn(dim)
     As = np.random.randn(num_twists, dim)
     bs = np.random.randn(num_twists, dim)
 
@@ -143,7 +143,7 @@ def test_vlog_psi_twist_single(num_particles = 10, dim=3):
     """
     test the vlog_psi_twist_single function
     """
-    xs = jnp.array(np.random.rand(num_particles, dim))
+    xs = jnp.array(np.random.randn(num_particles, dim))
     A = jnp.array(np.random.randn(dim))
     b = jnp.array(np.random.randn(dim))
 

From a9a5700fb11258651d5db42bf4ce3bd52409ba35 Mon Sep 17 00:00:00 2001
From: dominicrufa <dominic.rufa@gmail.com>
Date: Tue, 17 Nov 2020 14:59:42 -0500
Subject: [PATCH 4/5] updating csmc and notebook with twists

---
 melange/csmc.py              |   17 +-
 melange/notebooks/csmc.ipynb | 2158 ++++------------------------------
 2 files changed, 227 insertions(+), 1948 deletions(-)

diff --git a/melange/csmc.py b/melange/csmc.py
index d8240aa..a0baf51 100644
--- a/melange/csmc.py
+++ b/melange/csmc.py
@@ -4,6 +4,7 @@
 from melange.smc_objects import StaticULA
 from melange.gaussians import *
 import jax.numpy as jnp
+from jax import ops
 from functools import partial
 from jax import random
 from jax import grad, vmap, jit
@@ -696,10 +697,10 @@ def ADP(Xs,
 
             # package the new parameters
             output = {
-                      'out_A_params': out_A_params[1:],
-                      'out_b_params': out_b_params[1:],
-                      'out_A0': new_A0,
-                      'out_b0': new_b0,
+                      'out_A_params': jnp.asarray(out_A_params[1:]),
+                      'out_b_params': jnp.asarray(out_b_params[1:]),
+                      'out_A0': jnp.asarray(new_A0),
+                      'out_b0': jnp.asarray(new_b0),
                       'loss_trace': loss_trace[::-1]
                       }
 
@@ -719,16 +720,16 @@ def update_cSMC(self,
         """
         _logger.debug(f"updating cSMC with new parameters")
         #make sure that the input parameters are compatible with those of the class
-        assert new_A_params.shape == (self.T, self.A_params_len)
-        assert new_b_params.shape == (self.T, self.b_params_len)
+        assert new_A_params.shape == (self.T-1, self.A_params_len)
+        assert new_b_params.shape == (self.T-1, self.b_params_len)
         assert new_A0.shape == (self.Dx,)
         assert new_b0.shape == (self.Dx,)
 
         #catalogue the parameters
         catalogue_index = self.twisting_iteration-1
         _logger.debug(f"cacheing parameters at index {catalogue_index}")
-        self.A_params_cache[catalogue_index] = new_A_params
-        self.b_params_cache[catalogue_index] = new_b_params
+        self.A_params_cache = ops.index_update(self.A_params_cache, ops.index[catalogue_index,1:,:], new_A_params)
+        self.b_params_cache = ops.index_update(self.b_params_cache, ops.index[catalogue_index,1:,:], new_b_params)
         self.A0 = new_A0
         self.b0 = new_b0
 
diff --git a/melange/notebooks/csmc.ipynb b/melange/notebooks/csmc.ipynb
index e800574..8c25845 100644
--- a/melange/notebooks/csmc.ipynb
+++ b/melange/notebooks/csmc.ipynb
@@ -24,58 +24,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "DEBUG:absl:Initializing backend 'interpreter'\n",
-      "DEBUG:absl:Initializing backend 'cpu'\n",
-      "DEBUG:absl:Initializing backend 'gpu'\n",
-      "DEBUG:absl:Error initializing backend 'gpu': Not found: Could not find registered platform with name: \"cuda\". Available platform names are: Host Interpreter\n",
-      "/home/dominic/anaconda3/envs/openmm/lib/python3.6/site-packages/jax/lib/xla_bridge.py:130: UserWarning: No GPU/TPU found, falling back to CPU.\n",
-      "  warnings.warn('No GPU/TPU found, falling back to CPU.')\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1])).\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[2]),).\n",
-      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[2]),).\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[], weak_type=True)).\n",
-      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[])).\n",
-      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[100,2]),).\n",
-      "DEBUG:absl:Compiling _cumulative_reduction for args (ShapedArray(float64[1]),).\n",
-      "DEBUG:absl:Compiling _uniform for args (ShapedArray(uint32[100,2]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[], weak_type=True)).\n",
-      "DEBUG:absl:Compiling _searchsorted for args (ShapedArray(float64[1]), ShapedArray(float64[100])).\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "DEBUG:absl:Compiling _normal for args (ShapedArray(uint32[100,2]),).\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "DEBUG:absl:Compiling _cumulative_reduction for args (ShapedArray(float64[10,100]),).\n"
+      "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "the estimated logZ is -0.3309316707090595; the True logZ is -0.3465\n"
+      "the estimated logZ is -0.3494904538572321; the True logZ is -0.3465\n",
+      "now doing statistical sample; nom nom\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "DEBUG:absl:Compiling vSIS_lower_bound for args (ShapedArray(float64[9,1]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[10,1]), ShapedArray(float64[10,1]), ShapedArray(int64[10]), ShapedArray(uint32[2]), ShapedArray(float64[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1,1])).\n",
+      "100%|██████████| 100/100 [00:02<00:00, 33.94it/s]\n"
      ]
     }
    ],
@@ -88,14 +60,14 @@
     "from melange.csmc import *\n",
     "\n",
     "#define some parameters\n",
-    "N,T,Dx = 100, 10, 1\n",
+    "N,T,Dx = 10000, 10, 1\n",
     "potential, (mu, cov), dG = get_nondefault_potential_initializer(Dx)\n",
     "cov = cov[0]\n",
     "dt=1e-2\n",
     "\n",
     "#define some _vanilla_ A, b fns\n",
     "A_fn = lambda x, params: params\n",
-    "b_fn = lambda x, params: params\n",
+    "b_fn = lambda x, params: jnp.zeros(Dx)\n",
     "\n",
     "#create the csmc container object\n",
     "smc_obj= StaticULAControlledSMC(N, \n",
@@ -132,7 +104,49 @@
     "logWs = SIS_logW(Xs, prop_params, model_params, y, init_params, logw, init_logws, aggregate_works=False)\n",
     "aggregated_logWs = jnp.cumsum(logWs, axis=0)\n",
     "logZ = logsumexp(aggregated_logWs[-1,:]) - jnp.log(N)\n",
-    "print(f\"the estimated logZ is {logZ}; the True logZ is {dG}\")\n"
+    "print(f\"the estimated logZ is {logZ}; the True logZ is {dG}\")\n",
+    "\n",
+    "print(f\"now doing statistical sample; nom nom\")\n",
+    "from melange.smc import vSIS_lower_bound\n",
+    "jvSIS = jit(vSIS_lower_bound, static_argnums=(5,6,7))\n",
+    "logZs = []\n",
+    "\n",
+    "for i in tqdm.trange(100):\n",
+    "    rs, run_rs = random.split(rs)\n",
+    "    out_logZ = jvSIS(prop_params, model_params, y,  run_rs, init_params, prop, logw, (init_Xs, init_logws))\n",
+    "    logZs.append(out_logZ)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x7ff405e3e6d8>"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.distplot(logZs)"
    ]
   },
   {
@@ -144,14 +158,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "dict_keys(['utilities', 'ADP'])\n"
+      "dict_keys(['sum_square_diffs', 'loss', 'scipy_loss', 't0_scipy_loss', 'get_callback_fn', 'np_scipy_loss', 'np_t0_scipy_loss', 'np_scipy_loss_grad', 'np_t0_scipy_loss_grad', 'ADP'])\n"
      ]
     }
    ],
@@ -163,7 +177,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
@@ -171,11 +185,7 @@
      "output_type": "stream",
      "text": [
       "  0%|          | 0/9 [00:00<?, ?it/s]Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[1,1]), ShapedArray(float64[1,1]), ShapedArray(float64[1,1])).\n",
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "100%|██████████| 9/9 [00:04<00:00,  1.85it/s]\n"
+      "100%|██████████| 9/9 [00:02<00:00,  4.22it/s]\n"
      ]
     }
    ],
@@ -185,82 +195,45 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'losses': array([[2.63589304e-01, 1.80213411e-06],\n",
-       "        [1.72694117e+00, 1.47119806e+02],\n",
-       "        [1.75937544e+00, 1.50572245e+02],\n",
-       "        [1.82587472e+00, 1.56879640e+02],\n",
-       "        [1.77235697e+00, 1.52702972e+02],\n",
-       "        [1.74360282e+00, 1.51124501e+02],\n",
-       "        [1.70710334e+00, 1.47776157e+02],\n",
-       "        [1.51841437e+00, 1.30487521e+02],\n",
-       "        [1.17127262e+00, 1.00474560e+02],\n",
-       "        [6.32672756e-01, 5.47277550e+01]]),\n",
-       " 'out_A_params': array([[0.        ],\n",
-       "        [0.01714386],\n",
-       "        [0.01636685],\n",
-       "        [0.0165804 ],\n",
-       "        [0.01635617],\n",
-       "        [0.0160494 ],\n",
-       "        [0.01611148],\n",
-       "        [0.01605162],\n",
-       "        [0.01428961],\n",
-       "        [0.00999279]]),\n",
-       " 'out_b_params': array([[ 0.00000000e+00],\n",
-       "        [ 4.77967698e-04],\n",
-       "        [ 2.81921784e-04],\n",
-       "        [-1.87274466e-04],\n",
-       "        [-8.60159443e-04],\n",
-       "        [ 5.85031529e-05],\n",
-       "        [-6.78506955e-04],\n",
-       "        [-9.85206710e-04],\n",
-       "        [-1.46550472e-03],\n",
-       "        [-5.96509005e-04]]),\n",
-       " 'out_A0': array([0.01707836]),\n",
-       " 'out_b0': array([0.00047673]),\n",
-       " 'loss_trace': [[DeviceArray(54.73520582, dtype=float64),\n",
-       "   DeviceArray(54.73246888, dtype=float64),\n",
-       "   DeviceArray(54.72775501, dtype=float64),\n",
-       "   DeviceArray(54.72775501, dtype=float64)],\n",
-       "  [DeviceArray(100.51752116, dtype=float64),\n",
-       "   DeviceArray(100.50117051, dtype=float64),\n",
-       "   DeviceArray(100.47455996, dtype=float64),\n",
-       "   DeviceArray(100.47455996, dtype=float64)],\n",
-       "  [DeviceArray(130.50454908, dtype=float64),\n",
-       "   DeviceArray(130.49806639, dtype=float64),\n",
-       "   DeviceArray(130.48752097, dtype=float64)],\n",
-       "  [DeviceArray(147.78666381, dtype=float64),\n",
-       "   DeviceArray(147.7828206, dtype=float64),\n",
-       "   DeviceArray(147.77615651, dtype=float64),\n",
-       "   DeviceArray(147.77615651, dtype=float64)],\n",
-       "  [DeviceArray(151.12468516, dtype=float64),\n",
-       "   DeviceArray(151.12461876, dtype=float64),\n",
-       "   DeviceArray(151.12450085, dtype=float64),\n",
-       "   DeviceArray(151.12450085, dtype=float64)],\n",
-       "  [DeviceArray(152.71687149, dtype=float64),\n",
-       "   DeviceArray(152.71185237, dtype=float64),\n",
-       "   DeviceArray(152.70297236, dtype=float64),\n",
-       "   DeviceArray(152.70297236, dtype=float64)],\n",
-       "  [DeviceArray(156.88072878, dtype=float64),\n",
-       "   DeviceArray(156.88033712, dtype=float64),\n",
-       "   DeviceArray(156.87963972, dtype=float64),\n",
-       "   DeviceArray(156.87963972, dtype=float64)],\n",
-       "  [DeviceArray(150.57331098, dtype=float64),\n",
-       "   DeviceArray(150.57292777, dtype=float64),\n",
-       "   DeviceArray(150.57224453, dtype=float64),\n",
-       "   DeviceArray(150.57224453, dtype=float64)],\n",
-       "  [DeviceArray(147.12275986, dtype=float64),\n",
-       "   DeviceArray(147.12165056, dtype=float64),\n",
-       "   DeviceArray(147.11980568, dtype=float64),\n",
-       "   DeviceArray(147.11980568, dtype=float64)]]}"
+       "{'out_A_params': DeviceArray([[0.2411808 ],\n",
+       "              [0.21533811],\n",
+       "              [0.18930966],\n",
+       "              [0.16301932],\n",
+       "              [0.13656297],\n",
+       "              [0.10978213],\n",
+       "              [0.08282571],\n",
+       "              [0.0554628 ],\n",
+       "              [0.02790665]], dtype=float64),\n",
+       " 'out_b_params': DeviceArray([[0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.]], dtype=float64),\n",
+       " 'out_A0': DeviceArray([0.23910038], dtype=float64),\n",
+       " 'out_b0': DeviceArray([1.96265843e-05], dtype=float64),\n",
+       " 'loss_trace': [array([0.0954322 , 0.07760967, 0.03809855]),\n",
+       "  array([0.6508939]),\n",
+       "  array([0.64992903]),\n",
+       "  array([0.62721856]),\n",
+       "  array([0.62440323]),\n",
+       "  array([0.59485347]),\n",
+       "  array([0.55998865]),\n",
+       "  array([0.5919984]),\n",
+       "  array([0.55580362]),\n",
+       "  array([0.5492683])]}"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 40,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -270,175 +243,90 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 6,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[2.63589304e-01, 1.80213411e-06],\n",
-       "       [1.72694117e+00, 1.47119806e+02],\n",
-       "       [1.75937544e+00, 1.50572245e+02],\n",
-       "       [1.82587472e+00, 1.56879640e+02],\n",
-       "       [1.77235697e+00, 1.52702972e+02],\n",
-       "       [1.74360282e+00, 1.51124501e+02],\n",
-       "       [1.70710334e+00, 1.47776157e+02],\n",
-       "       [1.51841437e+00, 1.30487521e+02],\n",
-       "       [1.17127262e+00, 1.00474560e+02],\n",
-       "       [6.32672756e-01, 5.47277550e+01]])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "out_dict['losses']"
+    "alright, can we update the twisting iteration?"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from melange.csmc import *"
+    "smc_obj.update_cSMC(out_dict['out_A_params'], out_dict['out_b_params'], out_dict['out_A0'], out_dict['out_b0'])"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 26,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "def test_uncontrolled_csmc(dim=1):\n",
-    "    \"\"\"\n",
-    "    test a vanilla implementation of uncontrolled sequential monte carlo of a static model with an Euler Maruyama forward/backward kernel.\n",
-    "    the cSMC twisted weights should be the same as the uncontrolled SMC weights\n",
-    "    \"\"\"\n",
-    "    from melange.tests.utils import get_nondefault_potential_initializer, checker_function\n",
-    "    from melange.smc import generate_trajs, SIS_logW\n",
-    "    from melange.smc_objects import StaticULA\n",
-    "    \n",
-    "    N,T,Dx = 10000, 1000, dim #define some smc parameters\n",
-    "    potential, (mu, cov), dG = get_nondefault_potential_initializer(Dx) #get the potential and the starting distribution parameters\n",
-    "    cov = cov[0] #rework the covariance matrix so that it is a vector (squashed diagonal)\n",
-    "    dt=1e-2 #timestep\n",
-    "    \n",
-    "    dummy_A = lambda x, param: jnp.zeros(Dx) #create a dummy A function\n",
-    "    dummy_b = lambda x, param: jnp.zeros(Dx) #create adummy b function\n",
-    "    \n",
-    "    base_smc_obj = StaticULA(N, potential, potential, potential) #define a static ULA object so we can pull the _compute_log_work_function\n",
-    "    base_twisted_logW_fn = base_smc_obj.log_weights_fn() #pull out the log weight function of the uncontrolled SMC\n",
-    "    \n",
-    "    smc_obj= StaticULAControlledSMC(N, \n",
-    "                                potential=potential,\n",
-    "                                forward_potential=potential, \n",
-    "                                backward_potential=potential, \n",
-    "                                A_fn = dummy_A, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
-    "                                b_fn = dummy_b, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
-    "                                A_params_len=1,\n",
-    "                                b_params_len=1,\n",
-    "                                Dx=1,\n",
-    "                                T=T\n",
-    "                               ) #create a controlled smc class\n",
-    "    \n",
-    "    prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
-    "    potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis] #define the potential parameters\n",
-    "    \n",
-    "    prop_params = {\n",
-    "                   'potential_params': potential_params,\n",
-    "                   'forward_potential_params': potential_params,\n",
-    "                   'backward_potential_params': potential_params[1:],\n",
-    "                   'dt': dt\n",
-    "                   } #potential parameters dictionary goes here\n",
-    "\n",
-    "    init_params = {'mus': jnp.array([mu]), \n",
-    "                   'covs': jnp.array([cov]),\n",
-    "                   'mixture_weights': jnp.array([1.])} #define the initial params\n",
-    "    \n",
-    "    model_params=None #there are no model parameters\n",
-    "    y=jnp.arange(T) #the y data aren't important. just know that there are the same number of them as there are data\n",
-    "    rs = random.PRNGKey(5) #define a random number \n",
-    "    \n",
-    "    #generate trajectories and assert that (with sufficiently long annealing), the initial and final distributions are appropriately placed\n",
-    "    Xs = generate_trajs(prop_params, model_params, y, rs, init_params, init_Xs, prop)\n",
-    "    assert np.isclose(Xs[0,:,:].var(), 2., atol=2e-1)\n",
-    "    assert np.isclose(Xs[-1,:,:].var(), 1., atol=1e-1)\n",
-    "    \n",
-    "    #compute weights (there is a problem here because twisting should give me constant offsets that i dont want)\n",
-    "    vtwist_fn = smc_obj.vtwist_fn\n",
-    "    untwisted_logW_fn = smc_obj.log_weights_fn()\n",
-    "    twisted_mus, twisted_covs, logK_Zs, (As, bs) = vtwist_fn(Xs[0], \n",
-    "                                                             smc_obj.forward_potential, \n",
-    "                                                             prop_params['dt'], \n",
-    "                                                             prop_params['forward_potential_params'][0],\n",
-    "                                                             smc_obj.A_fn, \n",
-    "                                                             smc_obj.b_fn,\n",
-    "                                                             smc_obj.A_params_cache[:smc_obj.twisting_iteration],\n",
-    "                                                             smc_obj.b_params_cache[:smc_obj.twisting_iteration],\n",
-    "                                                             True)\n",
-    "    \n",
-    "    # assert all of the logK_Zs are close to zero\n",
-    "    assert np.allclose(logK_Zs, 0.)\n",
-    "    \n",
-    "    # assert all twists are zeros\n",
-    "    assert np.allclose(As.flatten(), 0.)\n",
-    "    assert np.allclose(bs.flatten(), 0.)\n",
-    "    \n",
-    "    #_just_ do the twisting potential and make sure it is zero\n",
-    "    log_psi_ts = smc_obj.vlog_psi_twist(Xs[0], As, bs)\n",
-    "    assert np.allclose(log_psi_ts, 0.)\n",
-    "    \n",
-    "    #compute twisted log weights:\n",
-    "    logWs = SIS_logW(Xs, prop_params, model_params, y, init_params, logw, init_logws)\n",
-    "    assert np.isclose(logsumexp(logWs[-1,:]) - jnp.log(N), )\n",
-    "    \n",
-    "    return Xs, logsumexp(logWs[-1,:]) - jnp.log(N)\n",
-    "    \n",
-    "Xs, logWs = test_null_twist(dim=1)   "
+    "well that worked. now we have to see if we can run smc again (twisted) and try to observe an improvement"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "DeviceArray(-0.34411429, dtype=float64)"
+       "2"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 42,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "logWs"
+    "smc_obj.twisting_iteration"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/100 [00:00<?, ?it/s]DEBUG:absl:Compiling vSIS_lower_bound for args (ShapedArray(float64[9,1]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[10,1]), ShapedArray(float64[10,1]), ShapedArray(int64[10]), ShapedArray(uint32[2]), ShapedArray(float64[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1,1])).\n",
+      "100%|██████████| 100/100 [00:03<00:00, 32.27it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
+    "twist1_logZs = []\n",
+    "\n",
+    "for i in tqdm.trange(100):\n",
+    "    rs, run_rs = random.split(rs)\n",
+    "    out_logZ = jvSIS(prop_params, model_params, y,  run_rs, init_params, prop, logw, (init_Xs, init_logws))\n",
+    "    twist1_logZs.append(out_logZ)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9f3c200208>"
+       "<matplotlib.legend.Legend at 0x7ff3d988a048>"
       ]
      },
-     "execution_count": 37,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEKCAYAAAD+XoUoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de3xU9Z3/8ddnJldygQDhIqBERFEgRC6KVZAWrXS1iv3J1qpVapW12l9r+9OWrlsvXe1Dd61rtw+p1W2VurbWu6jdtoBlC1q1KBcRUECoBEIIhFsg15nv7485GUKYTEJykjMk7+fjkcfMnPM9Z87JmXzync/5ns8x5xwiItIzhILeABER6ToK+iIiPYiCvohID6KgLyLSgyjoi4j0IAr6IiI9SKtB38x+ZWY7zWxNk2l9zWyhmW3wHguazPuBmW00s4/M7KIm0yeY2QfevP80M/N/d0REJJm29PSfBGY0mzYXWOycGwks9l5jZmcAVwKjvWXmmVnYW+bnwBxgpPfTfJ0iItLJWg36zrm/AJXNJl8GzPeezwdmNpn+jHOu1jm3GdgInGVmg4F859xfXexqsF83WUZERLpIWjuXG+icKwNwzpWZ2QBv+hDg7SbtSr1p9d7z5tMTMrM5xL4VkJOTM2HUqFHt3EyRAFTvhT2bIW8QhNP56O87GNIrQm6vTCjUZ1k6X//+/fnjH//4R+fcURmV9gb9liTK07sk0xNyzj0GPAYwceJEt3z5cn+2TqQrrHkRnv8anP9NyBvEtH96gHsm7OH8cUVwy9utLy/iAzPrn2h6e0fvlHspG7zHnd70UmBYk3ZDge3e9KEJpot0Py4ae2wyViHadLpIgNob9BcA13nPrwNeaTL9SjPLNLMiYids3/VSQQfMbLI3aufaJsuIdC/xIoZ25CQFfUkBraZ3zOy3wDSgv5mVAncB9wPPmtnXgU+BWQDOuQ/N7FlgLdAA3OKci3ir+gaxkUDZwP94PyLdT6KevgPifwoiwWk16DvnvtLCrOkttL8PuC/B9OXAmGPaOpHjUbxH3zS9Y/Hp9fX1lJaWUlNTE8DGSXeTlZXF0KFDSU9Pb1N7v0/kikiLPf3Y9NLSUvLy8hg+fDi6RlE6wjnH7t27KS0tpaioqE3LqAyDiO9ayunHptfU1NCvXz8FfOkwM6Nfv37H9K1RQV/Eby2N3okezukr4ItfjvWzpKAv4rdEOX2N3pEUoZy+iN8S9PSdsxaD/m/e+dTXt7/q7BN9XZ90L+rpi/gtHvQP/3ml0sVZe/fuZd68ece0zGc+85mk83/84x8f0/oqKyu58MILGTlyJBdeeCF79uxJ2K6srIxLLrnkmNbdGZ588km2bz/260lnz57N888/D8C0adM4luoCS5Ysie/7a6+9xl133XXM75+Igr6I31q8OCs1xum3J+i/9dZbSecfa9C///77mT59Ohs2bGD69Oncf//9Cds99NBD3Hjjjce07s6QLOhHIp1/XC+++GIWLFjAoUOHOrwuBX0RvyVI70RSKKc/d+5cNm3aRElJCbfffjs333wzCxYsAODyyy/n+uuvB+CXv/wl//Iv/wJAbm4uEOt5T506lZKSEsaMGcPSpUuZO3cu1dXVlJSUcPXVV7dpG1555RWuuy52Uf91113Hyy+/nLDdCy+8wIwZsZphTz75JN/85jfj8y655BKWLFkS37477riDcePGMXnyZMrLywEoLy/n8ssvZ9y4cYwbNy7+z+uhhx5izJgxjBkzhocffhiALVu2cPrpp3PjjTcyevRoPv/5z1NdXc3zzz/P8uXLufrqqykpKaG6uprhw4fzox/9iPPOO4/nnnuOlStXMnnyZIqLi7n88stb/ObS6E9/+hPnnHMO48ePZ9asWVRVVQHwhz/8gVGjRnHeeefx4osvxtubGdOmTeO1115r0+83GQV9Eb8lOJHrsCbfAIJ1//33M2LECFauXMm///u/M3XqVJYuXQrAtm3bWLt2LQDLli1jypQpRyz7m9/8hosuuoiVK1eyatUqSkpKuP/++8nOzmblypU8/fTTAEyZMoWSkpKjfhYtWgTEgvHgwYMBGDx4MDt37qS5zZs3U1BQQGZmZqv7dPDgQSZPnsyqVauYOnUqjz/+OADf+ta3OP/881m1ahXvv/8+o0eP5r333uOJJ57gnXfe4e233+bxxx9nxYoVAGzYsIFbbrmFDz/8kD59+vDCCy9wxRVXMHHiRJ5++mlWrlxJdnY2ELsoatmyZVx55ZVce+21PPDAA6xevZqxY8dyzz33tLitu3bt4t5772XRokW8//77TJw4kYceeoiamhpuvPFGXn31VZYuXcqOHTuOWG7ixInx49QROpEr4rdWLs5KNVOmTOHhhx9m7dq1nHHGGezZs4eysjL++te/8p//+Z9HtJ00aRLXX3899fX1zJw5k5KSkoTr9CM4lZWVUVhY2Ka2GRkZ8fz3hAkTWLhwIQBvvPEGv/71rwEIh8P07t2bZcuWcfnll5OTkwPAl770JZYuXcqll15KUVFRfJ8mTJjAli1bWnzPL3/5ywDs27ePvXv3cv755wOxby6zZs1qcbm3336btWvXcu655wJQV1fHOeecw/r16ykqKmLkyJEAXHPNNTz22GPx5QYMGNCu8wrNKeiL+C3h6B1SNugPGTKEPXv28Ic//IGpU6dSWVnJs88+S25uLnl5eUe0nTp1Kn/5y194/fXX+epXv8rtt9/Otddee9Q6p0yZwoEDB46a/uCDD3LBBRcwcOBAysrKGDx4MGVlZQwYMOCottnZ2UdcdJSWlkY0evh32HReenp6fLx6OBymoaGhxf11Sb5xNf1WEQ6Hqa6ubrFt4z+NY+Wc48ILL+S3v/3tEdNXrlyZdMx9TU1N/FtGRyjoi/gtYe0djrg4q6muHmKZl5d3VEA+55xzePjhh3njjTfYvXs3V1xxBVdcccVRy/79739nyJAh3HjjjRw8eJD333+fa6+9lvT0dOrr6+P1X1rr6V966aXMnz+fuXPnMn/+fC677LKj2px66qlH9LSHDx/OvHnziEajbNu2jXfffbfVfZ0+fTo///nPufXWW4lEIhw8eJCpU6cye/Zs5s6di3OOl156iaeeeirpehL9zhr17t2bgoICli5dypQpU3jqqafivf5EJk+ezC233MLGjRs55ZRTOHToEKWlpYwaNYrNmzezadMmRowYcdQ/hY8//pgxYzpevkw5fRG/pXh6p1+/fpx77rmMGTOG22+/HYj1zBsaGjjllFMYP348lZWVR+XzITaMsKSkhDPPPJMXXniBb3/72wDMmTOH4uLiNp/InTt3LgsXLmTkyJEsXLiQuXPnHtUmJyeHESNGsHHjRgDOPfdcioqKGDt2LLfddhvjx49v9X1++tOf8uc//5mxY8cyYcIEPvzwQ8aPH8/s2bM566yzOPvss7nhhhs488wzk65n9uzZ3HTTTfETuc3Nnz+f22+/neLiYlauXMmdd97Z4roKCwt58skn+cpXvkJxcTGTJ09m/fr1ZGVl8dhjj3HxxRdz3nnncdJJJx2x3J///GcuvvjiVve5NZbsq04q0J2z5Liz9Cew+EfwhQchnMa0f3qAr592gK+eVg13VbJu3TpOP/30oLfyuPDSSy/x3nvvce+99wa9KYEqLy/nqquuYvHixQnnJ/pMmdl7zrmJzdsqvSPiN905yzeXX345u3fvDnozAvfpp5/yk5/8xJd1KeiL+K3x23PzE7m4lBm2eTy54YYbgt6EwE2aNMm3dSmnL+K3BCdyI675PJFgKOiL+C3RkM3m80QCoqAv4jcXPaLYGkDU2eF5IgFSTl/EbwmCfjyVn2is/vIn/H3/iV/zd33SrainL+K3hD39JvMClgqllZ977jlGjx5NKBRKWm64M0orL1mypNWqoYk0Lfh299138+CDDx7T8o1F6yoqKuJF5IKgoC/it0RBv+m8gKVCaeUxY8bw4osvMnXq1KTtOqO0crKgn6x8g18KCwsZPHgwb775Zqe/VyIK+iJ+S5jeSZ2cfiqUVj799NM57bTTWm3XtLRyJBLhtttuY+zYsRQXF/Ozn/0MgMWLF3PmmWcyduxYrr/+empra4FY2Ya77rqL8ePHM3bsWNavX8+WLVt49NFH+Y//+A9KSkpYunQps2fP5rvf/S6f/exn+f73v09lZSUzZ86MXy27evXqpNu4adMmZsyYwYQJE5gyZQrr168HYlVCzznnHCZNmsQPf/jDI5aZOXNmvCJpV1PQF/Gbcynd00+F0spt0by08mOPPcbmzZtZsWIFq1ev5uqrr6ampobZs2fzu9/9jg8++ICGhgZ+/vOfx9fRv39/3n//fb7xjW/w4IMPMnz4cG666Sa+853vsHLlyvj+ffzxxyxatIif/OQn3HXXXZx55pmsXr2aH//4xwkLyjU1Z84cfvazn/Hee+/x4IMPcvPNNwPw7W9/m2984xv87W9/Y9CgQUcs41eZ5PbQiVwRvyU7kZsCQb+546W08qJFi7jppptIS4uFrb59+7Jq1SqKioo49dRTgVhZ40ceeYRbb70ViJVNhliZ5KY3JWlu1qxZhMNhIPbP7oUXXgDgc5/7HLt372bfvn0Jl6uqquKtt946opRy4zeNN998M76er371q3z/+9+Pt/GrTHJ7KOiL+M1FjxijD6l9cVYQpZXbonlpZefcUaWHW6sd1vgtobVyy03LJCdaZ0slj6PRKH369GHlypUJ57e0nF9lkttDQV/Eb4l6+k3nNdfFQyxTobRyWzQvrfz5z3+eRx99lGnTppGWlkZlZSWjRo1iy5Yt8TLFrZU1btz//fv3tzh/6tSpPP300/zwhz9kyZIl9O/fn/z8/IRt8/PzKSoq4rnnnmPWrFk451i9ejXjxo3j3HPP5ZlnnuGaa645Kn/vV5nk9lBOX8RvKX5xViqUVn7ppZcYOnQof/3rX7n44ou56KKLjmrTvLTyDTfcwIknnkhxcTHjxo3jN7/5DVlZWTzxxBPMmjWLsWPHEgqFuOmmm5K+9xe/+EVeeuml+Inc5u6++26WL19OcXFxvN5/Mk8//TS//OUvGTduHKNHj+aVV14BYmWdH3nkESZNmnRUesivMsntodLKIn577Tuw7lX47B0ATPunB/iHYYf4Xsk+uHUN68qqVFq5jbpraeWpU6fyyiuvUFBQ4Mv6VFpZJEgpfnHW8aQ7llauqKjgu9/9rm8B/1gpvSPit2gkpYdsHm+6W2nlwsJCZs6cGdj7K+iL+C3BOP1UHrIpPYuCvojfXBQsfMSkKKlzIld6NgV9Eb8lGKevnL6kCgV9Eb+l+Inc3bt3x8siDBo0iCFDhsRf19XV+fY+ixYtanfu+vnnnz+qhEMoFGLhwoW+bV9P1aHRO2b2HeAGYteefAB8DegF/A4YDmwB/tE5t8dr/wPg60AE+JZz7o8deX+RlNTqxVnB9rX69esXv4L07rvvJjc3l9tuu+2INs45nHOEQsFsa/OLw+bNm8fzzz/P9OnTA9me7qTdR9TMhgDfAiY658YAYeBKYC6w2Dk3EljsvcbMzvDmjwZmAPPMmiU+RbqDFL84qyUbN25kzJgx3HTTTYwfP56tW7fSp0+f+PxnnnkmPpKmvLycL33pS0ycOJGzzjqLt99+O+m6d+3axaWXXkpxcTGf+cxnWLNmDQA7d+5k+vTpjB8/nptvvpkhQ4awd+/eI5Zdt24dP/7xj/n1r38d2D+h7qSj4/TTgGwzqyfWw98O/ACY5s2fDywBvg9cBjzjnKsFNpvZRuAs4K8d3AaR1NLqnbOO/LObNm2ar2+/ZMmSdi+7du1annjiCR599NGktWq+9a1v8b3vfY/JkyezZcsWLrnkknggT+SHP/whZ599NgsWLOBPf/oTs2fPZvny5dx5553MmDGD22+/nddee+2ICpkAdXV1XHXVVTz88MMMHTq03fslh7U76DvntpnZg8CnQDXwJ+fcn8xsoHOuzGtTZmYDvEWGAE27A6XetKOY2RxgDsCJJ57Y3k0UCUaK5/STGTFiBJMmTWq13aJFi/joo4/ir/fs2UN1dXWLRcSWLVvG66+/DsRq6MyePZuDBw+ybNky7rgjduXyJZdcclSBt3/+539m/PjxCesASfu0O+ibWQGx3nsRsBd4zsyuSbZIgmkJa0A45x4DHoNYGYb2bqNIIJLeOevoj3NHeuZ+a1ptMhQKHVFxsnnFy3fffZeMjIw2rbd5uZfG18nKwCxatIhXX32V9957r03vIW3TkQTZBcBm51yFc64eeBH4DFBuZoMBvMedXvtSYFiT5YcSSweJdC/OQc2eoybFnqR2T7+pUChEQUEBGzZsIBqN8tJLL8XnXXDBBTzyyCPx1y2VFm7UWLkSYsF86NCh5OTkcN555/Hss88C8Pvf/z5e/XP37t3ccMMNPPXUU/G7dok/OhL0PwUmm1kvixWNng6sAxYA13ltrgNe8Z4vAK40s0wzKwJGAu924P1FUlOCETqHL86KdP32dMADDzzAjBkzmD59+hE59UceeYQ333yT4uJizjjjDB5//PGk6/nRj37EW2+9RXFxMXfeeSdPPPEEAPfccw+vv/4648eP54033mDgwIHk5OQwb948du3axZw5c44Ytvn888936v72BB2qsmlm9wBfBhqAFcSGb+YCzwInEvvHMMs5V+m1vwO43mt/q3Puf1p7D1XZlOPO0/8IO9fClP8HxKpsju9fy0PnVMLX/od1hwpUZdNTU1NDWloaaWlpLFu2jFtvvRX9vR+7Lquy6Zy7C7ir2eRaYr3+RO3vA+7ryHuKpDwXpfkprOPlRG5X27JlC1/5yleIRCJkZmbyi1/8IuhN6vZUWlnEbwnKMCS9c1YPNmrUKFasWBH0ZvQoutJBxG8Ja+94r6OxnH6q37xIjh/H+llS0BfxW9L0ToSsrCx2796twC8d5pxj9+7dZGVltXkZpXdE/Jagpx+JX5EbZehJQyktLaWioqLrt026naysrGO6WllBX8RvztG8px+Jp3caSE9Pp6ioqOu3SwSld0T8l+CK3Ejj+dtoy/VsRLqCgr6I35LdREVBXwKmoC/itwQnciPHQWll6RkU9EX8lvRErnr6EiwFfRG/Jezpe08U9CVgCvoifkt6cZaCvgRLQV/Eb0nTO8dXlU3pfhT0RfyWdJy+gr4ES0FfxG8apy8pTEFfxG86kSspTEFfxG8Jc/rH552zpPtR0Bfxm8bpSwpT0BfxW7LSyjqRKwFT0BfxW8I7Zxlg6ulL4BT0RfyWoKcPxEb0qKcvAVPQF/Gbc0f19AEv6KunL8FS0BfxW4L0DgAh9fQleAr6In5zURL+aamnLylAQV/Eby319BX0JQUo6Iv4rcUTuWFdnCWBU9AX8Zt6+pLCFPRF/NZiT990IlcCp6Av4rcWe/ph9fQlcAr6In5LOk5fPX0JloK+iN9aSu+ElNOX4Cnoi/gtwU1UAPX0JSUo6Iv4LWntHfX0JVgK+iJ+SzZkU+P0JWAK+iJ+0+gdSWEdCvpm1sfMnjez9Wa2zszOMbO+ZrbQzDZ4jwVN2v/AzDaa2UdmdlHHN18kBam0sqSwjvb0fwr8wTk3ChgHrAPmAoudcyOBxd5rzOwM4EpgNDADmGdm4Q6+v0jq0RW5ksLaHfTNLB+YCvwSwDlX55zbC1wGzPeazQdmes8vA55xztU65zYDG4Gz2vv+IinJOcChnr6kqo709E8GKoAnzGyFmf2XmeUAA51zZQDe4wCv/RBga5PlS71pRzGzOWa23MyWV1RUdGATRbqY826Gq56+pKiOBP00YDzwc+fcmcBBvFROCxL8FeASTMM595hzbqJzbmJhYWEHNlGki7lo7DHROH1dnCUpoCNBvxQodc69471+ntg/gXIzGwzgPe5s0n5Yk+WHAts78P4iqacx6Cfs4yi9I8Frd9B3zu0AtprZad6k6cBaYAFwnTftOuAV7/kC4EozyzSzImAk8G57318kJcV7+i2UYdA4fQlYWgeX/7/A02aWAXwCfI3YP5JnzezrwKfALADn3Idm9iyxfwwNwC3O6S9Aupn4R7qFnH6kvks3R6S5DgV959xKYGKCWdNbaH8fcF9H3lMkpSXr6eviLEkBuiJXxE86kSspTkFfxE/JTuSqpy8pQEFfxE9Jx+mHldOXwCnoi/gpaU9fQzYleAr6In5qDOoJh2yGIaqevgRLQV/ET41DNlu8c5Zy+hIsBX0RP0WTBP2QcvoSPAV9ET+5JOkdCwEOotGj54l0EQV9ET8l6+k33j5CeX0JkIK+iJ+SXZzVOE15fQmQgr6In1obvQPK60ugFPRF/BQvuJasp6+x+hIcBX0RP7U2egeU3pFAKeiL+Km1cfqgE7kSKAV9ET+1VloZ1NOXQCnoi/gpmizoe39uEQV9CY6CvoifkqV3lNOXFKCgL+KnpBdnKacvwVPQF/FTsnvkqqcvKUBBX8RPbenpK6cvAVLQF/FT0iGb6ulL8BT0RfzUltE7yulLgBT0Rfyk0TuS4hT0RfyknL6kOAV9ET+ppy8pTkFfxE/JSivrJiqSAhT0Rfykm6hIilPQF/FTNFk9/cabqCjoS3AU9EX8lOzG6CH19CV4CvoiftKN0SXFKeiL+ClZPX2N3pEUoKAv4qe23DlLOX0JkIK+iJ/alN5R0JfgKOiL+Clpeke1dyR4CvoifmrLkE319CVAHQ76ZhY2sxVm9pr3uq+ZLTSzDd5jQZO2PzCzjWb2kZld1NH3Fkk5yulLivOjp/9tYF2T13OBxc65kcBi7zVmdgZwJTAamAHMM2vs+oh0E0nLMFgs8KunLwHqUNA3s6HAxcB/NZl8GTDfez4fmNlk+jPOuVrn3GZgI3BWR95fJOUk6+k3TldOXwLU0Z7+w8D3gGiTaQOdc2UA3uMAb/oQYGuTdqXetKOY2RwzW25myysqKjq4iSJdKJqk9g7E8vrxvL9I12t30DezS4Cdzrn32rpIgmkuUUPn3GPOuYnOuYmFhYXt3USRrrdteewxUXoHYiN4IurpS3DSOrDsucClZvYPQBaQb2b/DZSb2WDnXJmZDQZ2eu1LgWFNlh8KbO/A+4uknmRVNsHr6SunL8Fpd0/fOfcD59xQ59xwYido33DOXQMsAK7zml0HvOI9XwBcaWaZZlYEjATebfeWi6Qi5w4PzUxEOX0JWEd6+i25H3jWzL4OfArMAnDOfWhmzwJrgQbgFueckpvSvbjo4Ro7iYSU05dg+RL0nXNLgCXe893A9Bba3Qfc58d7iqQkF229p6+cvgRIV+SK+MlFIJze8nzl9CVgCvoifopGIZTkC3RIF2dJsBT0RfwUbYBwRsvzLaScvgRKQV/ET0rvSIpT0BfxU2vpHdXekYAp6Iv4qdWevoK+BEtBX8RP0QiEWgv6yulLcBT0RfzkIhBWekdSl4K+iJ9cKz19DdmUgCnoi/gpqtE7ktoU9EX81GrQV05fgqWgL+Kn1tI7yulLwBT0RfwUjWrIpqQ0BX0RP7lIKxdnKacvwVLQF/FTazn9kHL6EiwFfRE/KacvKU5BX8RP0Ugbqmwq6EtwFPRF/BSph/Tslucrpy8BU9AX8VOkrpWgr5y+BEtBX8Qv0ShE6yG9V8ttVIZBAqagL+KXhprYY3pWy22U05eAKeiL+KW+OvaYrKevnL4ETEFfxC/1h2KPreX0XQSc65ptEmlGQV/EL409/a3vttzGvD85F+387RFJQEFfxC+NPf1k4/RD3p+cUjwSEAV9Eb809vSTXpwVjj0q6EtAFPRF/NLQGPRbKcMACvoSGAV9Eb+0qaffGPR1gZYEQ0FfxC/16ulL6lPQF/FLW07kKqcvAVPQF/FLW3r6Gr0jAVPQF/FLY9BvrZ4+KOhLYBT0RfzSUBt7bFNOXydyJRgK+iJ+aaiJBXVL8melnL4ErN1B38yGmdmfzWydmX1oZt/2pvc1s4VmtsF7LGiyzA/MbKOZfWRmF/mxAyIpo6E2eWoHlN6RwHWkp98A/D/n3OnAZOAWMzsDmAssds6NBBZ7r/HmXQmMBmYA88wauz0i3UCkFsJpydvoRK4ErN1B3zlX5px733t+AFgHDAEuA+Z7zeYDM73nlwHPOOdqnXObgY3AWe19f5GU01ADoVaCvnL6EjBfcvpmNhw4E3gHGOicK4PYPwZggNdsCLC1yWKl3rRE65tjZsvNbHlFRYUfmyjS+dqU3lFOX4LV4aBvZrnAC8Ctzrn9yZommJawqLhz7jHn3ETn3MTCwsKObqJI12hoQ3pHOX0JWIeCvpmlEwv4TzvnXvQml5vZYG/+YGCnN70UGNZk8aHA9o68v0hKaag9hvSOgr4EoyOjdwz4JbDOOfdQk1kLgOu859cBrzSZfqWZZZpZETASSHK3CZHjTENN6+kdnciVgLXSLUnqXOCrwAdmttKb9s/A/cCzZvZ14FNgFoBz7kMzexZYS2zkzy3OOZ3Nku6jTT39xpy+PvoSjHYHfefcMhLn6QGmt7DMfcB97X1PkZQWqU1+NS4ovSOB0xW5In5RTl+OAwr6In45pnH6CvoSDAV9Eb801LVhyKZy+hIsBX0Rv7Slp6/ROxIwBX0Rv6jgmhwHFPRF/KKcvhwHFPRF/BCNQrS+DUM2ldOXYCnoi/gh4t01Sz19SXEK+iJ+aKiJPbZ6Itfr6UfqOnd7RFqgoC/ihwYviLeW3mmc//e3Ond7RFqgoC/ih7b29C0U6+1H6jt/m0QSUNAX8UNDG3P6AOEMpXckMAr6In6In8htJb0DEMpQT18Co6Av4odj6umnK+hLYBT0RfzQmNNvrfYOeEFf6R0JRkduoiLSbfzmnU87tPzgiq18FviwvJqqA5VHzNtfE+vVv7M5Nv3scAZEFfQlGOrpi/ggHI319KPW1hO5Su9IMBT0RXwQ9tI10bbk9NMyoL6mk7dIJDGld0QSiDpHJOpoiDgcjpAZITPM8J6D2eG7hR7u6bdh9E5WAVR+0lmbLpKUgr70CPWRKDv21bB9bzXb91WzfW8NZfuq2XOwnj2H6ti86yCH6iJU10doiESJuuTrMyA9HCItbGSEQ3zZtjIZuH/TSRwM55MZipIRcmSEHFuTgjQAABCcSURBVAfHzsIi9TyzrT+ZIQehAZxdX80zS9dw0HJoiESpj0Spi7j489qGKNXe9tTUxx6r6yLU1Efjr2sbooS8f0LhUOwnMy1Ev9xM+udm0C8nk+37qinIzmBg7ywG5GWSHu68L/dXnX1ip61b/KOgL92Gc47dB+vYtLOKT3Yd5JOKKj6pOMimiiq27qkm0iyS9+mVTt+cDAp6ZdA7O53BvbPJTg+RFg4RDhnpISMcDmHeuqMu9g0g6hwN3reAei9IF1Y5OAQulEZd1KhqSKcuatS5EHWDS3DhDF7ekYHD2Bs6kbMz4L9//2fWuJOP2Kb0sJEWCpGVHiIrPUx2ejj2mBGmV0YafXNiz7PTQ2SkhXAOItHYt5KIc9TUR9hVVcf6HQfYXbWbfdWHzx0Y0D83k4G9szixby9GFOYwMD+LUJNvLNL9KejLcelQXQMf7TjA+h0HWF+2n3U7DvDRjgNHBLnMtBBF/XM444R8Lik+gWF9szmhj/fTO5vsjHC8bUdH75yxqRd8DLeNLMc1y+t/4+55AMy762YanDGuby94E357WT7R4s+TnhYL9OlhOyJl5Idf/3ULlQfrKN9fy4591ezYX8u2PYdYs20fADmZaYwozOGUwlxOG5RHXlYb0lNyXFPQl5TmnKN0TzXryvazfseB+OOW3QdxXsc9JyPMqMH5XFI8mFMG5HJyYS4n989hSJ9sQqGu6cWmRWpwGM7CLbYxg3Rz5PXpDxh5Bz+FXp0bZNNCIQbkZTEgL4uxQ3rHp+89VMcm71vQpp1VrC7dhwHD++cw5oR8Rg/pTb7+AXRLCvqSMg7U1PNx+QHWlR1g/Y79rC+L9eSramO1583gpL69OH1wPjNLhjBqcB5nDM7v0uDeklC0jkgoM7aRrXhny17OTOvFp5s3824Hv2G0V59eGUw4KYMJJxXgnKN8fy1rtu9jzbZ9vLq6jNdWl3FSv14UD+1D8ZDe9MpUqOgudCSly9U1RPlkV1U8PfOR97Ntb3W8TV5WGv1yMhgzJJ9B+dkM7p3FgPxMMtMO96R3V9WxdMOuIHbhKGmRGiLhzDa3rw/nklW3uxO3qO3MjEG9sxjUO4sLTh9I+f4a1mzfxwel+1iwajuvrd7OqQPzKBnWh1GD8slI00jv45mCvnQa5xzb9lYfFdw/2VVFfSSWm0kLGScX5jD+pAKuOvtEThuYx2mD8hhakM1v390a8B60XThaG+vpt1FDWg5ZtakR9JsbmJ/FwPwsPnfaAMr21bBq615Wle5l/Y4DZKSFGD04n5JhfTi5MJdwwN+w5Ngp6MsxaemEZ3VdhB37a9ixv4byfd7j/hpqG6LxNn2y0xmYn8VnRvRnYH4Wg/Kz6J+XQVrocM9x54Fadh6o7fT98Fs4UntsPf20HLLqKltvGCAzi5/4vmjMIDbvOsiqrXtZs30fK7buJTczjeKhvSkZ1ochfbKD3lxpIwV9OSYNkSg7D9RSvv9wYN+xr4b9NYfv+ZqVHmJQfhYlw/rE0gZezzErveWTnMe7Y+3p14d70bvu+LlAK2TGiMJcRhTm8sVxJ/DRjgOsKt3LO5sreWvTbvrlZFBRVcvMkiEM758T9OZKEgr6klA0Ghs1s37H/lh6ptxLzVRUxS9cCoeMAXmZnFyYGw/sg3pnkZ+V5vvQw1QXPsacfkNaL9IjBwlF6oiGMzpxy/yXHg4xZkhvxgzpTXVdhA+372Pl1r38dPEGHl60gXHD+jCz5AQuKT6Bwry2/06kayjoC5UH6+LBvTH/vqH8AAfrIvE2w/pmc9rAfIYWZMcDfP/cTOV0PWmRQ9Sn5ba5fUO4FwCZ9XuoDg/srM3qdNkZYSYO78vE4X357KhCXl21nZdXbOeeV9dy7+vrOOfkfkw7rZBppw1gRGFOj+sMpCIF/R6kpj7ChvKqwwG+PBbgK5rk0At6pXPaoDxmTRzGaYNiJ1VPHZhHrjdkr6MXMXVXGfUH2J8zvM3t69O8oF+3h+qs4zfoNzW4dzZzpo5gztQRbCg/wMsrt/GHNTu49/V13Pv6OoYWZHP+qYVMGdmficP70j9X3wKCoKDfDTQPxFHnqDxYx459NUfk3ndX1dFYiCAtZAzIz2RYQTYTTyqI9d57Z5GXeTg14xyxsfJlB7p4j44/6Q0H2tfTr9vTWZsUqJED87j9olHcftEotlYe4n8/ruB/P67g5RXbeNr7vJ5cmMOkk/oyqahvbDRQ/5zAr7foCRT0j2POOXZV1bFxZ9URo2Z2HqiJD4k0oG9OBgPzsyge2ic+aqZfboZqrvgoo/4A9el5bW7f2NPPqtvbWZuUMob17cU1k0/imsknUdcQ5YNt+/jblkr+trmS/1lTxu+Wx4bm5mSEGX1Cb0YPyWfskN6cOjCPkwtz6JWhMOUn/TaPA845tu+rYUP5ATburDr8U1HF3kOHa83kZKYxKD+Ts4b3jZ9UHZCXpYtpOplFG0iPHKIure1BvyEcG+GSmeLDNo/FsaT+8rPSmX76QD47agA7D9SybU812/ZWs31vNSu27ol3WiCWcizMy2RAXpb3mMmcqSfTNydD5wjaQUE/RTRWiNxaeYhPKw+xtfIQn1QcZMPOKjZVVHGoyUnVvjkZnFKYyxfGxGrNbNtTzaDeWfG8u3StjPpY8bK6jN6ttDysIZxFlFDKXJUblJAZg7xvnxNOKgBi6ckK73qNigM13mMtn1TspsEbOvaLv3xCTkaYYX17MaxvL05s8jOkIJtBzVKVcliXRwkzmwH8FAgD/+Wcu7+rt6GrRaOOPYfqqKiqZef+2viHuHx/DaV7qindEwv0TQM7wODeWZwyIJd/nDiMkQNzOaUwl1MG5NKv2QkwnVwNVk51GQAHswaTVdvGshAWoqrXMPKrtnTehh2nQmbxq4Lh8D/SqHPsPVTPzgM1FPXPiXeO/r77IEs3VFBTHz1iPb0ywvHrRAb1zoqV8sjLom9OBv28+w3ESmunk9aJ9xlINV0a9M0sDDwCXAiUAn8zswXOubWd/d7N66G7+PNYPfJE8yNRR11D7IYWtQ2xG1jUNkSorY9S4z3WNkQ5VNfA/poG9lfXs7+mnv3Vh5/vPVTPrqraeA+lqdzMNIYWZDO0oBefGdGfYX2zOdHruQwtyFYu8zhRsH8dAAdyTmp70Af25Z1C/72rjsux+kEImdE3J4O+ORlH3bDFOUdFVS1bKw+xfW/sgsEd3oWDZfuqeeeTSsr31yT8OzSD3tmxeyvkZaWTl5lGXlbjTzp5WWnkZqaRlR4mMy1EZnqYLO8xMy3k/YTJTA+REQ4RChlhM0IhCHs3uGmcFg5Z/KY3ze++1lW6OqqcBWx0zn0CYGbPAJcBvgf9f/jpUjbsPEAk6lq9C5Jf8rLSyM9KJz87nd7ZaZzYtxdjhqTH85AD8mJFwwpzMxmQn6mg3h04x8itz7Evp4j9OUUUVr7X5kW3nHAxw8oXc1LZ79k8dGYnbmT3Z2bxEtITTkrcJhp1VB6qo/JgHbuqaqk82Pi8jsqDtew5GOuoVdU2sGN/DQdq6qmqaTjiehX/tzs22KIx+BuHC7Uaxuq7P+/7lezmXBdFRMDMrgBmOOdu8F5/FTjbOffNZu3mAHO8l6cBH/m4Gf2B1CjN2Pl6yr5qP7uXnrKf0Hn7ugvAOTej+Yyu7mom+i5z1H8d59xjwGOdsgFmy51zEztj3ammp+yr9rN76Sn7CcHsa1efvSgFhjV5PRTY3sXbICLSY3V10P8bMNLMiswsA7gSWNDF2yAi0mN1aXrHOddgZt8E/khsyOavnHMfduU20ElpoxTVU/ZV+9m99JT9hAD2tUtP5IqISLB6zhUJIiKioC8i0pN0m6BvZn3NbKGZbfAeCxK0yTKzd81slZl9aGb3NJv/f83sI2/evzWZ/gMz2+jNu6gr9qclHd1PM7vbzLaZ2Urv5x+86cPNrLrJ9Ee7cr+a66z99OalzPH0tqfDn12vzW1m5sysv/e6Wx3TJm2O2E9vWsocUx8+u/9qZqu9Y/YnMzvBm+7P8XTOdYsf4N+Aud7zucADCdoYkOs9TwfeASZ7rz8LLAIyvdcDvMczgFVAJlAEbALCx/F+3g3clmCZ4cCaoI9jF+xnSh1PP/bVmzaM2ACJvwP9u+MxTbKfKXVMffjs5jdp9y3gUT+PZ7fp6RMr5zDfez4fOOq6dhdT5b1M934az2R/A7jfOVfrtd3ZZL3POOdqnXObgY3EykkEpaP7ebzorP1MtePZuE0d3df/AL5Hah/nztrPVDumHdpP59z+Jk1z8PmYdqegP9A5VwbgPQ5I1MjMwma2EtgJLHTOvePNOhWYYmbvmNn/mtkkb/oQYGuTVZR604LS0f0E+Kb39fFXzb56FpnZCm//p3TaHrRNZ+1nqh1P6OC+mtmlwDbn3KoEi3WbY5pkP1PtmHb4s2tm95nZVuBq4M4mi3X4eB5XFb/MbBEwKMGsO9q6DudcBCgxsz7AS2Y2xjm3htjvogCYDEwCnjWzk2lj6Qg/dfJ+/hz4V2L78K/AT4DrgTLgROfcbjObALxsZqOb9Tp8FdB+dvnxhM7bV+ATbx2fT7BItzmmJN/P7vY3inPuDuAOM/sB8E3gLnw6nsdV0HfOXdDSPDMrN7PBzrkyMxtM7L9nsnXtNbMlwAxgDbHewYsuljx718yixIohdXnpiM7cT+dceZN1PQ685rWrBRpTW++Z2SZi336Wd3R/kmxbl+8nAZUC6cR9/SOxPPYqi5VnHAq8b2ZnOed20H2OaYv7STf7G202+zfA68Bdfv2Ndqf0zgLgOu/5dcArzRuYWaH3XxUzywYuANZ7s18GPufNOxXIIFapbgFwpZllmlkRMBJ4txP3ozUd2k/vQ9jocrwPmbdM2Ht+MrH9/KST9qEtOmU/Sb3j2bhN7dpX59wHzrkBzrnhzrnhxALgeOfcju50TJPtJ6l3TDv62R3ZpOmlTab7czzbc/Y3FX+AfsBiYIP32NebfgLwe+95MbACWE0sCNzZZPkM4L+96e8Dn2sy7w5iIwI+Ar5wnO/nU8AH3rwFwGBv+v8BPiQ2CuJ94IvdcT9T7Xj6sa/N1rWFw6NautUxbWk/U+2Y+vDZfcGbthp4FRji5/FUGQYRkR6kO6V3RESkFQr6IiI9iIK+iEgPoqAvItKDKOiLiPQgCvoizZhZVeutEi43zA5XQGz82W9mD/i9jSLtpSGbIs2YWZVzLteH9YwFfg+c5bxaLCJBU09fpAUW8+9mtsbMPjCzL3vTQ2Y2z2J10F8zs9+b2RXNls0CngZuUcCXVHJc1d4R6WJfAkqAccTqMP3NzP4CnEustvlYYhUU1wG/arbsvwFvOucWdNnWirSBgr5Iy84Dfuti1RDLzex/iVVgPQ94zjkXBXaY2Z+bLmRmXyBWS2ViV2+wSGsU9EValqhkb7LpmFkh8AvgMufcoU7ZKpEOUE5fpGV/Ab5ssZtdFAJTiVVvXAb8Hy+3PxCY1mSZXwE/c86t6PKtFWkDjd4RaaZx9I7FCrf/G/AFYjfluNc59zszCwHziP0T+JjYvVkfAqqAt4hVR2z6h7XQOXd7V+6DSEsU9EXawcxynXNVZtaPWO//XBer7S6S0pTTF2mf17ybYGQA/6qAL8cL9fRFRHoQncgVEelBFPRFRHoQBX0RkR5EQV9EpAdR0BcR6UH+PwJanpLM+ZsSAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -450,350 +338,175 @@
     }
    ],
    "source": [
-    "sns.distplot(Xs[0,:,:])\n",
-    "sns.distplot(Xs[-1,:,:])"
+    "sns.distplot(logZs, label='twist=0 (uncontrolled)')\n",
+    "sns.distplot(twist1_logZs, label='twist=1 (controlled)')\n",
+    "plt.xlabel(f\"logZ\")\n",
+    "plt.vlines(dG,0,1000, label=f\"True logZ\")\n",
+    "plt.ylim(0,1000)\n",
+    "plt.legend()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "how will we minimize?\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "from scipy.optimize import minimize"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def rosen(x):\n",
-    "    \"\"\"The Rosenbrock function\"\"\"\n",
-    "    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)\n",
-    "jit_rosen=jit(rosen)"
+    "now, we have to generate ensemble trajectories and works so that we can twist _again_"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
-    "x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])"
+    "twist_1_Xs = generate_trajs(prop_params, model_params, y, rs, init_params, init_Xs, prop)\n",
+    "twist_1_logWs = SIS_logW(twist_1_Xs, prop_params, model_params, y, init_params, logw, init_logws, aggregate_works=False)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "848.22"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['sum_square_diffs', 'loss', 'scipy_loss', 't0_scipy_loss', 'get_callback_fn', 'np_scipy_loss', 'np_t0_scipy_loss', 'np_scipy_loss_grad', 'np_t0_scipy_loss_grad', 'ADP'])\n"
+     ]
     }
    ],
    "source": [
-    "rosen(x0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "energy_history = []\n",
-    "x_values = []\n",
-    "def callback(x):\n",
-    "    fobj = jit_rosen(x)\n",
-    "    energy_history.append(fobj)\n",
-    "    x_values.append(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "out = minimize(jit_rosen,x0 = x0, method='L-BFGS-B', options={'disp':1}, callback = callback)"
+    "ADP_dict = smc_obj.get_ADP_fn()\n",
+    "print(ADP_dict.keys())\n",
+    "ADP_fn = ADP_dict['ADP']"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "['fun', 'hess_inv', 'jac', 'message', 'nfev', 'nit', 'status', 'success', 'x']"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 9/9 [00:02<00:00,  4.09it/s]\n"
+     ]
     }
    ],
    "source": [
-    "dir(out)"
+    "out_dict = ADP_fn(twist_1_Xs, twist_1_logWs, prop_params, verbose=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "dtype('float64')"
+       "{'out_A_params': DeviceArray([[1.14078437],\n",
+       "              [0.92719429],\n",
+       "              [0.73231083],\n",
+       "              [0.55587318],\n",
+       "              [0.40075045],\n",
+       "              [0.26908349],\n",
+       "              [0.16247449],\n",
+       "              [0.08182895],\n",
+       "              [0.02742049]], dtype=float64),\n",
+       " 'out_b_params': DeviceArray([[0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.],\n",
+       "              [0.]], dtype=float64),\n",
+       " 'out_A0': DeviceArray([1.21034982], dtype=float64),\n",
+       " 'out_b0': DeviceArray([0.0048561], dtype=float64),\n",
+       " 'loss_trace': [array([2232.38811346,  821.13728281,  819.6326252 ,  818.34456201,\n",
+       "          818.34456201]),\n",
+       "  array([651.39607831,  30.73995716]),\n",
+       "  array([189.80606019,  24.69034995]),\n",
+       "  array([2223.89044803,   18.82275719]),\n",
+       "  array([5998.92824669,   15.92329024]),\n",
+       "  array([10.63161091]),\n",
+       "  array([7.22675448]),\n",
+       "  array([4.78205351]),\n",
+       "  array([2.68082285]),\n",
+       "  array([1.15562279])]}"
       ]
      },
-     "execution_count": 53,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "out['x'].dtype"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = jnp.asarray(np.random.randn(3,3))\n",
-    "b = jnp.asarray(np.random.randn(3))"
+    "out_dict"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 11,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray([[-0.6738118 , -0.71250094, -0.02713342],\n",
-       "             [-0.19548071, -0.69893683,  0.36365833],\n",
-       "             [-0.39087161,  0.04401595, -1.06750039],\n",
-       "             [ 0.09134596,  1.10062331,  1.62327804]], dtype=float64)"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "jnp.vstack((a,b))"
+    "on a note, its strange that the new A parameters have changed more in this iteration than they have in the previous...i suspect this will be detrimental to the smc logZ estimator. let's find out."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def square(x):\n",
-    "    return (x-1)**2\n",
-    "vsquare = vmap(square)\n",
-    "out_fn = lambda x: vsquare(x).sum()\n",
-    "\n",
-    "out = minimize(out_fn, x0 = np.random.randn(3,3)*100, method='L-BFGS-B', options={'disp':True})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "      fun: DeviceArray(2.69886881e-16, dtype=float64)\n",
-       " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>\n",
-       "      jac: array([ 1.51797942e-09, -2.24263495e-09,  8.80799771e-10, -2.55183650e-09,\n",
-       "       -4.71546471e-10, -3.77173283e-09,  5.62467847e-10,  2.73691290e-10,\n",
-       "       -1.57714653e-09])\n",
-       "  message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
-       "     nfev: 60\n",
-       "      nit: 3\n",
-       "   status: 0\n",
-       "  success: True\n",
-       "        x: array([1.        , 0.99999999, 1.        , 0.99999999, 0.99999999,\n",
-       "       0.99999999, 1.        , 1.        , 0.99999999])"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[1.        , 0.99999999, 1.        ],\n",
-       "       [0.99999999, 0.99999999, 0.99999999],\n",
-       "       [1.        , 1.        , 0.99999999]])"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out['x'].reshape(3,3)"
+    "smc_obj.update_cSMC(out_dict['out_A_params'], out_dict['out_b_params'], out_dict['out_A0'], out_dict['out_b0'])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 1/1 [00:05<00:00,  5.02s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "doing base SIS\n",
-      "done\n"
+      "  0%|          | 0/100 [00:00<?, ?it/s]DEBUG:absl:Compiling vSIS_lower_bound for args (ShapedArray(float64[9,1]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[10,1]), ShapedArray(float64[10,1]), ShapedArray(int64[10]), ShapedArray(uint32[2]), ShapedArray(float64[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1,1])).\n",
+      "100%|██████████| 100/100 [00:03<00:00, 28.93it/s]\n"
      ]
     }
    ],
    "source": [
-    "smc_obj= StaticULAControlledSMC(N, \n",
-    "                                potential=potential,\n",
-    "                                forward_potential=potential, \n",
-    "                                backward_potential=potential, \n",
-    "                                A_fn = A_twist_fn, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
-    "                                b_fn = b_twist_fn, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
-    "                                A_params_len=1,\n",
-    "                                b_params_len=1,\n",
-    "                                Dx=1\n",
-    "                               )\n",
-    "prop, logw, inits = smc_obj.get_fns()\n",
-    "potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis]\n",
-    "prop_params = {\n",
-    "               'potential_params': potential_params,\n",
-    "               'forward_potential_params': potential_params,\n",
-    "               'backward_potential_params': potential_params[1:],\n",
-    "               'dt': dt\n",
-    "               }\n",
-    "\n",
-    "init_params = {'mus': jnp.array([mu]), \n",
-    "               'covs': jnp.array([cov]),\n",
-    "               'mixture_weights': jnp.array([1.])}\n",
-    "\n",
-    "model_params=None\n",
-    "y=jnp.zeros(T)\n",
-    "rs = random.PRNGKey(10)\n",
-    "jSIS_lower_bound = jit(vSIS_lower_bound, static_argnums=(5,6,7))\n",
-    "jSIS = jit(SIS, static_argnums=(5,6,7)) #SIS(prop_params, model_params, y,  rs, init_params, prop_fn, logW_fn, init_fns)\n",
-    "logZs = []\n",
-    "\n",
-    "for i in tqdm.trange(1):\n",
-    "    rs, run_rs = random.split(rs, 2)\n",
-    "    logZ = vSIS_lower_bound(prop_params, model_params, y, run_rs, init_params, prop, logw, inits)\n",
-    "    logZs.append(logZ)\n",
+    "prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
+    "twist2_logZs = []\n",
     "\n",
-    "print(f\"doing base SIS\")\n",
-    "Xs, untwisted_logWs = jSIS(prop_params, model_params, y, rs, init_params, prop, logw, inits, aggregate_works=False)\n",
-    "print('done')\n",
-    "    \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-0.3465"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dG"
+    "for i in tqdm.trange(100):\n",
+    "    rs, run_rs = random.split(rs)\n",
+    "    out_logZ = jvSIS(prop_params, model_params, y,  run_rs, init_params, prop, logw, (init_Xs, init_logws))\n",
+    "    twist2_logZs.append(out_logZ)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "DeviceArray(-21.059101, dtype=float32)"
+       "<matplotlib.legend.Legend at 0x7ff3d877add8>"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 51,
      "metadata": {},
      "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.array(logZs).mean()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -805,1455 +518,20 @@
     }
    ],
    "source": [
-    "for i in range(1000):\n",
-    "    plt.plot(Xs[:,i,:])"
+    "sns.distplot(logZs, label='twist=0 (uncontrolled)')\n",
+    "sns.distplot(twist1_logZs, label='twist=1 (controlled)')\n",
+    "sns.distplot(twist2_logZs, label='twist=2 (controlled)')\n",
+    "plt.xlabel(f\"logZ\")\n",
+    "plt.vlines(dG,0,1000, label=f\"True logZ\")\n",
+    "plt.ylim(0,100)\n",
+    "plt.legend()"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/dominic/anaconda3/envs/openmm/lib/python3.6/site-packages/seaborn/distributions.py:288: UserWarning: Data must have variance to compute a kernel density estimate.\n",
-      "  warnings.warn(msg, UserWarning)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7f1d2db79fd0>"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "sns.distplot(random.normal(key=random.PRNGKey(0), shape=(10000,))*jnp.sqrt(cov))\n",
-    "sns.distplot(Xs[0,i,:])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "ok, so this looks ok"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## for the ADP (lord help me)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "losses, grad_losses, optimize_fn, ADP_fn = smc_obj.get_ADP_fn()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/9 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "iterating backward...\n",
-      "t: 9; initial loss: 90.28929138183594\n",
-      "optimized parameters: {'A_params': DeviceArray([-56.194862], dtype=float32), 'b_params': DeviceArray([-0.14679931], dtype=float32)}\n",
-      "twisting A params: [[  0.      ]\n",
-      " [-56.194862]]\n",
-      "twist b params: [[ 0.        ]\n",
-      " [-0.14679931]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 11%|█         | 1/9 [00:01<00:13,  1.68s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 8; initial loss: 72244168.0\n",
-      "optimized parameters: {'A_params': DeviceArray([-55.792953], dtype=float32), 'b_params': DeviceArray([0.01488524], dtype=float32)}\n",
-      "twisting A params: [[  0.      ]\n",
-      " [-55.792953]]\n",
-      "twist b params: [[0.        ]\n",
-      " [0.01488524]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 22%|██▏       | 2/9 [00:01<00:08,  1.24s/it]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 7; initial loss: 73184264.0\n",
-      "optimized parameters: {'A_params': DeviceArray([-62.749123], dtype=float32), 'b_params': DeviceArray([0.07351948], dtype=float32)}\n",
-      "twisting A params: [[  0.      ]\n",
-      " [-62.749123]]\n",
-      "twist b params: [[0.        ]\n",
-      " [0.07351948]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 33%|███▎      | 3/9 [00:02<00:05,  1.07it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 6; initial loss: 73946816.0\n",
-      "optimized parameters: {'A_params': DeviceArray([-68.571884], dtype=float32), 'b_params': DeviceArray([0.12859744], dtype=float32)}\n",
-      "twisting A params: [[  0.      ]\n",
-      " [-68.571884]]\n",
-      "twist b params: [[0.        ]\n",
-      " [0.12859744]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 44%|████▍     | 4/9 [00:02<00:03,  1.38it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 5; initial loss: 74741664.0\n",
-      "optimized parameters: {'A_params': DeviceArray([-74.96388], dtype=float32), 'b_params': DeviceArray([0.06939767], dtype=float32)}\n",
-      "twisting A params: [[  0.     ]\n",
-      " [-74.96388]]\n",
-      "twist b params: [[0.        ]\n",
-      " [0.06939767]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 56%|█████▌    | 5/9 [00:02<00:02,  1.74it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 4; initial loss: 75185112.0\n",
-      "optimized parameters: {'A_params': DeviceArray([-78.34155], dtype=float32), 'b_params': DeviceArray([0.23034683], dtype=float32)}\n",
-      "twisting A params: [[  0.     ]\n",
-      " [-78.34155]]\n",
-      "twist b params: [[0.        ]\n",
-      " [0.23034683]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 67%|██████▋   | 6/9 [00:02<00:01,  2.14it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 3; initial loss: 75328984.0\n",
-      "optimized parameters: {'A_params': DeviceArray([-78.976166], dtype=float32), 'b_params': DeviceArray([0.65710646], dtype=float32)}\n",
-      "twisting A params: [[  0.      ]\n",
-      " [-78.976166]]\n",
-      "twist b params: [[0.        ]\n",
-      " [0.65710646]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 78%|███████▊  | 7/9 [00:03<00:00,  2.50it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 2; initial loss: 75302760.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 89%|████████▉ | 8/9 [00:03<00:00,  2.78it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "optimized parameters: {'A_params': DeviceArray([-78.01529], dtype=float32), 'b_params': DeviceArray([0.8420237], dtype=float32)}\n",
-      "twisting A params: [[  0.     ]\n",
-      " [-78.01529]]\n",
-      "twist b params: [[0.       ]\n",
-      " [0.8420237]]\n",
-      "t: 1; initial loss: 75218032.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 9/9 [00:03<00:00,  2.55it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "optimized parameters: {'A_params': DeviceArray([-76.50562], dtype=float32), 'b_params': DeviceArray([0.9285487], dtype=float32)}\n",
-      "twisting A params: [[  0.     ]\n",
-      " [-76.50562]]\n",
-      "twist b params: [[0.       ]\n",
-      " [0.9285487]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "new_param_dct, losses_arr, init_losses_arr = ADP_fn(Xs, \n",
-    "                                                    random.PRNGKey(42), \n",
-    "                                                    untwisted_logWs, \n",
-    "                                                    prop_params, \n",
-    "                                                    init_params, \n",
-    "                                                    opt_steps=1000,\n",
-    "                                                    learning_rates_0={'A0': 1e-5, 'b0': 1e-5})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "smc_obj.update_twist(new_param_dct)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "let's check the smc object"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1\n",
-      "[[nan]]\n",
-      "[nan]\n",
-      "[[[  0.      ]\n",
-      "  [-76.50562 ]\n",
-      "  [-78.01529 ]\n",
-      "  [-78.976166]\n",
-      "  [-78.34155 ]\n",
-      "  [-74.96388 ]\n",
-      "  [-68.571884]\n",
-      "  [-62.749123]\n",
-      "  [-55.792953]\n",
-      "  [-56.194862]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]\n",
-      "\n",
-      " [[  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]\n",
-      "  [  0.      ]]]\n",
-      "[[[ 0.        ]\n",
-      "  [ 0.9285487 ]\n",
-      "  [ 0.8420237 ]\n",
-      "  [ 0.65710646]\n",
-      "  [ 0.23034683]\n",
-      "  [ 0.06939767]\n",
-      "  [ 0.12859744]\n",
-      "  [ 0.07351948]\n",
-      "  [ 0.01488524]\n",
-      "  [-0.14679931]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]\n",
-      "\n",
-      " [[ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]\n",
-      "  [ 0.        ]]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(smc_obj.twisting_iteration)\n",
-    "print(smc_obj.A0)\n",
-    "print(smc_obj.b0)\n",
-    "print(smc_obj.A_params_cache)\n",
-    "print(smc_obj.b_params_cache)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "ok, can we try to run a twisted iteration?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prop, logw, inits = smc_obj.get_fns()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jSIS_lower_bound = jit(vSIS_lower_bound, static_argnums=(5,6,7))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 100/100 [00:03<00:00, 27.90it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "doing base SIS\n",
-      "done\n"
-     ]
-    }
-   ],
-   "source": [
-    "rs = random.PRNGKey(34)\n",
-    "twist_logZs = []\n",
-    "for i in tqdm.trange(100):\n",
-    "    rs, run_rs = random.split(rs, 2)\n",
-    "    logZ = jSIS_lower_bound(prop_params, model_params, y, run_rs, init_params, prop, logw, inits)\n",
-    "    twist_logZs.append(logZ)\n",
-    "\n",
-    "print(f\"doing base SIS\")\n",
-    "Xs, twisted_logWs = jSIS(prop_params, model_params, y, rs, init_params, prop, logw, inits, aggregate_works=False)\n",
-    "print('done')\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(10, 1000)"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "twisted_logWs.shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray(-0.34653977, dtype=float32)"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.array(twist_logZs).mean()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0, 0.5, 'density')"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "sns.distplot(logZs, label='uncontrolled SMC')\n",
-    "sns.distplot(twist_logZs, label='controlled SMC (1 twist)')\n",
-    "plt.vlines(dG, 0,800, label='true log evidence')\n",
-    "plt.ylim(0,800)\n",
-    "plt.legend()\n",
-    "plt.xlabel(f\"log evidence\")\n",
-    "plt.ylabel(f\"density\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "losses, grad_losses, optimize_fn, ADP_fn = smc_obj.get_ADP_fn()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/9 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "iterating backward...\n",
-      "t: 9; initial loss: 2.352574586868286\n",
-      "optimized parameters: {'A_params': DeviceArray([0.02777491], dtype=float32), 'b_params': DeviceArray([0.00017573], dtype=float32)}\n",
-      "twisting A params: [[0.02761868]\n",
-      " [0.02777491]]\n",
-      "twist b params: [[-0.00014188]\n",
-      " [ 0.00017573]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 11%|█         | 1/9 [00:00<00:02,  3.46it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 8; initial loss: 19.79930877685547\n",
-      "optimized parameters: {'A_params': DeviceArray([0.08117654], dtype=float32), 'b_params': DeviceArray([-0.00045195], dtype=float32)}\n",
-      "twisting A params: [[0.05527914]\n",
-      " [0.08117654]]\n",
-      "twist b params: [[-0.00018345]\n",
-      " [-0.00045195]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 22%|██▏       | 2/9 [00:00<00:01,  3.67it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 7; initial loss: 76.38909912109375\n",
-      "optimized parameters: {'A_params': DeviceArray([0.1611653], dtype=float32), 'b_params': DeviceArray([-0.00200456], dtype=float32)}\n",
-      "twisting A params: [[0.0828969]\n",
-      " [0.1611653]]\n",
-      "twist b params: [[-4.7316571e-05]\n",
-      " [-2.0045561e-03]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 33%|███▎      | 3/9 [00:00<00:01,  3.78it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 6; initial loss: 210.3072967529297\n",
-      "optimized parameters: {'A_params': DeviceArray([0.2689866], dtype=float32), 'b_params': DeviceArray([-0.00059998], dtype=float32)}\n",
-      "twisting A params: [[0.11011182]\n",
-      " [0.2689866 ]]\n",
-      "twist b params: [[ 0.00012336]\n",
-      " [-0.00059998]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 44%|████▍     | 4/9 [00:01<00:01,  3.84it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 5; initial loss: 468.725830078125\n",
-      "optimized parameters: {'A_params': DeviceArray([0.39778167], dtype=float32), 'b_params': DeviceArray([-0.0009053], dtype=float32)}\n",
-      "twisting A params: [[0.1369963 ]\n",
-      " [0.39778167]]\n",
-      "twist b params: [[ 0.00011628]\n",
-      " [-0.0009053 ]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 56%|█████▌    | 5/9 [00:01<00:01,  3.99it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 4; initial loss: 872.512939453125\n",
-      "optimized parameters: {'A_params': DeviceArray([0.55107117], dtype=float32), 'b_params': DeviceArray([0.00042376], dtype=float32)}\n",
-      "twisting A params: [[0.16334553]\n",
-      " [0.55107117]]\n",
-      "twist b params: [[2.3297016e-05]\n",
-      " [4.2376152e-04]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 67%|██████▋   | 6/9 [00:01<00:00,  4.06it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 3; initial loss: 1513.4588623046875\n",
-      "optimized parameters: {'A_params': DeviceArray([0.7302874], dtype=float32), 'b_params': DeviceArray([0.00440207], dtype=float32)}\n",
-      "twisting A params: [[0.18970983]\n",
-      " [0.7302874 ]]\n",
-      "twist b params: [[0.00049331]\n",
-      " [0.00440207]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 78%|███████▊  | 7/9 [00:01<00:00,  4.04it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 2; initial loss: 2498.88427734375\n",
-      "optimized parameters: {'A_params': DeviceArray([0.92457175], dtype=float32), 'b_params': DeviceArray([0.00066601], dtype=float32)}\n",
-      "twisting A params: [[0.2155855 ]\n",
-      " [0.92457175]]\n",
-      "twist b params: [[0.00104538]\n",
-      " [0.00066601]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      " 89%|████████▉ | 8/9 [00:01<00:00,  4.13it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "t: 1; initial loss: 3782.283935546875\n",
-      "optimized parameters: {'A_params': DeviceArray([1.1399895], dtype=float32), 'b_params': DeviceArray([-0.00361299], dtype=float32)}\n",
-      "twisting A params: [[0.24124295]\n",
-      " [1.1399895 ]]\n",
-      "twist b params: [[ 0.0016072 ]\n",
-      " [-0.00361299]]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 9/9 [00:02<00:00,  4.10it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "new_param_dct, losses_arr, init_losses_arr = ADP_fn(Xs, \n",
-    "                                                    random.PRNGKey(42), \n",
-    "                                                    twisted_logWs, \n",
-    "                                                    prop_params, \n",
-    "                                                    init_params, \n",
-    "                                                    opt_steps=1000,\n",
-    "                                                    learning_rates_0={'A0': 1e-5, 'b0': 1e-5})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray([[4.5078994e+03, 3.9918843e+03, 3.5360549e+03, ...,\n",
-       "              8.0459534e+01, 8.0459534e+01, 8.0459534e+01],\n",
-       "             [3.7822839e+03, 3.3549795e+03, 2.9760068e+03, ...,\n",
-       "              3.0151620e+00, 3.0151620e+00, 3.0151620e+00],\n",
-       "             [2.4988843e+03, 2.2155190e+03, 1.9643240e+03, ...,\n",
-       "              2.2535410e+00, 2.2535410e+00, 2.2535410e+00],\n",
-       "             ...,\n",
-       "             [7.6389099e+01, 6.7769112e+01, 6.0128262e+01, ...,\n",
-       "              4.8120111e-01, 4.8120111e-01, 4.8120111e-01],\n",
-       "             [1.9799309e+01, 1.7551268e+01, 1.5562107e+01, ...,\n",
-       "              2.7208564e-01, 2.7208564e-01, 2.7208564e-01],\n",
-       "             [2.3525746e+00, 2.0999529e+00, 1.8758588e+00, ...,\n",
-       "              1.1430583e-01, 1.1430583e-01, 1.1430583e-01]],            dtype=float32)"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "losses_arr"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "smc_obj.update_twist(new_param_dct)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'A0': DeviceArray([[1.2154009]], dtype=float32),\n",
-       " 'b0': DeviceArray([0.00343322], dtype=float32),\n",
-       " 'A_params': DeviceArray([[0.        ],\n",
-       "              [1.1399895 ],\n",
-       "              [0.92457175],\n",
-       "              [0.7302874 ],\n",
-       "              [0.55107117],\n",
-       "              [0.39778167],\n",
-       "              [0.2689866 ],\n",
-       "              [0.1611653 ],\n",
-       "              [0.08117654],\n",
-       "              [0.02777491]], dtype=float32),\n",
-       " 'b_params': DeviceArray([[ 0.        ],\n",
-       "              [-0.00361299],\n",
-       "              [ 0.00066601],\n",
-       "              [ 0.00440207],\n",
-       "              [ 0.00042376],\n",
-       "              [-0.0009053 ],\n",
-       "              [-0.00059998],\n",
-       "              [-0.00200456],\n",
-       "              [-0.00045195],\n",
-       "              [ 0.00017573]], dtype=float32)}"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "new_param_dct"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray(2.3525746, dtype=float32)"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(twisted_logWs[-1]**2).sum()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "ok, can we twist this again?!, but for safety's sake, let's try to do it manually. but first, let's plot the twisted logWs"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cum_twist_logWs = jnp.cumsum(twisted_logWs, axis=0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "for i in range(1000):\n",
-    "    plt.plot(cum_twist_logWs[:,i])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "ok, now let's try to twist these...."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "start_A_twist_params = smc_obj.A_params_cache[0]\n",
-    "start_b_twist_params = smc_obj.b_params_cache[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "logK_int_twists = jnp.zeros(smc_obj.N)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "Vbar_ts = -twisted_logWs[9] - logK_int_twists"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 't' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-33-02030d44fefa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mVbar_ts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m: name 't' is not defined"
-     ]
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray(2.3525746, dtype=float32)"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(Vbar_ts**2).sum()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from jax import value_and_grad\n",
-    "def loss_t(params, Xps, Xcs, Vbars):\n",
-    "    As, bs = params\n",
-    "    return ((-smc_obj.vlog_psi_t_twist(Xps, Xcs, smc_obj.base_A_fn, smc_obj.base_b_fn, As, bs) - Vbars)**2).sum()\n",
-    "val_and_grad_loss = jit(value_and_grad(loss_t))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 1000/1000 [00:02<00:00, 384.48it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "start_params = (jnp.zeros(1), jnp.zeros(1))\n",
-    "lr=1e-6\n",
-    "import tqdm\n",
-    "losses = []\n",
-    "for epoch in tqdm.trange(1000):\n",
-    "    loss, grads = val_and_grad_loss(start_params, Xs[8], Xs[9], Vbar_ts)\n",
-    "    losses.append(loss)\n",
-    "    As, bs = start_params\n",
-    "    As = As - grads[0]*lr\n",
-    "    bs = bs - grads[1]*lr\n",
-    "    start_params = (As, bs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(DeviceArray([0.02768037], dtype=float32),\n",
-       " DeviceArray([-6.7175526e-05], dtype=float32))"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "start_params"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fd95e32e160>]"
-      ]
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(losses)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 158,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def new_potential(pos, parameter):\n",
-    "    mod_parameter = parameter[0]\n",
-    "    dim = pos.shape[0]\n",
-    "    x0 = jnp.ones(pos.shape)\n",
-    "    x1 = x0*1.5\n",
-    "    k0, k1 = 0.5 * jnp.diag(jnp.ones(dim)), 4.*jnp.diag(jnp.ones(dim))\n",
-    "    start_pot = 0.5*(1. - mod_parameter) * jnp.dot(jnp.dot(pos, k0), pos)\n",
-    "    end_pot = mod_parameter*((pos**4).sum() - 8*(pos**2).sum())\n",
-    "    return start_pot + end_pot"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 159,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vnew_potential = vmap(new_potential, in_axes=(0, None))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 160,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "energies = vnew_potential(supports[..., jnp.newaxis], jnp.array([0.]))\n",
-    "new_energies = vnew_potential(supports[..., jnp.newaxis], jnp.array([1.]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 182,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def make_gmm_potential(x, parameters):\n",
-    "    xpos = x[0]\n",
-    "    return -1.*jnp.log(0.3*jnp.exp(-0.5*(xpos+2)**2) \n",
-    "                   + 0.4*jnp.exp(-0.2*(xpos+1.)**2)\n",
-    "                   + 0.3*jnp.exp(-0.7*(xpos-4.)**2)\n",
-    "                   + jnp.exp(-1*(xpos-3.)**2)\n",
-    "                  )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 183,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vgmm = vmap(make_gmm_potential, in_axes=(0,None))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 184,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "nergies = vgmm(supports[..., jnp.newaxis], jnp.array([0.]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 185,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fac94c63080>]"
-      ]
-     },
-     "execution_count": 185,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3iVRfbA8e+kkwAJkAChJCGEHkILRRCkSFEQVCw0u4IN29rLb1fXrmt3V1m7NBFQUUGqSu+9JxDSCCQhkN7v/P54ExcjNfe99703OZ/n4QnchJmzWTx3Mu+ZOUprjRBCCPfjYXUAQgghqkcSuBBCuClJ4EII4aYkgQshhJuSBC6EEG7Ky5mTBQcH64iICGdOKYQQbm/Lli2ZWuuQqq87NYFHRESwefNmZ04phBBuTymVeKbXZQtFCCHclCRwIYRwU5LAhRDCTUkCF0IINyUJXAgh3NR5E7hS6jOlVLpSaneV16cqpQ4opfYopV53XIhCCCHO5EJW4F8AI05/QSk1CBgDxGitOwFvmh+aEEKIczlvAtdarwSyqrx8D/Cq1rq44mvSHRDbH1bHZfLv3+IdOYUQQjhEQUkZz/+4h8QT+aaPXd098LZAf6XUBqXU70qpnmf7QqXUZKXUZqXU5oyMjGpNtioug38tOUh6TlE1wxVCCGv8tDONz9ccIT232PSxq5vAvYAGQB/gMWCOUkqd6Qu11tO01rFa69iQkL+cBL0gN/ZsSblN8+2WlGqGK4QQ1pi1MYmoxnWJDW9g+tjVTeApwHxt2AjYgGDzwvqzyJC69IlsyOxNSdhs0kFICOEeDhzLZVvSKcb1bMlZ1rh2qW4C/x4YDKCUagv4AJlmBXUm43uFkZxVyNpDJxw5jRBCmGbWxiR8PD24tnsLh4x/IWWEs4B1QDulVIpS6g7gMyCyorRwNnCLdnBzzeGdmhLk782sjUmOnEYIIUxRVFrOd9tSGR7dlIYBPg6Z47y3EWqtx5/lU5NMjuWc/Lw9Gdu9BV+tO0JmXjHBdX2dOb0QQlyURbvTyC4sZXzPlg6bw61OYo7v1ZLScs08eZgphHBxszYmE97Inz6RjRw2h1sl8KjG9egZ0YDZm5Jx8I6NEEJU26GMPDYmZDGuZxgeHuY/vKzkVgkcYFzPMBIy81l/uOrZIiGEcA3fbErGy0NxXQ/HPLys5HYJfGRMKPX9vORhphDCJRWXlTN3SwqXd2hCSD3HPqtzuwTu5+3Jtd1b8MvuY5zML7E6HCGE+JOle4+TlV/CuF6Oe3hZye0SOMC4Xi0pKbcxb6s8zBRCuJbZG5NpHlSH/m2qd/L8YrhlAm/ftD7dwoLkYaYQwqUknShgdXwmN/ZsiacDH15WcssEDjC+Zxjx6XlsTjxpdShCCAHArE1JeCi4PtaxDy8ruW0CH9UllLq+8jBTCOEaisvKmbMpmcs7NCE0sI5T5nTbBO7v48WYrs34eWcapwrkYaYQwlq/7D7GifwSJvUJd9qcbpvAASb2Dqe4zMZcOZkphLDY9PWJhDfy59Ioh13M+hduncA7NqtPj/AGzNgg18wKIayz/1gOm46cZGJvx568rMqtEzjATX3CScjMZ80hh95mK4QQZzVjfRI+Xh5c38Pxtd+nc/sEfkVn46rGr9clWh2KEKIWyi8u47ttqYzqHEoDB10bezZun8B9vTy5sWdLlu07ztFThVaHI4SoZb7fnkpecRkTnfjwspLbJ3CACb3C0MBsKSkUQjiR1prp65PoGFqf7mFBTp//QjryfKaUSq/ovlP1c48qpbRSynmPXc+gZUN/BrVrzKxNyZSU2awMRQhRi2xNOsW+tBwm9Ql3SM/L87mQFfgXwIiqLyqlWgJDAZdY9t7UJ5yM3GKW7D1mdShCiFpixvpE6voaZ1KscN4ErrVeCZzp8u23gccBl6jfG9A2hJYN68jDTCGEU2Tll/DTzjSu7d6cAN/zdqd0iGrtgSulRgOpWusdF/C1k5VSm5VSmzMyMqoz3QXx9FBM7B3OhoQs4o7nOmweIYQA+HZzMiXlNqeevKzqohO4UsofeAb4vwv5eq31NK11rNY6NiTEsdcrXt+jBT6eHkxfL6twIYTj2GyamRuT6BXRkLZN6lkWR3VW4K2BVsAOpdQRoAWwVSnV1MzAqqNRXV9GxoQyb2sq+cVlVocjhKihVsZlkHiigIl9wiyN46ITuNZ6l9a6sdY6QmsdAaQA3bXWLvH0cFKfcPKKy/h+e6rVoQghaqgv1h4hpJ4vV0SHWhrHhZQRzgLWAe2UUilKqTscH1b1dQ8LomNofb5elyjNHoQQpkvIzOe3AxlM7B2Gj5e1R2kupAplvNY6VGvtrbVuobX+tMrnI7TWLnMRiVKKW/qGs/9YrnSuF0KY7su1R/D2VEzobe32CdSQk5hVjenanAb+3nyxNsHqUIQQNUhecRlzt6QwsnMojev5WR1OzUzgft6ejO8VxtK9x0nOKrA6HCFEDTFvSwp5xWXc2q+V1aEANTSBA38cbZWSQiGEGWw2zZdrj9ClZRBdWzr/3pMzqbEJvFlQHUZ0asqsjUkUlEhJoRDCPqviMzmcmc9tfSOsDuUPNTaBA9zaL4KcIuOuXiGEsMcXaxIIruvLlZ2tLR08XY1O4LHhDYhuXp8v1hyRkkIhRLUlZObzq4uUDp7OdSJxAKUUt/ZtRVx6HmsPnbA6HCGEm/pq3RG8PBQTXaB08HQ1OoEDjIoJpVGAD5+vkZJCIcTFyysuY+7mFEbGhNK4vvWlg6er8Qncz9uTCb3DWL4/ncQT+VaHI4RwM/O3ppBbXMYtLvTwslKNT+BglBR6KsVXcle4EOIi/FE62CKQbi5SOni6WpHAm9T348rOoczZlCy3FAohLtjvcRkcysjn1n4RlrRMO59akcDBKCnMLS5j3tYUq0MRQriJT1Ydpml9P0Z2tqZl2vnUmgTerWUQXVoG8dnqBMptUlIohDi3vUdzWBN/glv6RthXOliSD2vfh2zzz6PUmgSulOKu/q04cqKAZfuOWx2OEMLFfbo6gTrenkzoZWfpYMIqWPIsZB40J7DT1JoEDjCiU1OaB9Xhk1WHrQ5FCOHC0nOKWLAjlRtiWxDo723fYPHLwNsfwvuaE9xpLqShw2dKqXSl1O7TXntDKbVfKbVTKfWdUsr1Hs+egZenB7df2opNR06yPfmU1eEIIVzUV+sSKbNpbjPj1sH4ZdBqAHj52j9WFReyAv8CGFHltaVAtNY6BjgIPGVyXA5zY8+W1PPz4r+yChdCnEFhSTnTNyQyrGMTIoID7BvsxCE4mQBRl5sTXBUX0pFnJZBV5bUlWuvKerz1GI2N3UJdXy8m9Apj0a40uStcCPEX87amcKqglDv7R9o/WPxy42PUEPvHOgMz9sBvBxad7ZNKqclKqc1Kqc0ZGRkmTGe/W/tF4KEUn685YnUoQggXYrNpPludQJcWgcSGN7B/wPhl0DDS+OUAdiVwpdQzQBkw42xfo7WeprWO1VrHhoSE2DOdaUID6zAqJpRvNiWRXVhqdThCCBfx64F0Dmfmc0f/SPsP7pQWwZFVDts+ATsSuFLqFmAUMFG74V2td/aPJL+knNkbk6wORQjhIj5ZlUCzQD+uiG5q/2CJq6G0AKKG2j/WWVQrgSulRgBPAKO11m65kRzdPJBLIhvxxdojlJbbrA5HCGGx3anZrDt8glv7ReDtacLu8sEl4FUHWvW3f6yzuJAywlnAOqCdUipFKXUH8AFQD1iqlNqulPrIYRE60F0DWpGWXcTPO9OsDkUIYbFpKw8T4OPJOHsP7gBoDXGLjfJB7zr2j3cWXuePQ48/w8ufOiAWpxvYtjGtQwL476rDjOnazCUvqxFCOF5yVgE/7TzKnf0jqe9n58EdgMw4OHkE+k61f6xzqFUnMavy8FDc2T+SPUdzWCcde4Sotf676jCeHorbzTi4A8bqG6DNcHPGO4tancABrunWnOC6vvzn90NWhyKEsMCJvGLmbE7mmm7NaRpoUsedg4uhcUcIamnOeGdR6xO4n7cnt18awaq4THanZlsdjhDCyb5ce4TiMhuTB7Q2Z8CibEhaB22GmTPeOdT6BA5Gx556vl6yCheilskvLuPLdYkM7dCEqMZ1zRn00AqwlUFbx26fgCRwAOr7eTPpknAW7UojIVP6ZgpRW8zelEx2YSl3DzRp9Q1G+aBfELToZd6YZyEJvMJt/SLw8vRg2kpZhQtRG5SU2fhk1WF6tWpI9zATjs0D2GwQv9S4+8TzvEV+dpMEXqFxPT+u79GCeVtSOZ5TZHU4QggHW7DjKGnZRdxzmYmr76PbID8D2la9wNUxJIGfZsqA1pTZbHy2OsHqUIQQDmSzaT7+/RDtm9ZjYDsT72iKWwzKw6H3n5zOfRJ4WbHDpwhr5M+omGZMX59IdoFcciVETbVifzpx6XlMucyES6tOd3AxtOgJ/g3NG/Mc3COBr3gRPh0KtnKHT3X3Za3JLynn6/VHHD6XEML5tNZ89PshmgfVYVSMid3mc9IgbbtTygcruUcCD2kPaTtg+0yHT9WxWX0GtQvh8zVHKCxx/BuGEMK5NiRksTnxJHf1b2XOpVWVDiw0PrYfad6Y5+EeCTx6rFGSs/wFKM51+HT3DIziRH4J325JdvhcQgjn+mBFPMF1fc25tOp0BxZCg1bGgtNJ3COBKwUjXoH8dFj9tsOn6xnRgB7hDfj498Ny1awQNcjWpJOsjs9k8oBW+Hl7mjdwcS4krDRW3068FM89EjhAi1jofAOs/QBOObYJg1KK+wdHkXqqkO+2pjp0LiGE83ywIp4G/t5M7B1u7sDxy6C8xKnbJ+BOCRzg8r8bJTrL/uHwqQa2DSGmRSAf/BpPmazChXB7u1OzWbE/nTsubUWAr8mHbPb/DP6NoGVvc8c9jwtp6PCZUipdKbX7tNcaKqWWKqXiKj6adIzpPAJbGPfr7p4HSRscOpVSiqmD25CUVcAP2486dC4hhON9sCKeen5e3Nw3wtyBy0shbolxeMfDxG2ZC3AhK/AvgKrHip4Elmut2wDLK/7sHP0ehHqhsPgp49iqA13eoTEdQuvz4a/xlNvcru2nEKLCweO5/LLnGLf1jTCnYcPpEtcYNxA6efsELiCBa61XAllVXh4DfFnx+y+Bq02O6+x868KQ/4PULbB7rkOnUkrxwOAoDmfm89NOWYUL4a4+WBFPgI8nt5nVsOF0+382el9GDjJ/7POo7h54E611GkDFx8bmhXQBYsZBaFdjL7zEsT2Vh3dqStsmdflgRTw2WYUL4XYOZ+Tx086jTLoknAYBPuYOrjXsXwitB4GPv7ljXwCHP8RUSk1WSm1WSm3OyMgwZ1APD6OsMCcV1r5nzphnncrYC49Lz+OXPcccOpcQwnz//u0Q3p4e3HlppPmDH9sJOSnQ7krzx74A1U3gx5VSoQAVH9PP9oVa62la61itdWxIiImXxoT3hY5Xw+p3HF5WeGXnUCJDAnhveZyswoVwI8lZBXy3LZXxvcIIqedr/gT7fzYq49pdYf7YF6C6CXwBcEvF728BfjAnnIs07EWjaH7xMw6dxtNDMXVwFPuP5bJ033GHziWEMM+/f4vHUymmXOaA1TcY2ycte0NAsGPGP48LKSOcBawD2imlUpRSdwCvAkOVUnHA0Io/O19QS+j/N9i3wGhj5EBXxTQjopE/76+IQ2tZhQvh6pJOFPDt5hTG92pJaGAd8yfIOgzHd1lSfVLpQqpQxmutQ7XW3lrrFlrrT7XWJ7TWQ7TWbSo+Vq1ScZ6+U6FhJCx6AspKHDaNl6cH9w6KYndqDsv3nXXHSAjhIt5bEYenh+LeQVGOmWDvAuNjh9GOGf8CuNdJzDPx8oURr0HmQdjwkUOnuqZbc8Ia+vP2soOyFy6EC0vIzGf+1hQm9QmnSX0/x0yy9wdo1h0amHws/yK4fwIHaDsM2l4Bv79m3MnrIN6eHjx0eRv2HM1hsVSkCOGy3lseh6+XJ3eb2S7tdKeS4OhW6DjGMeNfoJqRwAFGvGwcaV36fw6dZkzX5rQOCeDtZQfldKYQLig+PZfvt6dyc99wx1SewP+2Tzpat30CNSmBN4w0jtnvmgNH1jhsGk8PxSND23HweJ6czhTCBb2zLA5/b0+mDHDQ6huM7ZOmMUbesVDNSeAAlz4MgS1h0eNQXuawaa6Ibkr7pvV4e+lBualQCBey/1gOP+9K49Z+ETQ0+9RlpexUSNlo+fYJ1LQE7uMPw1+G47th0ycOm8bDQ/G3Ye04cqKA+XJfuBAu491lcdT18eKu/g5cGe/70fjY0XlXQJ1NzUrgAB2ugtZDjEbIOY7b4ri8Q2O6tAjk3eVxlJTJKlwIq+05ms2i3ce4/dJWBPk7aPUNxvZJ404Q7KDyxItQ8xK4UjDyTbCVwi+Ou+VWKWMVnnqqkG82S+9MIaz29tI46vt5cUd/B9w4WCn3GCStc4ntE6iJCRyMBwsDHjPeKQ8udtg0/dsE0zOiAR+siKOoVDrYC2GVLYknWbbvOJMHRJp/3/fp9v0IaEngDtf3AaM79M+PQkm+Q6aoXIUfzylmxgbHXqglhDgzrTWv/bKf4Lq+3H6pA1ffYCwKQ9pDY+d1nj+XmpvAvXxg1NuQnWQc8HGQPpGNuDQqmA9/jSe3qNRh8wghzuy3AxlsTMjiwSFR+PuY3OvydLnHjO47LrL6hpqcwMG4crbbJFj3IRzf47BpHhvejqz8Ev67KsFhcwgh/spmM1bf4Y38GdcrzLGT7fkOtA2ir3PsPBehZidwgKH/BL9A+PEhh/XQ7NIyiJExoXyy6jDpuUUOmUMI8VcLdhxl/7FcHhnaFm9PB6ezXXONwzshbR07z0Wo+QncvyEMe8kovN/65fm/vpoeHdaOkjIb7y+Pd9gcQoj/KSmz8a+lB+jUrD5XxTRz7GRZhyF1M3R2ndU31IYEDtBlHET0h2V/h1zHNGRoFRzA+F5hzNqYREKmYx6aCiH+Z9bGJJKzCnl8RHs8PJRjJ9s9z/jY6VrHznORakcCV8p4oFlaCIsec9g0U4dE4ePlwZtLDjhsDiEE5BeX8f6KOPpENmRAGwd3w9Ha2D4J62s0kXEhdiVwpdTDSqk9SqndSqlZSikHXbxrguA2cNkTRhlQ5U1iJmtcz487+0fy8840diSfcsgcQgj4ZFUCmXklPDGiPUo5ePV9fA9k7IfOYx07TzVUO4ErpZoDDwCxWutowBMYZ1ZgDtHvQWjaGRY+CoUnHTLFXf1b0SjAh1cX7ZfWa0I4QGZeMf9ddZjhnZrQLayB4yfcPReUp0vcfVKVvVsoXkAdpZQX4A+49v2qnt4w5kPIz3RYI+R6ft5MHRzFusMnWBmX6ZA5hKjN3ll2kMLSch4b7oTDNFrDrnnQerBljYvPpdoJXGudCrwJJAFpQLbWeknVr1NKTVZKbVZKbc7IyKh+pGYJ7QKXPgTbZ0D8ModMMaF3OC0b1uHVRful6YMQJopPz2XWxmQm9g4jqnFdx0+YvNE4DOhi1SeV7NlCaQCMAVoBzYAApdSkql+ntZ6mtY7VWseGhIRUP1IzDXgcgtsateHFuaYP7+PlwWPD27MvLYd5W1NMH1+I2urlhfvx9/HkwSFtnDPhrm/By8/SzvPnYs8WyuVAgtY6Q2tdCswH+poTloN5+8HoDyA7BZa/4JAprooJpVtYEG8sPkB+seOaSwhRW6yOy2TF/nTuHxRFo7oOapV2urJiY/+7/Ujwref4+arBngSeBPRRSvkr4zHwEGCfOWE5QVhv6D0FNk6DxHWmD6+U4rlRHcnILeaj3w+ZPr4QtUm5TfPiz3tp0aAOt/SNcM6kB38xih26THDOfNVgzx74BmAusBXYVTHWNJPico7Bz0FQGCy436gRN1n3sAaM7tKMaSsPk3rK/PGFqC3mbUlh/7FcnhjRHj9vT+dMun0W1G0KrQc5Z75qsKsKRWv9d611e611tNb6Jq11sVmBOYVvXRj9PpyId9hWyhNXGE/KX/9lv0PGF6Kmyy8u440lB+gWFsSomFDnTJqXAfFLIeYG8HDSG0Y11I6TmOcSORB6TYb1/4aEVaYP3zyoDnf1j+SH7UfZluSY2nMharKPVx4mI7eYZ0d2dPyhnUq7vgVbGXR13e0TkARuuPx5aNgavr8XinJMH/6ega0JqefLP3/aK4d7hLgIx7KLmLbyECNjQukR7oRDO5V2zITQrtC4g/PmrAZJ4GB0s7/mY8hJgcVPmT58gK8Xjw1rx9akU/y4M8308YWoqV5ZtA+bhidHOLEDzrFdxq+uE503ZzVJAq/Usif0ewi2TYcDi0wffmyPFnQMrc9ri/ZL/0whLsDGhCx+2H6UKQMiadnQ33kTb58FHt4ue3jndJLATzfwSWgSDQsegPwTpg7t6WGUFaaeKpSyQiHOo9ym+fuCPTQL9OPegVFOnLgUds2BtsONXgIuThL46bx8ja2UwpPw8yPGPQgmuqR1I0bFhPKf3w6RnFVg6thC1CQzNyaxLy2HZ0Z2pI6PE6tA4pZCfobLP7ysJAm8qqbRMOgp2Pv9/y5xN9EzIzvg6aF44ae9po8tRE1wMr+Efy05wCWRjbiyc1PnTr71S6jbBNoMc+681SQJ/Ez6Pggtehqr8FPJpg4dGliHqYPbsHTvcX49kG7q2ELUBP9aeoDcojL+MbqT88oGAbJTIW6J0Qjd09t589pBEviZeHoZWym2cvhuivHRRHdc2orI4ACeX7CH4jJ5oClEpT1Hs5m5IYmb+oTTrqmT7x/ZNt3oOt/tJufOawdJ4GfTqDVc+QYkroHVb5s6tI+XB/8Y3YkjJwr4ZFWCqWML4a601jy/YC9B/j48PNTJnd9t5bD1K4gcBA1bOXduO0gCP5cu4yF6LPz6MqRsNnXoAW1DGNGpKe+viJN7UoQAfth+lI1Hsnh8eDsC6zh5C+PQCuMcSI9bnTuvnSSBn4tSMPItqN8c5t1h+t3hz44yTnm99LM80BS1W3ZBKS/+vJcuLYO4IdaCxsFbvgD/YGh3pfPntoMk8POpEwTXToNTSbDwcVOHbtHAn/sGRrFw1zFWxblAtyIhLPL64v1k5Zfw8jXReHg48cElQO4x4/Bet4ng5ePcue0kCfxChF8CAx4z7kcwubTwrgGRtAoO4Nnvd8sJTVErbU06ycyNSdzWrxWdmgU6P4Bt00GXQ/dbnD+3nSSBX6gBj0OLXvDjw8Zq3CR+3p68dHU0iScKeH9FnGnjCuEOysptPD1/F03r+zn/wSX87+FlRH+jcMHN2JXAlVJBSqm5Sqn9Sql9SqlLzArM5Xh6wdj/Ahrm3WkcuTVJ36hgxnZvwce/H+bgcfN7dArhqj5fc4T9x3L5+1WdqOvr5fwA4pbAqUToeYfz5zaBvSvwd4FftNbtgS64U0u16mgQAVe9C8kbYMWLpg79zMgO1PPz4qn5u7BJJ3tRC6SeKuTtZQcZ0r4xwzs1sSaIjdOgXjNoP8qa+e1kT1f6+sAA4FMArXWJ1vqUWYG5rOhrIfZ2WPMOHFxi2rANA3x4ZmRHtiSeZPYmc09/CuGK/rFgD1rD82OcfOKyUmacUT7Y83a3OXlZlT0r8EggA/hcKbVNKfWJUirApLhc2/BXoEln45Rmdoppw47t3pxLIhvxyqJ9pOcWmTauEK5m8Z5jLN17nAcvb0OLBk68KvZ0G6eBpw90v9Wa+U1gTwL3AroD/9FadwPygSerfpFSarJSarNSanNGRg0plfP2gxu+hPISmHu7afvhSileuiaa4jIbL/woteGiZsouKOXZ73fTMbQ+d1xq0anHohzYPhM6XQt1Q6yJwQT2JPAUIKWiOz0YHeq7V/0irfU0rXWs1jo2JMR9v1F/0ai1Q/bDI0Pqcv+gKH7amcbyfcdNG1cIV/Hiz3vJyi/h9eti8Pa0qBBux2woyYPek62Z3yTV/u5prY8ByUqpdhUvDQFq17Kx83XQ4zbT98Pvvqw17ZvW4+nvdpFdaF61ixBWW3kwg2+3pDBlQCTRzS2o+Qaw2Yztk+ax0LyHNTGYxN63v6nADKXUTqAr8LL9IbmZEa8YXXy+m2JcR2kCHy8P3riuC5l5JXLMXtQYecVlPDV/F61DAnhgSBvrAjm8Ak7EQS/3Xn2DnQlca729YnskRmt9tdb6pFmBuQ3vOnD9FxX74bdBWYkpw3ZuEciUAZHM2ZzCb3JvuKgBXv9lP0ezC3n9uhj8vJ3YZaeqte9DvVDodI11MZhETmKaIbgNjH7P2A9f8qxpwz4wpA1Rjevy1Pxd5BTJVopwXxsTsvhqXSK3XBJBj3ALe02m7YDDv0Hvu93u3pMzkQRuluix0Oc+2Pgx7JxjypB+3p68cV0Mx3OKeGVhzT4jJWquotJynpi3kxYN6vDY8Hbn/wuOtPYD8KkHsbdZG4dJJIGbaejzENbX6Gp/bLcpQ3YLa8Bd/SOZtTGZ1XGZpowphDO99st+EjLzeW1sDAFWHJevdCrZuIyuxy3gZ9EDVJNJAjeTp7exH+4XCHNugkJzDqY+PLQtkcEBPDFvJ7mylSLcyNr4TD5fc4RbLgmnX1SwtcFs+Mi447/PPdbGYSJJ4Gar18Q45HMqCb672yhZspOftydvXN+FtOxCnpcDPsJNZBeW8ui3O4gMDuDJKzpYG0zhKaNpQ6drIbCFtbGYSBK4I4T1geEvw8FFsPotU4bsEd6AewdGMXdLCot2pZkyphCO9PyPezieW8xbN3aljo+FVScAWz43Du70nWptHCaTBO4ovSZD5+uNU5rxy00Z8sHL29C5eSBPfbeL4zlyV4pwXb/sTmP+1lTuGxRF15ZB1gZTUgDrPoTWgyE0xtpYTCYJ3FGUMo7aN+5o3B9uQhMIb08P3r6xK0Wl5Tw2dyday7WzwvWk5xbx1PxddG4eyNTBUVaHY2yd5GcYTVlqGEngjuQTADd+bXT9mD0BSvLtHjKqcV2eubIDKw9m8NW6RBOCFMI8WmuemreLgpJy3r6xi3V3nVQqLYI17xodd8JrXr8ZSeCO1qg1XPepUVb4/b1gwqp5Up9wBrYL4eWF+4hPlw4+wnV8vT6R5fvTeWJEe6Ia17M6HNj2NeQdM3ra1nPCWX8AABxYSURBVECSwJ2hzVCjRnzv97DqTbuHU0rx+tgY/H08eeib7RSXSTNkYb29R3N48ed9DGoXwm39IqwOx7jWYvU70LIPtBpgdTQOIQncWfo+ADE3Gg819y+0e7jG9f14dWwMu1NzeG3RARMCFKL6CkrKmDprK4F1vHnj+i7WdNipasdMyEmByx4znknVQJLAnaXyoWazbjD/Lki3/2j88E5NubVvBJ+tSWDpXrk7XFjn+QV7OZyZzzs3diW4rq/V4Rir71VvQbPu0HqI1dE4jCRwZ/KuAzfOAG9/mDUeCrLsHvKpK9sT3bw+j367g9RThSYEKcTF+XHHUb7ZnMw9l7W2/rRlpa1fGt3mBz1dY1ffIAnc+QKbw7gZkJNqXD9bXmbXcL5ennwwvjvlNs0Ds7ZRWm7/yU8hLlRyVgFPz99Ft7AgHh7a1upwDCX5sPIN416iqMutjsahJIFboWUvGPW2ca2lCdfPRgQH8PK1ndmSeJK3lh60Pz4hLkBxWTn3z9wKCt4b1836ksFKGz6GvONw+d9r9OobTEjgSinPiq70P5kRUK3RbRL0vgc2/Ae2fmX3cKO7NGN8rzD+89shfj9YQ5pHC5f2wo972ZGSzZvXd6FlQ4s6y1dVeNJocdhmuHGlRQ1nxlvmg4BcVl0dw16EyEHw08OQsNLu4f5+VUfaN63HQ7O3kXKywIQAhTizeVtSmLEhiSmXRTK8U1Orw/mfNe9BUTYMec7qSJzCrgSulGoBjAQ+MSecWsbTy7h+tlEUfDMJMuPsGs7P25N/T+xOWbnmnulbKSqV+nBhvn1pOTzz/S76RDbksWEWN2g4Xc5R48rY6OugaWero3EKe1fg7wCPA2d9cqaUmqyU2qyU2pyRIT/a/0WdIJjwDXh4w4zrIf+EXcNFhtTlrRu7sis1m+e+3y33pQhT5RSVcs/0LdT38+b98d3xcpV9b4DlL4CtrNasvsGOBK6UGgWka623nOvrtNbTKhofx4aEhFR3upqtQQSMn2WsIL6ZCGXFdg03tGMTHhgcxbdbUpi50f5LtIQA456TR+fsIOVkIf+e2J2Qei5Q710pdQvsmAWX3Gf891RL2PP22Q8YrZQ6AswGBiulppsSVW3Ushdc8x9IWgcLptp9Z8qDl7dlYLsQ/rFgD1sST5oUpKjNPlgRz5K9x3nyivbERljYmLgqreGXpyGgMVz6iNXROFW1E7jW+imtdQutdQQwDlihtZ5kWmS1UfRYGPQs7PzGqGO1g6eH4p0buxIaWId7Z2whPVfuDxfV98vuY/xr6UGu7dacOy5tZXU4f7bnO0heD4OfBb/6VkfjVC60gSUAGPAoxIyDX1+CXXPtGirI34ePJvUgu7CUKV9vkYeaolr2peXwyJztdGkZxMvXdnaNe04qlRTA0r9Dk85GaW4tY0oC11r/prUeZcZYtZ5SMPo9CLvEuH42ca1dw3VsVp93buzKtqRTPC5NIMRFOpFXzJ1fbqaenxf/vakHft4Wt0aratWbkJ0EV7wKHi4WmxPICtwVefnCuJkQFAazxkH6fruGGxEdymPD27Fgx1HeXxFvUpCipisps3HP9K1k5hUz7aZYGtf3szqkP8s4YNR9dxkPEZdaHY0lJIG7Kv+GMGkeePnB9LGQnWrXcPcObM213Zrz1tKD/LTzqElBippKa83//bCbjUeyeP26GLpY3deyKq3hp0eMrldD/2l1NJaRBO7KGoTDxLnGybIZ10HhqWoPpZTilbGdiQ1vwN/m7GB7cvXHEjXfv387xOxNydw3qDVjuja3Opy/2jEbElcbjVLq1t7yZEngri40BsZNN05pzravRtzXy5OPb+pBSD1f7vpqM8lZctxe/NV321J4Y/EBxnRtxt+GutBJy0r5J4xL4Fr0gm43Wx2NpSSBu4PIgXD1f4wVx3dTwFb9K2Mb1fXl81t7Ulxazi2fbSQrv8S0MIX7WxufyeNzd9InsiGvXxeDh4cLVZxUWvSY8VPpVe+AR+1OYbX7f707ibne2Ovb8x0sftqugz5tmtTj01t7knqqkNu/2ERBiX13kouaYf+xHKZ8vYVWwQF8fFMsvl4uWNWx9wfYPQ8uewKadLI6GstJAncnfadCn3uNK2jtbI7cM6Ih743vxs6UU9w3Y6s0gqjl0rILue3zTfj7evL5bb0IrONtdUh/lZ9pPLgM7QKXPmR1NC5BErg7UQqGvWQc9FnxIqz/yK7hhndqyj+vjubXAxk8890uqRGvpU7kFTPpkw3kFpXx2a09aR5Ux+qQzmzho8bWydUfgacLvsFYwMvqAMRF8vCAMR9CSR788oRRRtX9pmoPN7F3OOk5xby7PI6GAb48MaKda520Ew6VU1TKzZ9tJOVkIV/d3otOzQKtDunMdnxjbB8Ofg6adLQ6GpchCdwdeXrBdZ8ZjZF/fMBI4tHXVnu4hy5vw4n8Yj76/RD+Pp48MKSNicEKV1VYUs4dX2zi4PFcpt0cS+/IRlaHdGYnDsHPjxg9LvvJ1snpJIG7Ky9fuHG6cchn/l1GEm87vFpDKaV4YXQ0hSU23lp6ED9vDyYPaG1ywMKVFJeVM2X6FrYknuT98d0Z1K6x1SGdWVkJzLsDPLxg7H+NxYv4g+yBuzMff5gwG5pEwzc3GU2Sq8nDQ/H6dTGMignl5YX7+WrdEbOiFC6mpMzG1JnbWHkwg1evjWFkTKjVIZ3dihfg6DYY8wEEtrA6GpcjCdzd+QXCTd8Zbdlm3gjxy6s9lKeH4u0buzKsYxP+74c9zJZmEDVOSZmN+2ZuZcne4/zjqo7c0LOl1SGd3YFFsPZ9iL0DOlxldTQuSRJ4TeDfEG750Ujis8ZD3LJqD+Xt6cH7E7oxsF0IT87fxfT1iSYGKqxUXFbOvTO2sHTvcV4Y04lb+7nYvd6ny4yH+ZONksHhL1kdjcuSBF5TBDQyknhIW5g9Hg4uqfZQvl6efDSpB5d3aMyz3+/m09UJJgYqrFBUWs4907eybF86/7w6mpsvibA6pLMrzjVaC3p6G895vF20rNEF2NMTs6VS6lel1D6l1B6l1INmBiaqwb8h3LwAGnc0/gM4sKjaQxkd7ntwZeem/POnvXz4q1xD664KS8qZ8vUWVuxP56VrormpT7jVIZ2d1sY9+JkH4brPjSuVxVnZswIvA/6mte4A9AHuU0pJgabV/BvCzd9XPNicZFdXHx8vD94b141rujXnjcUH+NeSA3LYx81kF5Qy6dMNrIrL4NVrOzOxtwsnb4DfXoF9C+Dy5yHyMqujcXnVrsnRWqcBaRW/z1VK7QOaA3tNik1UV50GRhKfNcEowcrPhD53V2soL08P3ry+C75eHry/Ip6TBSU8PzoaT1e85Ej8yfGcIm7+dCMJmfl8OKE7V3R24WoTgG0z4PfXjNZofadaHY1bMKWoUikVAXQDNpzhc5OByQBhYfLjkNP4BRoNIebdYZzYLMiEQc8Yx/EvkqeH4pVrOxs9Nn8/RHpOMe+N7+Z67bXEH45k5nPTZxvIyivh89t60i8q2OqQzu3wb8ahtMiBMOqdav07rY3sfoiplKoLzAMe0lrnVP281nqa1jpWax0bElJ7L163hLcfXP8ldL/Z6HL/00Ngq15jY6UUT17Rnn9c1ZGl+44z8ZMNnCqQq2hd0fbkU1z30Tryi8uZeVcf10/e6fuMcwzBbeGGr+Sek4tgVwJXSnljJO8ZWuv55oQkTOXpBVe9B/3/Blu+MGrFi/7yPnvBbu3Xig8ndGdXSjZj/7NWmkK4mIW70rjx43X4eXswZ8olrtcKraqsBPj6GvD2hwlzjJ8cxQWzpwpFAZ8C+7TWb5kXkjCdUjDk/2DU23D4V/h0qPEfTjVd2TmUr+7oRUZuMWM+XMP6wydMDFZUh9aaD3+N594ZW4luHsgP9/UjqnFdq8M6t5yj8NVoKCsyDqMFufChIhelqltVoJS6FFgF7AIqL5N+Wmu98Gx/JzY2Vm/evLla8wmTHP4d5twMHp5GjW143+oPlZHHnV9tJulEAS+MiWZC71r+jENrOJlg7Oce3Q4n4iv6mGqo1xSadobWQyCiv6mdZIrLynl6/m7mbU3h6q7NeHVsjOs/n8jLgC+uhJw0uGUBNO9udUQuTSm1RWsd+5fXnVkWJgncRZw4BDNvgJOJMOIV6HlntR8a5RSV8sCsbfx2IIObLwnnuVEd8fasZefD8jNh+0zY+hWciDNeq9PQ2NMNCDYSe04qHN8DtlJoGGncqtdtkvFGaoejpwq5Z8ZWdiSf4pGhbZk6OMr1rwMuPAlfXmWctrxpvl2LiNpCErj4s8KTMH8KxC2GTtcY++R+9as1VLlN8/ov+/l45WF6VXT6aRroZ3LALsZmgyMrjecK+34yEnPYJRA9FiIHQaPWf31TLMk3Dlet/zekboHQrnDNx9C4fbVCWB2XyQOzt1FSZuPN62MYEe3iZYJgNCT+egxkHIBxs6DN5VZH5BYkgYu/stlg7Xuw/AVoEAE3fGn8mF9NP2xP5an5u6jj7cnbN3ZlQNsaWHWUlw7bZ8CWL43tEr8g6DoBut9y4YlYa6Ov46InoLQARv7LGOMC2Wya//x+iH8tOUBU47r8Z1IPWoe4+H43GN+7L0cb37dxMyBKkveFkgQuzu7IGph7OxRmweBn4ZL7q/2jfXx6HvfN2MrB9FzuHxTFg0Pa4OXuWyo2GyT8Zqy29/8MtjII7wc9boUOo41yzerIPQbz7oQjq+DSh2Hw/513bzw9p4i/fbuDVXGZjOnajFeu7Yy/jxvckZ1z1EjeOakw4RtoNcDqiNyKJHBxbvmZRp34vh+hZR+4+t/GNkA1FJaU8/cFu5mzOYXY8Ab864YuhDcKMDlgJ8g99r/V9qlE44Rr14nGajukrTlzlJcZvR63fA6dbzC+72epg16y5xhPzNtJYWk5z43qyIReYa6/3w0VpYJXG9snk+ZCWB+rI3I7ksDF+WkNO+fAwseMPd3LnoA+94KXT7WG+35bKs/9sJtym+bpKzswsbcbJJzyMohfajyQPLgYdLlRNdLjVmg/qvqr7XPRGlb9C1b805jjus//9D3PLy7jpYX7mLkhiU7N6vPuuG6uXyJY6eh2mHG98e9p4jxo0cPqiNySJHBx4bJTjVXhgYUQ3A5GvlntH3mPnirk8bk7WR2fyYC2Ibw2tjOhgS54PWjWYdg23biPI+8YBDQ29qW73QTBUc6JYf1HxrUH7UbC9V+Alw+/H8zg6fm7OJpdyOQBkfxtaDt8vNxkS+rQCuOEZZ0GMGm+eT+11EKSwMXFO/ALLHrc2D7oMNroCF6N/whtNs30DYm8vHAfnkrxyLB23HJJuPV743kZsPd72PUtJG8A5QFthhlJu+1wa450b/wvLHyUktbDecbrUb7dkUFkSACvjY2hZ0RD58dTXTvnwPf3QEh7mDgX6rtBhYwLkwQuqqe0ENa8a7S2Ki0wVqWXPVmtU3NJJwp47ofd/H4wg46h9Xn52s50dfZR76Ic40Hkrm+NAze6HBp3gs5joct4qN/MufFUYbNpts1/kx67X+RXW1d29H2fu4d0cv2DOZW0htVvGZVNEf2NahM5Hm83SeDCPvmZxj7tpk9A24x65z73QrOuFzWM1ppFu4/x/I97SM8t5oYeLXlkWFua1Hdg3XjuMWM7aP9CSPgdyksgKBw6XwfR10ET17jGftORLJ7/cQ+7U3N4ImQd9+S+b5TauUtXmtIiWDAVds0xvq9X/xu8fK2OqkaQBC7MkZ0C6z40HvKV5EH4pRUP+EaCj/8FD5NbVMo7y+L4at0RvDw8uKt/KyZf1pq6viaUxNnK4dhOo8HzgYXGoRkwat3bjTQOLrWIdZkrSxNP5PPmkoP8uOMoTev78dSV7RndpRlq23QjIUYOhHEzL+r763S5x2D2BON7Pfg54/I0F/n+1gSSwIW5irKNJL5hGmQngU896DTG2CtvNeCCV4xJJwp4ffF+ftqZRnBdX+4d2JrxvcKo43MRWwZaGw8hD/9m/EpYCUWnjM816w7trzQSd+MOLpVUUk4W8P7yeOZuTcHLQzFlQCR3D2z957ru7TONFmOt+sP42eDjguWYKVuM7k9F2XDtx9JB3gEkgQvHsNkgcQ3smAV7fzBW5d7+xqox4lJo2Ruaxpy3FHFb0kle+2U/6w9nEVzXhzv7RzKpT/hfV+RaQ24aHN8LqZshZbOx6ivMMj5fv4Uxd+RA442kXhPT/yfbK+lEAdNWHeKbTckoFBN6h3HvwNY0Pts20s458N0U46j+hG/At55zAz4brWHDx7DkWagXCuNn2nWSV5ydJHDheKVFkLjaqJ+OWwInjxive/oa1SvB7YwLngKbQ0CI8csvEDx9jIoP5cn2hDS+WbOfvYlphPkWMLKVpm9ICfVL0o37MzIPQnHlfebKqHJoEWv8iuhvXBTlQqvsSlprtiSe5JNVCSzeewwvD8UNsS25f3DUhZVV7p4H8+6CJp2Me7Otruooyja2d/b+AG2vMPa7/d2oSsbNSAIXzpeTBikbIXkjZOw3ku+pZODi/s3ZtCLHqyE6uA2BYZ3xCGlnJO7QLtW+gMtZsgtLWbDjKHM2JbMrNZvAOt5M6hPGzZdEXPyD27ilMOcWo6564hwjmVshaYPxE8GpJLj8H0b/Shd806xJJIEL11BaCHnHjRrs/HSjrM9WCuWlRnWLdx1jC8bbHwJCSNNBzNhTyKxNaZzIL6FxPV/GdG3G1d2a0zG0vkue7CwuK2ftoRP8sC2VRbuPUVxmo33TekzsHcbYHi3su7skbYfRVak4D67+EDqOMS/w8yktgl9fgnUfQGALuGYahF/ivPlrMUngwq0Vl5WzbG86329P5bcD6ZSWayKDAxjcvjGDOzSmZ0RDS+8hzy4sZW18Jov3HGP5vnRyi8uo5+fF1V2bc0NsS6Kbm/hmk51iNOVI3QK9psCwfzq+XC9hJfz8KGQeMKqOhr3oOnvxtYBDErhSagTwLuAJfKK1fvVcXy8JXJjhZH4JP+9KY8ne46w/dIKSchv1fL3o2aohsREN6BnRkM7NAx16+CUjt5jdqdlsSMhi3aFMdqVmY9PQwN+bYR2bMiK6KX2jGuHr5aAYykpg+fPGajikvXGfe1hv8+c5lWw8pNz7PQSFwci35Q5vC5iewJVSnsBBYCiQAmwCxmut957t70gCF2bLLy5jTXwmvx7IYNORLOLT8wDw8lC0Cg6gXdN6tGtSj4jgAJoF+dE0sA6N6/med7WutSa/pJysvBKSTxaQeKKAxKx8DqXnsTs1h2M5RX/M0y0siL6tg+kXFUz3sCDnXhFwcAn89LBxTWu3idU+JfsX2Smw+m2jVFR5wKWPQL8H3ONAUQ3kiAR+CfAPrfXwij8/BaC1fuVsf0cSuHC0rPwStiSeZFvSSQ4ez+Pg8VySsgr+9DVKgb+3JwG+XtT19cLX2xObTVOuNTabJq+4jFMFpZSU2/7097w9FeGNAohuVp/o5oFENw+kc/NAAsw4fGSP4jz47RXYOM34c9eJEHs7hMZc3Dg2m3FSdetXxrXCYLwp9H9UGg5bzBEJ/DpghNb6zoo/3wT01lrfX+XrJgOTAcLCwnokJiZWaz4hqiu/uIyUk4WkZRdyLLuItOwicovKKCgpI6+4jKJSG14eCk8PhYeHIsDHkyB/Hxr4e9PA34cWDeoQ1sif0MA6eHq43kPTP5xKhpVvwI7ZUF5s1GS3GWbUxDfuCP6N/lwtYis3+qMe22kcgIpfZtTY12lg3AvT515J3C7CEQn8emB4lQTeS2s99Wx/R1bgQjhBQZZx+GfPd5CyybiwC8C3vvHLyweKc42+qLay/32u9WDjFKWj7j0X1Xa2BG7Pz34pwOlvzy2Ao3aMJ4Qwg39D6HO38avwlHFiNTPO6IxTkgdlRUYFSZ2GENwGmkQb1wxYcX2usIs9CXwT0EYp1QpIBcYBF96ZVQjheHWCjBsNpYFwjVTtBK61LlNK3Q8sxigj/Exrvce0yIQQQpyTXY/PtdYLgYUmxSKEEOIiuElzPSGEEFVJAhdCCDclCVwIIdyUJHAhhHBTksCFEMJNSQIXQgg35dT7wJVSGUB1L0MJBjJNDMcsEtfFkbgujsR1cVw1LrAvtnCtdUjVF52awO2hlNp8prsArCZxXRyJ6+JIXBfHVeMCx8QmWyhCCOGmJIELIYSbcqcEPs3qAM5C4ro4EtfFkbgujqvGBQ6IzW32wIUQQvyZO63AhRBCnEYSuBBCuCm3SuBKqa5KqfVKqe1Kqc1KqV5Wx1RJKTVVKXVAKbVHKfW61fGcTin1qFJKK6WCrY4FQCn1hlJqv1Jqp1LqO6VUkMXxjKj4/y5eKfWklbFUUkq1VEr9qpTaV/Fv6kGrYzqdUspTKbVNKfWT1bFUUkoFKaXmVvzb2lfReN1ySqmHK/4/3K2UmqWUMq1fnVslcOB14HmtdVfg/yr+bDml1CBgDBCjte4EvGlxSH9QSrUEhgJJVsdymqVAtNY6BjgIPGVVIEopT+BD4AqgIzBeKdXRqnhOUwb8TWvdAegD3OcicVV6ENhndRBVvAv8orVuD3TBBeJTSjUHHgBitdbRGM1vxpk1vrslcA3Ur/h9IK7Tg/Me4FWtdTGA1jrd4nhO9zbwOMb3ziVorZdorSu66bIeo5+qVXoB8Vrrw1rrEmA2xpuxpbTWaVrrrRW/z8VIRs2tjcqglGoBjAQ+sTqWSkqp+sAA4FMArXWJ1vqUtVH9wQuoo5TyAvwxMW+5WwJ/CHhDKZWMscq1bOVWRVugv1Jqg1Lqd6VUT6sDAlBKjQZStdY7rI7lHG4HFlk4f3Mg+bQ/p+AiibKSUioC6AZssDaSP7yDsSiwWR3IaSKBDODziq2dT5RSAVYHpbVOxchVSUAakK21XmLW+Ha1VHMEpdQyoOkZPvUMMAR4WGs9Tyl1A8a7rVO6tZ4nLi+gAcaPuj2BOUqpSO2EGs3zxPU0MMzRMZzJueLSWv9Q8TXPYGwVzHBmbFWoM7zmMj+tKKXqAvOAh7TWOS4QzyggXWu9RSk10Op4TuMFdAemaq03KKXeBZ4EnrMyKKVUA4yf6FoBp4BvlVKTtNbTzRjf5RK41vqsCVkp9RXG3hvAtzjxR7jzxHUPML8iYW9UStkwLq7JsCoupVRnjH80O5RSYGxTbFVK9dJaH7MqrtPiuwUYBQxxxhvdOaQALU/7cwtcZGtOKeWNkbxnaK3nWx1PhX7AaKXUlYAfUF8pNV1rPcniuFKAFK115U8pczESuNUuBxK01hkASqn5QF/AlATublsoR4HLKn4/GIizMJbTfY8RD0qptoAPFt+IprXepbVurLWO0FpHYPwD7+6M5H0+SqkRwBPAaK11gcXhbALaKKVaKaV8MB4wLbA4JpTxrvspsE9r/ZbV8VTSWj+ltW5R8W9qHLDCBZI3Ff+uk5VS7SpeGgLstTCkSklAH6WUf8X/p0Mw8eGqy63Az+Mu4N2KhwFFwGSL46n0GfCZUmo3UALcYvGq0tV9APgCSyt+Olivtb7bikC01mVKqfuBxRgVAp9prfdYEUsV/YCbgF1Kqe0Vrz2ttV5oYUyubiowo+KN+DBwm8XxULGdMxfYirFduA0Tj9TLUXohhHBT7raFIoQQooIkcCGEcFOSwIUQwk1JAhdCCDclCVwIIdyUJHAhhHBTksCFEMJN/T+FlcgrgIRd6wAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(supports, energies)\n",
-    "plt.plot(supports, nergies.flatten())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 241,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray([], dtype=float32)"
-      ]
-     },
-     "execution_count": 241,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.zeros((1,1,1))[:0,5,:]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 243,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "blank = jnp.array([])\n",
-    "a = jnp.zeros(3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "jnp.vstack((blank))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 244,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ValueError",
-     "evalue": "Need at least one array to concatenate.",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-244-12efcb947f1a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mjnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mblank\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/anaconda3/envs/openmm/lib/python3.6/site-packages/jax/numpy/lax_numpy.py\u001b[0m in \u001b[0;36mconcatenate\u001b[0;34m(arrays, axis)\u001b[0m\n\u001b[1;32m   2309\u001b[0m   \u001b[0m_check_arraylike\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"concatenate\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2310\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2311\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Need at least one array to concatenate.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2312\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mndim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2313\u001b[0m     \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Zero-dimensional arrays cannot be concatenated.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mValueError\u001b[0m: Need at least one array to concatenate."
-     ]
-    }
-   ],
-   "source": [
-    "jnp.concatenate(blank, a)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 245,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = jnp.zeros((3,4))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 246,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "b = jnp.ones(4)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 249,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "DeviceArray([[0., 0., 0., 0.],\n",
-       "             [0., 0., 0., 0.],\n",
-       "             [0., 0., 0., 0.],\n",
-       "             [1., 1., 1., 1.]], dtype=float32)"
-      ]
-     },
-     "execution_count": 249,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "jnp.vstack((a, b[jnp.newaxis, ...]))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = (1,2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(1, 2, 3)"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "a + (3,)"
+    "so there might be a problem :/"
    ]
   },
   {

From 10e117c89bf98dd6eebf8803c2ee911b8680e3c0 Mon Sep 17 00:00:00 2001
From: dominicrufa <dominic.rufa@gmail.com>
Date: Sat, 12 Dec 2020 19:24:31 -0500
Subject: [PATCH 5/5] updating csmc experiments

---
 melange/csmc.py              | 308 +++++++++----
 melange/nn.py                |  10 +-
 melange/notebooks/csmc.ipynb | 825 +++++++++++++++++++++++------------
 melange/smc.py               |  24 +
 4 files changed, 790 insertions(+), 377 deletions(-)

diff --git a/melange/csmc.py b/melange/csmc.py
index a0baf51..5614f55 100644
--- a/melange/csmc.py
+++ b/melange/csmc.py
@@ -7,16 +7,18 @@
 from jax import ops
 from functools import partial
 from jax import random
-from jax import grad, vmap, jit
+from jax import grad, vmap, jit, device_put
 from jax.lax import map, scan, cond
 from jax.scipy.special import logsumexp
 from jax.config import config; config.update("jax_enable_x64", True)
+import numpy as np
+import tqdm
 import logging
 
 # Instantiate logger
 logging.basicConfig(level = logging.NOTSET)
 _logger = logging.getLogger("csmc")
-_logger.setLevel(logging.INFO)
+_logger.setLevel(logging.DEBUG)
 
 """twisting utilities"""
 def twisted_normal_params(mu, cov, A, b, get_log_twist_constant=True): #tested
@@ -120,7 +122,15 @@ def do_param_twist(base_mu, base_cov, As, bs, get_log_normalizer):
     logZ = cond(get_log_normalizer, lambda x: Normal_logZ(*x) - base_logZ, lambda x: 0., (twisted_mu, twisted_cov)) # compute the logZ of the kernel if specified
     return twisted_mu, twisted_cov, logZ + log_twist_constant
 
-def gaussians_twist(Xp, potential, dt, potential_params, A_fn, b_fn, A_params, b_params, get_log_normalizer):
+def gaussians_twist(Xp,
+                    potential,
+                    dt,
+                    potential_params,
+                    A_fn,
+                    b_fn,
+                    A_params,
+                    b_params,
+                    get_log_normalizer):
     """
     conduct a gaussian twist to return a twisted mean, covariance vector, normalizing constant, As, and bs
 
@@ -162,6 +172,44 @@ def gaussians_twist(Xp, potential, dt, potential_params, A_fn, b_fn, A_params, b
     twisted_mu, twisted_cov, logZ = do_param_twist(start_mu, start_cov, As, bs, get_log_normalizer)
     return twisted_mu, twisted_cov, logZ, (As, bs)
 
+def precomputed_gaussian_twist(Xp,
+                               twisted_mu,
+                               twisted_cov,
+                               A_fn,
+                               b_fn,
+                               A_params,
+                               b_params):
+    """
+    conduct a gaussian twist with recomputed twisted mu and covariance vectors
+    NOTE : this is primarily a utility for ADP
+
+    arguments
+        Xp : jnp.array(Dx)
+            previous x values
+        twisted_mu : jnp.array(Dx)
+            twisted mean
+        twisted_cov : jnp.array(Dx)
+            twisted covariance vector
+        A_fn : function
+            A twisting function
+        b_fn : function
+            b twisting function
+        A_params : jnp.array(V)
+            parameters to twist; each is of dim V
+        b_params : jnp.array(W)
+            parameters to twist; each is of dim W
+    returns
+        logZ : float
+            forward kernel log normalizer
+    """
+    A, b = A_fn(Xp, A_params), b_fn(Xp, b_params)
+    _, _, logZ = do_param_twist(twisted_mu,
+                                twisted_cov,
+                                A_params[jnp.newaxis, ...],
+                                b_params[jnp.newaxis, ...],
+                                True)
+    return logZ
+
 def get_twisted_gmm(mix_weights, mus, covs, A, b):
     """
     twist a gaussian mixture model with matrix A and vector b
@@ -309,25 +357,47 @@ def __init__(self,
                  *args, # N, potential, forward_potential, backward_potential
                  A_fn,
                  b_fn,
-                 A_params_len,
-                 b_params_len,
+                 params_len,
                  Dx,
                  T,
-                 max_twists = 10,
+                 max_twists,
+                 prop_params,
+                 init_params,
+                 model_params,
+                 y,
                  **kwargs):
         _logger.debug(f"instantiating super")
         super().__init__(*args, **kwargs) #init the og args
 
+        #define the twisting functions
+        _logger.debug(f"define A, b functions")
+        self.A_fn = A_fn
+        self.b_fn = b_fn
+
+        _logger.debug(f"getting the parameter lengths")
+        self.params_len = params_len
+
         _logger.debug(f"getting x dimension")
         self.Dx = Dx
 
         _logger.debug(f"getting the terminal time")
         self.T = T
 
-        #define the twisting functions
-        _logger.debug(f"define A, b functions")
-        self.A_fn = A_fn
-        self.b_fn = b_fn
+        _logger.debug(f"getting the maximum number of twists")
+        self.max_twists = max_twists
+
+        _logger.debug(f"getting prop_params")
+        self.prop_params = prop_params
+
+        _logger.debug(f"getting init_params")
+        self.init_params = init_params
+
+        _logger.debug(f"getting model_params")
+        self.model_params = model_params
+
+        _logger.debug(f"getting y")
+        self.y = y
+
 
         #vmap the A, b functions; this is a special utility to compute As, bs of a single twist for N particle positions
         self.vA_fn = vmap(A_fn, in_axes=(0,None))
@@ -336,45 +406,47 @@ def __init__(self,
         #define twisting iterations
         _logger.debug(f"define twisting parameters and parameter caches")
         self.twisting_iteration = 1
-        self.max_twists = max_twists
-        self.A_params_cache = jnp.zeros((max_twists, T, A_params_len))
-        self.b_params_cache = jnp.zeros((max_twists, T, A_params_len))
+        self.A_params_cache = jnp.zeros((max_twists, T, params_len))
+        self.b_params_cache = jnp.zeros((max_twists, T, params_len))
         self.A0, self.b0 = jnp.zeros(self.Dx), jnp.zeros(self.Dx)
 
-        #assert parameter lengths are the same
-        assert A_params_len == b_params_len, f"the A and b parameter lengths must be the same"
-        self.A_params_len = A_params_len
-        self.b_params_len = b_params_len
-
         #define the psi twisting function
         _logger.debug(f"define psi twisting functions")
         self.vlog_psi_twist = vmap(log_psi_twist, in_axes=(0,0,0))
+        self.precomputed_twist_fn = precomputed_gaussian_twist
         self.twist_fn = gaussians_twist
         self.vtwist_fn = vmap(self.twist_fn, in_axes=(0, None, None, None, None, None, None, None, None)) #args (Xp, potential, dt, potential_params, A_fn, b_fn, A_params, b_params, get_log_normalizer)
+        self.vprecomputed_twist_fn = vmap(self.precomputed_twist_fn, in_axes=(0, 0, 0, None, None, None, None)) # (Xp, twisted_mu,twisted_cov, A_fn, b_fn, A_params, b_params)
+
+        #make a cache to store the As, bs, logK_twists, twisted_mus, twisted_covs for the next iteration and to compute ADP
+        self.As_cache = None # cache of the A values
+        self.bs_cache = None # cache of the b values
+        self.K_logZs_cache = None # cache of the twisted kernel log normalizers
+        self.twisted_mus_cache = None # cache of the twisted mus
+        self.twisted_covs_cache = None # cache of the twisted covariances
+        self.t0_log_normalizer = None # _value_ of the prior normalizer
 
 
     def sim_prop_fn(self):
         _logger.debug(f"generating simulation propagation function")
         self.vpropagator = vmap(gaussian_proposal, in_axes=(0,0,0))
 
-        def prop(t, Xp, y, prop_params, model_params, rs):
-            N, Dx = Xp.shape #extract the number of particles and the dimension of x
-            folder_rs = random.split(rs, num=N+1) #create a list of random keys
+        def prop(t, Xp, rs):
+            folder_rs = random.split(rs, num=self.N+1) #create a list of random keys
             new_rs, runner_rs = folder_rs[0], folder_rs[1:] #separate the random keys
 
-            twisted_mus, twisted_covs, _, _ = self.vtwist_fn(Xp,
-                                                          self.forward_potential,
-                                                          prop_params['dt'],
-                                                          prop_params['forward_potential_params'][t],
-                                                          self.A_fn,
-                                                          self.b_fn,
-                                                          self.A_params_cache[:self.twisting_iteration,t],
-                                                          self.b_params_cache[:self.twisting_iteration,t],
-                                                          False) # twisted_mu, twisted_cov, logZ, (As, bs)
-
+            twisted_mus, twisted_covs, K_logZs, (As, bs) = self.vtwist_fn(Xp,
+                                                                    self.forward_potential,
+                                                                    self.prop_params['dt'],
+                                                                    self.prop_params['forward_potential_params'][t],
+                                                                    self.A_fn,
+                                                                    self.b_fn,
+                                                                    self.A_params_cache[:self.twisting_iteration,t],
+                                                                    self.b_params_cache[:self.twisting_iteration,t],
+                                                                    True) # twisted_mu, twisted_cov, logZ, (As, bs)
 
             Xs = self.vpropagator(runner_rs, twisted_mus, twisted_covs)
-            return Xs
+            return Xs, {'twisted_mus': twisted_mus, 'twisted_covs': twisted_covs, 'K_logZs': K_logZs, 'As': As, 'bs': bs}
         return prop
 
     def log_weights_fn(self):
@@ -382,7 +454,7 @@ def log_weights_fn(self):
         #define vmapped twisting functions and logK_integral functions
         static_ula_logW_fn = super().log_weights_fn() #get the super static ula log_weights_fn
 
-        def log_weights(t, Xp, Xc, y, prop_params, model_params):
+        def log_weights(t, Xp, Xc):
             """
             arguments
                 prop_params : tuple
@@ -391,30 +463,16 @@ def log_weights(t, Xp, Xc, y, prop_params, model_params):
                     backward_potential_params : jnp.array(T-1,S)
                     forward_dts : jnp.array(T)
                     backward_dts : jnp.array(T-1)
-
-            NOTE : need to implement a conditional here. specifically, if t == T, then we do _not_ need to compute the logK_Zs. we need only the untwisted incremental weight and the
-                twisting potential
             """
             # compute untwisted logWs
-            logWs = static_ula_logW_fn(t, Xp, Xc, y, prop_params, model_params)
-
-            #compute twisting logZ forward kernel and psi_twist
-            compute_logK_Z = cond(t == self.T, lambda x: False, lambda x: True, None)
-            _, _, logK_Zs, (As, bs) = self.vtwist_fn(Xp,
-                                                 self.forward_potential,
-                                                 prop_params['dt'],
-                                                 prop_params['forward_potential_params'][t],
-                                                 self.A_fn,
-                                                 self.b_fn,
-                                                 self.A_params_cache[:self.twisting_iteration,t],
-                                                 self.b_params_cache[:self.twisting_iteration,t],
-                                                 compute_logK_Z)
+            logWs = static_ula_logW_fn(t, Xp, Xc, self.y, self.prop_params, self.model_params)
 
             #compute twisting functions
-            log_psi_ts = self.vlog_psi_twist(Xc, As, bs)
+            log_psi_ts = self.vlog_psi_twist(Xc, self.As_cache[t], self.bs_cache[t])
 
             #build modifier
-            return logWs + logK_Zs - log_psi_ts
+            K_logZs = cond(t==self.T-1, lambda x: jnp.zeros(self.N), lambda x: self.K_logZs_cache[t+1], None) #compute the t+1 twisted kernel normalizer
+            return logWs + K_logZs - log_psi_ts
         return log_weights
 
     def initialize_Xs_fn(self):
@@ -426,34 +484,32 @@ def initialize_Xs_fn(self):
         self.vsample_gmm = vmap(sample_gmm, in_axes = (0, None, None, None)) # args: (key, weights, mus, covs)
 
 
-        def init_xs(prop_params, rs, init_params):
+        def init_xs(rs):
             #resolve random keys
             folder_rs = random.split(rs, self.N+1)
             rs, run_rs = folder_rs[0], folder_rs[1:]
 
             # conduct twisted initialization full_log_normalizer, log_normalized_twisted_mixtures, (twisted_mus, twisted_covs)
-            _, log_normalized_twisted_mixtures, (twisted_mus, twisted_covs) = get_twisted_gmm(init_params['mixture_weights'],
-                                                                                  init_params['mus'],
-                                                                                  init_params['covs'],
+            t0_log_normalizer, log_normalized_twisted_mixtures, (twisted_mus, twisted_covs) = get_twisted_gmm(self.init_params['mixture_weights'],
+                                                                                  self.init_params['mus'],
+                                                                                  self.init_params['covs'],
                                                                                   self.A0,
                                                                                   self.b0) #compute twisting parameters
 
             _, Xs = self.vsample_gmm(run_rs, exp_normalize(log_normalized_twisted_mixtures), twisted_mus, twisted_covs)
-            return Xs
+            return t0_log_normalizer, Xs
         return init_xs
 
     def initialize_logW_fn(self, **kwargs):
         _logger.debug(f"generating SMC log weight initializer function")
 
-        def init_logWs(X, init_params, prop_params):
-            log_normalizer, _, _ = get_twisted_gmm(init_params['mixture_weights'],
-                                                   init_params['mus'],
-                                                   init_params['covs'],
-                                                   self.A0,
-                                                   self.b0) #compute twisting parameters
-
+        def init_logWs(X):
             # compute twisted weights
-            log_psi0s = log_normalizer - vlog_psi_twist_single(X, self.A0, self.b0)
+            log_psi0s = (
+                            self.t0_log_normalizer # use the precomputed t=0 log normalizer; NOTE : this isn't necessary for ADP
+                            + self.K_logZs_cache[1] # use the precomputed t=0 forward kernel normalizer
+                            - vlog_psi_twist_single(X, self.A0, self.b0) # compute the t=0 twisted potential
+                            )
 
             return log_psi0s
         return init_logWs
@@ -465,7 +521,6 @@ def get_ADP_fn(self):
         """
         _logger.debug(f"generating approximate dynamic programming functions")
         from jax.ops import index, index_add, index_update
-        import tqdm
         import numpy as np
 
         def sum_square_diffs(Xcs, As, bs, V_bars):
@@ -533,7 +588,7 @@ def scipy_loss(A_b_params, Xps, Xcs, V_bars):
                 out : float
                     loss
             """
-            A_params, b_params = A_b_params[:self.A_params_len], A_b_params[self.A_params_len:]
+            A_params, b_params = A_b_params[:self.params_len], A_b_params[self.params_len:]
             return loss(Xps, Xcs, A_params, b_params, V_bars)
 
         def t0_scipy_loss(A0_b0, Xcs, V_bars):
@@ -584,11 +639,6 @@ def callback(xk):
         t0_scipy_loss_grad = grad(t0_scipy_loss, argnums=(0,))
 
         #to numpy wrapper
-        # def np_scipy_loss(A_b_params, Xps, Xcs, V_bars): return float(scipy_loss(A_b_params, Xps, Xcs, V_bars))
-        # def np_t0_scipy_loss(A0_b0, Xcs, V_bars): return float(t0_scipy_loss(A0_b0, Xcs, V_bars))
-        # def np_scipy_loss_grad(A_b_params, Xps, Xcs, V_bars): return np.array(scipy_loss_grad(A_b_params, Xps, Xcs, V_bars), dtype=np.float64)
-        # def np_t0_scipy_loss_grad(A0_b0, Xcs, V_bars): return np.array(t0_scipy_loss_grad(A0_b0, Xcs, V_bars), dtype=np.float64)
-
         def np_scipy_loss(*args): return float(scipy_loss(*args))
         def np_t0_scipy_loss(*args): return float(t0_scipy_loss(*args))
         def np_scipy_loss_grad(*args): return np.array(scipy_loss_grad(*args), dtype=np.float64)
@@ -597,7 +647,6 @@ def np_t0_scipy_loss_grad(*args): return np.array(t0_scipy_loss_grad(*args), dty
 
         def ADP(Xs,
                 logWs,
-                prop_params,
                 minimizer_params = {
                                     'method': 'L-BFGS-B',
                                     'options': {'disp':True}
@@ -619,8 +668,8 @@ def ADP(Xs,
             assert N == self.N
 
             #initialize arrays as nan
-            out_A_params = np.empty((T, self.A_params_len)); out_A_params[:] = np.nan
-            out_b_params = np.empty((T, self.b_params_len)); out_b_params[:] = np.nan
+            out_A_params = np.empty((T, self.params_len)); out_A_params[:] = np.nan
+            out_b_params = np.empty((T, self.params_len)); out_b_params[:] = np.nan
             loss_trace=[] #create a loss trace if we are verbose
 
             logK_int_twist = jnp.zeros(N) #initialize the logK_twist_T+1
@@ -639,7 +688,7 @@ def ADP(Xs,
                     callback_fn=None
 
                 out_containter = minimize(np_scipy_loss, #at time t, we use the generic np scipy loss function
-                                          x0 = jnp.zeros((2, self.A_params_len)).flatten(), #initial parameters
+                                          x0 = jnp.zeros((2, self.params_len)).flatten(), #initial parameters
                                           args = runner_args, #other args
                                           jac = np_scipy_loss_grad,
                                           callback=callback_fn,
@@ -651,7 +700,7 @@ def ADP(Xs,
                 assert out_containter['success'], f"iteration {t} failed with message {out_containter['message']}" #TODO : make this fail safe
 
                 #extract the output parameters
-                reshaped_out_x = out_containter['x'].reshape(2,self.A_params_len) #check to make sure this is reshaped properly
+                reshaped_out_x = out_containter['x'].reshape(2,self.params_len) #check to make sure this is reshaped properly
                 new_A_params, new_b_params = reshaped_out_x[0,:], reshaped_out_x[1,:]
 
                 #record the parameters
@@ -659,19 +708,26 @@ def ADP(Xs,
                 out_b_params[t,:] = new_b_params
 
                 #compute the logK twisting integrals for the next optimization step
-                _, _, logK_int_twist, _ = self.vtwist_fn(Xs[t-1],
-                                                     self.forward_potential,
-                                                     prop_params['dt'],
-                                                     prop_params['forward_potential_params'][t],
-                                                     self.A_fn,
-                                                     self.b_fn,
-                                                     jnp.vstack((self.A_params_cache[:self.twisting_iteration,t], jnp.asarray(new_A_params))),
-                                                     jnp.vstack((self.b_params_cache[:self.twisting_iteration,t], jnp.asarray(new_b_params))),
-                                                     True)
+                logK_int_twist =  self.vprecomputed_twist_fn(Xs[t-1],
+                                                             self.twisted_mus_cache[t], # CHECK that this index is correct
+                                                             self.twisted_covs_cache[t], # Same here
+                                                             self.A_fn,
+                                                             self.b_fn,
+                                                             new_A_params,
+                                                             new_b_params)
+                # _, _, logK_int_twist, _ = self.vtwist_fn(Xs[t-1],
+                #                                      self.forward_potential,
+                #                                      self.prop_params['dt'],
+                #                                      self.prop_params['forward_potential_params'][t],
+                #                                      self.A_fn,
+                #                                      self.b_fn,
+                #                                      jnp.vstack((self.A_params_cache[:self.twisting_iteration,t], jnp.asarray(new_A_params))),
+                #                                      jnp.vstack((self.b_params_cache[:self.twisting_iteration,t], jnp.asarray(new_b_params))),
+                #                                      True)
 
             #now to do the 0th time twist
             _logger.debug(f"conducting t=0 twist...")
-            Vbar0 = -logWs[0] - logK_int_twist #compute the Vbars
+            Vbar0 = -(logWs[0] - self.t0_log_normalizer) - logK_int_twist #compute the Vbars
             # TODO : do we have to flatten an array as first argument to minimizer
 
             runner_args = (None, Xs[0], Vbar0) #other arguments passed to minimizer
@@ -720,8 +776,8 @@ def update_cSMC(self,
         """
         _logger.debug(f"updating cSMC with new parameters")
         #make sure that the input parameters are compatible with those of the class
-        assert new_A_params.shape == (self.T-1, self.A_params_len)
-        assert new_b_params.shape == (self.T-1, self.b_params_len)
+        assert new_A_params.shape == (self.T-1, self.params_len)
+        assert new_b_params.shape == (self.T-1, self.params_len)
         assert new_A0.shape == (self.Dx,)
         assert new_b0.shape == (self.Dx,)
 
@@ -730,8 +786,80 @@ def update_cSMC(self,
         _logger.debug(f"cacheing parameters at index {catalogue_index}")
         self.A_params_cache = ops.index_update(self.A_params_cache, ops.index[catalogue_index,1:,:], new_A_params)
         self.b_params_cache = ops.index_update(self.b_params_cache, ops.index[catalogue_index,1:,:], new_b_params)
-        self.A0 = new_A0
-        self.b0 = new_b0
+        self.A0 = self.A0 + new_A0
+        self.b0 = self.b0 + new_b0
 
         #then update the twisting iteration
         self.twisting_iteration += 1
+
+
+"""
+implementation utilities;
+
+these utilities are used to perform csmc twists, run SIS, etc
+"""
+def twisted_smc(smc_object, rs, aggregate_works=False):
+    """
+    generate trajectories of length T, N
+    """
+
+    #initialize
+    init_X_fn = smc_object.initialize_Xs_fn() #get the initialize xs function
+    rs, init_rs = random.split(rs) #split the random vars
+    t0_log_normalizer, X0 = init_X_fn(init_rs) # get the log normalizing function at t0 and the initial positions
+
+    #make propagation function
+    prop_fn = jit(smc_object.sim_prop_fn()) #we jit this function because it can become expensive
+
+    #define a cache
+    As_cache = np.zeros((smc_object.T, smc_object.N, smc_object.twisting_iteration, smc_object.Dx)) # create a cache of A variance parameters
+    bs_cache = np.zeros((smc_object.T, smc_object.N, smc_object.twisting_iteration, smc_object.Dx)) # createa a cache of b twisting parameters
+    K_logZs_cache = np.zeros((smc_object.T, smc_object.N)) # create a cache of log normalizing parameters
+    twisted_mus_cache = np.zeros((smc_object.T, smc_object.N, smc_object.Dx)) # create a cache of twisted mus
+    twisted_covs_cache = np.zeros((smc_object.T, smc_object.N, smc_object.Dx)) #create a cache of twisted covariance vectors
+    all_Xs = np.zeros((smc_object.T, smc_object.N, smc_object.Dx)) # create a cache of all positions
+    all_Xs[0] = np.asarray(X0) #update the t=0 particles
+
+    Xp = X0 # the previous positions are set as the X0s before SMC
+    for t in tqdm.trange(1,smc_object.T):
+        rs, run_rs = random.split(rs) #split the random vars
+        X, out_dict = prop_fn(t, Xp, run_rs) #do a propagation
+
+        #update the positions
+        As_cache[t] = np.asarray(out_dict['As']) # update the As cache
+        bs_cache[t] = np.asarray(out_dict['bs']) # and the bs cache
+        K_logZs_cache[t] = np.asarray(out_dict['K_logZs']) # update the log normalizers
+        twisted_mus_cache[t] = np.asarray(out_dict['twisted_mus']) # update the twisted mus cache
+        twisted_covs_cache[t] = np.asarray(out_dict['twisted_covs']) # update the twisted covariance cache
+        all_Xs[t] = np.asarray(X) # update positions cache
+        Xp = X
+
+    #update the smc object cache
+    smc_object.As_cache = jnp.asarray(As_cache)
+    smc_object.bs_cache = jnp.asarray(bs_cache)
+    smc_object.K_logZs_cache = jnp.asarray(K_logZs_cache)
+    smc_object.twisted_mus_cache = jnp.asarray(twisted_mus_cache)
+    smc_object.twisted_covs_cache = jnp.asarray(twisted_covs_cache)
+    smc_object.t0_log_normalizer = t0_log_normalizer
+    all_Xs = jnp.asarray(all_Xs)
+
+    #get weight_functions
+    init_logw_fn = smc_object.initialize_logW_fn()
+    logw_fn = jit(smc_object.log_weights_fn())
+
+    #compute initial weight
+    init_logWs = init_logw_fn(all_Xs[0])
+
+    #compute the other weights
+    logWs = np.zeros((smc_object.T, smc_object.N))
+    logWs[0,:] = np.asarray(init_logWs)
+
+    for t in tqdm.trange(1,smc_object.T):
+        Xp, Xc = all_Xs[t-1], all_Xs[t]
+        logW = logw_fn(t, Xp, Xc)
+        logWs[t] = np.asarray(logW)
+
+    logWs = jnp.asarray(logWs)
+
+
+    return all_Xs, cond(aggregate_works, lambda x: jnp.cumsum(x, axis=0), lambda x: x, logWs)
diff --git a/melange/nn.py b/melange/nn.py
index 55db471..cae3ba0 100644
--- a/melange/nn.py
+++ b/melange/nn.py
@@ -75,7 +75,9 @@ def simple_nnpotential_generator(base_potential, nn_potential, base_potential_pa
 
     shapes = [(w.shape, b.shape) for w,b in nn_potential_param_list]
     def out_nnpotential(x, parameter):
-        base_e_param, nn_param = parameter[:base_potential_parameter_length], parameter[base_potential_parameter_length:]
+        base_scale_param, nn_scale_param=parameter[:2]
+        aux_params = parameter[2:]
+        base_e_param, nn_param = aux_params[:base_potential_parameter_length], aux_params[base_potential_parameter_length:]
 
         #resolve the base param
         base_e = base_potential(x, base_e_param)
@@ -93,11 +95,11 @@ def out_nnpotential(x, parameter):
 
         #call the nn_potential
         nn_e = nn_potential(x, nn_param_list)
-        return nn_e + base_e
+        return nn_scale_param*nn_e + base_scale_param*base_e
 
     return out_nnpotential
 
-def sigmoid_nn_potential(pos, parameter):
+def convolution_nn_potential(pos, parameter, activation=jax.nn.sigmoid):
     """
     make a simple, fully-connected
     arguments
@@ -118,5 +120,5 @@ def sigmoid_nn_potential(pos, parameter):
         w,b = parameter[i]
         dotter = jnp.dot(w, act)
         outs = dotter + b
-        act = jax.nn.sigmoid(outs) - 0.5
+        act = activation(outs)
     return act.sum()
diff --git a/melange/notebooks/csmc.ipynb b/melange/notebooks/csmc.ipynb
index 8c25845..50b3988 100644
--- a/melange/notebooks/csmc.ipynb
+++ b/melange/notebooks/csmc.ipynb
@@ -19,48 +19,67 @@
     "from matplotlib import pyplot as plt\n",
     "import seaborn as sns\n",
     "from jax.config import config; config.update(\"jax_enable_x64\", True)\n",
+    "from jax.scipy.stats import multivariate_normal\n",
+    "from melange.gaussians import unnormalized_Normal_logp\n",
     "%matplotlib inline"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "as a test, i am going to anneal between two gaussians centered at zero over 10 steps. the prior has a variance of 2 and the posterior has a variance of 1.\n",
+    "\n"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/100 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "the estimated logZ is -0.3494904538572321; the True logZ is -0.3465\n",
-      "now doing statistical sample; nom nom\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "DEBUG:absl:Compiling vSIS_lower_bound for args (ShapedArray(float64[9,1]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[10,1]), ShapedArray(float64[10,1]), ShapedArray(int64[10]), ShapedArray(uint32[2]), ShapedArray(float64[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1,1])).\n",
-      "100%|██████████| 100/100 [00:02<00:00, 33.94it/s]\n"
+      "DEBUG:absl:Initializing backend 'interpreter'\n",
+      "DEBUG:absl:Initializing backend 'cpu'\n",
+      "DEBUG:absl:Initializing backend 'gpu'\n",
+      "DEBUG:absl:Error initializing backend 'gpu': Not found: Could not find registered platform with name: \"cuda\". Available platform names are: Interpreter Host\n",
+      "/home/dominic/anaconda3/envs/openmm/lib/python3.6/site-packages/jax/lib/xla_bridge.py:130: UserWarning: No GPU/TPU found, falling back to CPU.\n",
+      "  warnings.warn('No GPU/TPU found, falling back to CPU.')\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1])).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:csmc:instantiating super\n",
+      "DEBUG:csmc:define A, b functions\n",
+      "DEBUG:csmc:getting the parameter lengths\n",
+      "DEBUG:csmc:getting x dimension\n",
+      "DEBUG:csmc:getting the terminal time\n",
+      "DEBUG:csmc:getting the maximum number of twists\n",
+      "DEBUG:csmc:getting prop_params\n",
+      "DEBUG:csmc:getting init_params\n",
+      "DEBUG:csmc:getting model_params\n",
+      "DEBUG:csmc:getting y\n",
+      "DEBUG:csmc:define twisting parameters and parameter caches\n",
+      "DEBUG:csmc:define psi twisting functions\n"
      ]
     }
    ],
    "source": [
     "from melange.tests.utils import get_nondefault_potential_initializer, checker_function\n",
-    "from melange.smc import vSIS_lower_bound, SIS, generate_trajs, SIS_logW\n",
+    "from melange.smc import vSIS_lower_bound, SIS, generate_trajs, SIS_logW, bootstrap_logZ\n",
     "import tqdm\n",
     "from jax.lax import cond\n",
     "import numpy as np\n",
     "from melange.csmc import *\n",
     "\n",
     "#define some parameters\n",
-    "N,T,Dx = 10000, 10, 1\n",
+    "N,T,Dx = 1000, 10, 1\n",
     "potential, (mu, cov), dG = get_nondefault_potential_initializer(Dx)\n",
     "cov = cov[0]\n",
     "dt=1e-2\n",
@@ -69,21 +88,6 @@
     "A_fn = lambda x, params: params\n",
     "b_fn = lambda x, params: jnp.zeros(Dx)\n",
     "\n",
-    "#create the csmc container object\n",
-    "smc_obj= StaticULAControlledSMC(N, \n",
-    "                            potential=potential,\n",
-    "                            forward_potential=potential, \n",
-    "                            backward_potential=potential, \n",
-    "                            A_fn = A_fn, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
-    "                            b_fn = b_fn, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
-    "                            A_params_len=1,\n",
-    "                            b_params_len=1,\n",
-    "                            Dx=1,\n",
-    "                            T=T\n",
-    "                           ) #create a controlled smc class\n",
-    "\n",
-    "#create SMC parameters/functions\n",
-    "prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
     "potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis] #define the potential parameters\n",
     "\n",
     "prop_params = {\n",
@@ -99,234 +103,322 @@
     "y=jnp.arange(T) #the y data aren't important. just know that there are the same number of them as there are data\n",
     "rs = random.PRNGKey(6) #define a random number \n",
     "\n",
-    "#create the trajectories\n",
-    "Xs = generate_trajs(prop_params, model_params, y, rs, init_params, init_Xs, prop)\n",
-    "logWs = SIS_logW(Xs, prop_params, model_params, y, init_params, logw, init_logws, aggregate_works=False)\n",
-    "aggregated_logWs = jnp.cumsum(logWs, axis=0)\n",
-    "logZ = logsumexp(aggregated_logWs[-1,:]) - jnp.log(N)\n",
-    "print(f\"the estimated logZ is {logZ}; the True logZ is {dG}\")\n",
-    "\n",
-    "print(f\"now doing statistical sample; nom nom\")\n",
-    "from melange.smc import vSIS_lower_bound\n",
-    "jvSIS = jit(vSIS_lower_bound, static_argnums=(5,6,7))\n",
-    "logZs = []\n",
+    "#create the csmc container object\n",
+    "smc_obj= StaticULAControlledSMC(N, \n",
+    "                            potential=potential,\n",
+    "                            forward_potential=potential, \n",
+    "                            backward_potential=potential, \n",
+    "                            A_fn = A_fn, #A_fn=lambda x, p: jnp.zeros((Dx, Dx)), \n",
+    "                            b_fn = b_fn, #b_fn = lambda x, p: jnp.zeros(Dx),\n",
+    "                            params_len=1,\n",
+    "                            Dx=1,\n",
+    "                            T=T,\n",
+    "                            max_twists=10,\n",
+    "                            prop_params=prop_params,\n",
+    "                            init_params=init_params,\n",
+    "                            model_params=model_params,\n",
+    "                            y=None\n",
+    "                           ) #create a controlled smc class\n",
     "\n",
-    "for i in tqdm.trange(100):\n",
-    "    rs, run_rs = random.split(rs)\n",
-    "    out_logZ = jvSIS(prop_params, model_params, y,  run_rs, init_params, prop, logw, (init_Xs, init_logws))\n",
-    "    logZs.append(out_logZ)\n"
+    "\n"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 37,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7ff405e3e6d8>"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd3hc1ZnH8e87M+q9V9tykXvDFmBjwGAbQjHY1CWUGDZZJ9kkJNlNgWWXsgSWkGST7CZAgJAlhE4A20BoNjhUueEmWbZlSdiyutV7mbN/aJIoIDfNjO7MnffzPHpm5t47M+/x1fx0fefcc8QYg1JKKXtxWF2AUkop39NwV0opG9JwV0opG9JwV0opG9JwV0opG3JZXQBAamqqycvLs7oMpZQKKlu3bm0wxqQNty4gwj0vL48tW7ZYXYZSSgUVEfn0aOv0tIxSStmQhrtSStmQhrtSStmQhrtSStmQhrtSStmQhrtSStmQhrtSStmQhrtSStmQhrtSStlQQFyhqtRoeKrw4Ki917Wnjx2191JqOHrkrpRSNqThrpRSNqThrpRSNnTccBeRx0SkTkR2D1mWLCJvich+z23SkHW3ikipiOwVkS/4q3CllFJHdyJH7v8HXPCZZbcA640x+cB6z2NEZDpwDTDD85wHRMTps2qVUkqdkOOGuzHmz0DjZxavAB733H8cWDlk+TPGmB5jTDlQCpzmo1qVUkqdoJGec88wxlQDeG7TPctzgENDtqv0LPscEVktIltEZEt9ff0Iy1BKKTUcX3+hKsMsM8NtaIx52BhTYIwpSEsbdpYopZRSIzTScK8VkSwAz22dZ3klMGbIdrlA1cjLU0opNRIjDfe1wCrP/VXAmiHLrxGRCBEZD+QDm7wrUSml1Mk67vADIvI0cA6QKiKVwB3AfcBzIvJl4CBwFYAxpkhEngOKgX7gG8aYAT/VrpRS6iiOG+7GmC8eZdXSo2x/D3CPN0UppZTyjl6hqpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNqThrpRSNuSyugCllHeeKjw4au917eljR+29lHf0yF0ppWxIw10ppWxIw10ppWxIw10ppWxIv1BVIautu4/9de00tPVwpKMXA0Q4HcRGuhiTFMWY5GjiIsOsLlOpEdFwVyHFGMOe6lYKyxsprWvHAA6BpOhwHCL0Drhp6+7DbQa3H5MUxezcRGbnJox60A+4B2utau5iwG0QEU4Zm0hGfOSo1qGCk4a7ChnVLV28srOa8oYOEqPCWDw5jVm5CaTHReJ0yF+36xtwU9XcRXlDB7sOt/Dqrmpe313DjJx4FoxPYVxKNCJyjHcaud5+N28V1/LC1kNsrmiivaf/c9tMzojl6oIxrDojjzCnnllVw9NwV7ZnjOE3fy7jVxtKiQp3smJuNgXjkv8u0IcKczoYlxLDuJQYzpmSTl1rN5srGtl6sImdlS1kxkeyYEIKc8ckEu7yTbiWN3TwzOaDvLClkiMdveQkRrHylME6J6bFEuYSunoH2FTeyPo9dfzo1T28sLWSey6b6ZP3V/Yjxhira6CgoMBs2bLF6jKUDbX39PP953fwp901zMxJ4LK5OUSFO0f0Wr39bnYcaubj8iNUt3QTGeZg3tgkFoxPITUu4u+2PZGLfXr6B3ijqJanCw/yUdkRnA5h2bR0vnjaWM7KTzvqHx9jDG8U1XLXuiLq2nq4umAMs3ISRtSmk6UXMQUWEdlqjCkYbp1XR+4i8l3gK4ABdgE3AdHAs0AeUAFcbYxp8uZ9lBqJ5s5erv9tIXuq27jtomlEhzu9Op0S7nJw6vhkCvKSONjYyUdlRygsa+TDA0eYlB7L6eOTmZQeS4Tr6H88+gbcFJY1ek71VNPU2UduUhTf/8IUrpqfS/oJnE8XES6YmcmiSSnc9LvNPLv5IMJYZo5SwKvgMOIjdxHJAd4HphtjukTkOeA1YDrQaIy5T0RuAZKMMT881mvpkbvytcaOXq57tJADde08eP08lk7L8Mtl+m3dfWyuaGJzRSMtXX04BLITo1g4IYW0uAjiIsPo6OmnqbOXPdWtFFW10tPvJjrcyZKp6VxdMIYzJ6XiOMpR+vG09/Rz0S/fo7Kpk1UL88jPiPNxC/+eHrkHFr8duXueHyUifQwesVcBtwLneNY/DrwLHDPclfKllq4+rn3kY8obOnhkVQGLJ6f57b3iIsNYMjWdxZPTKGtop7yhg4qGTt7b30B9ew8DboPTIcRHupiUHssNC8Zx6vhkFk9OIzJsZKeHhoqNcHHTGXn85s9lPL+1kpuX5hMboV+lKS/C3RhzWER+ChwEuoA3jTFvikiGMabas021iKQP93wRWQ2sBhg7Vo8GlG/09rv52hNbOVDfzmM3nspZ+f4L9qGcDiE/PY789MEj52tPH4vbbejuHyAqzLvTQccTEebk6oIxPPBuKS9uq+SGBeP8+n4qOIz4q34RSQJWAOOBbCBGRK4/0ecbYx42xhQYYwrS0kbnA6jszRjDLS/u5KOyI9x3+exRC/ajcTiE6HDXqARtZkIkX5iRSUlNG5sqGv3+firwedOPaxlQboypN8b0AS8CZwC1IpIF4Lmt875MpY7voY1lvLjtMN9dNpkr5udaXc6oWzgxhYlpMbxRVEPnMP3jVWjxJtwPAgtEJFoGD02WAnuAtcAqzzargDXelajU8X14oIGfvFHCxbOzuHnpJKvLsYRDhOWzs+npc/POXj2mCnUjDndjTCHwArCNwW6QDuBh4D7gPBHZD5zneayU39S2dnPz058wPjWGH18xO6TPN2fERzJ/XBIflzfS1NFrdTnKQl5dXmeMucMYM9UYM9MYc4MxpscYc8QYs9QYk++51ROAym8G3IZvPf0Jnb0DPHT9fO0pAiydloFD4K09tVaXoiykA1OooPbQxgNsKm/k7hUz/d7HO1gkRIVxxsRUth9qpqal2+pylEU03FXQ2lnZzM/f2sfFs7O4fF6O1eUElLPz0whzCu+XNlhdirKIhrsKSl29A3znme2kxUVw78pZIX2efThR4U7mj0tmx6FmWrv7rC5HWUDDXQWln7yxl7KGDn521RwSonVCjeEsmpiC2xg+LjtidSnKAhruKuhsqWjkdx+W86WF4zhjUqrV5QSslNgIpmXFU1jWSG+/2+py1CjTcFdBpbtvgB+8sJOcxCh+eMFUq8sJeGdOSqWrb4BtB3Vg1lCj4a6Cyi/e3k9ZQwc/vmI2Mdrt8bjGpUSTnRjJpvJGAmHuBjV6NNxV0Cita+fR98q4an4ui/R0zAkREQrGJVPT2k2VdosMKRruKigYY7hzbRHR4U5+eKGejjkZc3ITcTmELTqgWEjRcFdB4U+7a3i/tIF/PX8KqbERx3+C+quocCczsuPZUdlM34B+sRoqNNxVwOvs7edHrxQzLSue63QmoBGZPy6Z7j43xVWtVpeiRomGuwp4v9pQSlVLN3evmIHLqb+yIzEhLYak6DC2fqq9ZkKFflJUQCurb+eR98q4fF4OBXnJVpcTtBwizBubRGl9Oy1desVqKNBwVwHLGMOd64qJdDm59cJpVpcT9ObkJgKw63CLxZWo0aDhrgLWG0W1/HlfPd89bzJpcfolqrdS4yLITohkZ2Wz1aWoUaDhrgJSV+8Ad79SzNTMOL60cJzV5djG7NxEKpu6aNSJPGxPL/FTAemBd0s53NzFs6sXBOWXqE8VHrS6hGHNykng9aIadlU2s3hKutXlKD8Kvk+Nsr2Khg5+s7GMlXOzOX1CitXl2EpSTDhjk6PZqefdbU/DXQWc/3ylmDCn8G8X6Zeo/jArJ4Hqlm7q2nQ4AjvTcFcB5e3iWjaU1PGdZZNJj4+0uhxbmpWTgAC79ejd1jTcVcDo7hvgrleKyE+P5cZFeVaXY1vxUWGMSY7Wq1VtTsNdBYyHNh7gUGMXd62YQVgQfokaTKZnxVPV0k2T9pqxLf0EqYBwqLGTB989wPLZWZwxUYfz9bcZ2fEAFFfr0btdabirgHDXumKcDuG2i/VL1NGQEhtBRnwERXpqxra0n7uy1FOFB9lb08rbe2q5YEYm75TUW11SyJielcC7e+to7+knVme1sh09cleW6htws25nNWmxEZwxSfu0j6YZ2fEYoERPzdiShruy1Hv7G2js6OWSOdm4HPrrOJqyEiJJig7TUzM2pZ8mZZnKpk427qtjZnY8k9JjrS4n5IgI07LiOVDfTm+/ztBkNxruyjJ3v1IMwEWzsiyuJHRNzYyn320oq2+3uhTlYxruyhIb99XzRlEt505JJzE63OpyQlZeajThLgclNW1Wl6J8TMNdjbqe/gHuXFvE+NQYzpykfdqt5HI4yE+PpaSmFWOM1eUoH/Iq3EUkUUReEJESEdkjIgtFJFlE3hKR/Z7bJF8Vq+zh0ffKKW/o4M5LdU7UQDA1M47W7n6qW3QgMTvx9pP1S+B1Y8xUYA6wB7gFWG+MyQfWex4rBcDh5i5+taGUL8zIYPHkNKvLUcDkjDgAPTVjMyMOdxGJB84GfgtgjOk1xjQDK4DHPZs9Dqz0tkhlH/e8WozbGP5j+XSrS1EecZFh5CZFsbdGu0TaiTdH7hOAeuB3IvKJiDwqIjFAhjGmGsBzO+x0LyKyWkS2iMiW+nq9KjEUvL+/gdd21fCNcyeRmxRtdTlqiCmZcVQ2ddHe0291KcpHvAl3FzAPeNAYcwrQwUmcgjHGPGyMKTDGFKSl6X/P7a63383ta3czLiWa1WdPsLoc9RlTMwevVt2np2Zsw5twrwQqjTGFnscvMBj2tSKSBeC5rfOuRGUHj31QTll9B3dcMp3IMKfV5ajPyE6IJD7SRYmemrGNEYe7MaYGOCQiUzyLlgLFwFpglWfZKmCNVxWqoFfT0s3/rN/PsmnpLJmaYXU5ahgiwpTMOPbXtdPv1qtV7cDboeC+BTwpIuFAGXATg38wnhORLwMHgau8fA8V5O55bQ/9bsPty2dYXYo6hikZ8WyuaOLTI51MTNPhIIKdV+FujNkOFAyzaqk3r6vs48MDDazbUcW3l+YzNkW/RA1kE9NjcDmEkupWDXcb0CtIlN/0Dbi5Y00RY5Kj+Po5E60uRx1HhMvJhLQY7e9uExruym8e/7CC/XXt3L58hn6JGiSmZMZzpKOXhrYeq0tRXtLpV9TnPFV40OvXaO3u4+dv7WNKRhx1rd0+eU3lf1Mz4lgHlNS0cmacdlEOZnrkrvzitV3VDLgNy2dnISJWl6NOUFJMOOlxEZTU6qmZYKfhrnzuQH07OytbOHtyGimxEVaXo07S1Mw4Kho66O4bsLoU5QUNd+VT/W43a7dXkRwTrgODBakpmfG4DZTW6QQewUzDXfnUB6VHqG/v4ZLZWYTpcL5BaWxyNJFhDvZqr5mgpp8+5TPNnb1sKKllelY8UzLjrS5HjZDTIeSnx7G3tg23TuARtDTclc+8srMagItn65yowW5qZhztPf1UNXdZXYoaIQ135RN7a9oorm7l3CnpJOmcqEEvPyMOAT01E8Q03JXX+gbcrNtZRWpsBGfm65yodhAb4RqcwEO7RAYtDXfltT/vq6exo5dL52TjcuivlF1MyYynsqmLtu4+q0tRI6CfROWVI+09bNxXz6ycBCal62BTdjI1c3Bu1X212iUyGGm4qxEzxvDKzmqcDuHiWfolqt1keSbw0LlVg5OGuxqx4upW9ta2sXRaBvFRYVaXo3xMRJicMTiBx4Bbu0QGGw13NSLdfQOs21FFVkIkCyekWF2O8pOpmXH09LupONJhdSnqJGm4qxF5s7iGtu5+LjslB6dDBwazq4npsTgdohNnByENd3XSDh7poLCskTMmppCbpLMr2VmEy8n41BgdJTIIabirk9LvdvPS9sMkRIWxbLpOdh0KpmTEUd/WQ2NHr9WlqJOg4a5Oyvv7G6ht7eHSOdlEuHR2pVDwly6RJdprJqhouKsT1tDew4aSOmbmJDA1SwcGCxUpsRGkx0VQXK3hHkw03NUJMcbw8ieHcTmF5TowWMiZnhVPRUMHzZ16aiZYaLirE7LtYDNlDR1cMCOL+Ejt0x5qpmcPTuCxoaTO6lLUCdJwV8fV3tPPa7uqGZcSTUFektXlKAtkJ0YRH+nizaJaq0tRJ0jDXR3Xa7uq6e13c9ncHBw62XVIcogwLSuejfvqdW7VIKHhro5pX20b2w81s3hKGunxkVaXoyw0PTuerr4B3tvfYHUp6gRouKuj6u13s2b7YVJjIzhHJ7sOeeNTY4iLdPFmUY3VpagToOGujmp9SS1NnX1cdkoOLp3sOuS5HA6WTE3n7T219A+4rS5HHYd+YtWwqpq7+KC0gVPzkhifGmN1OSpAnD89k6bOPrZ+2mR1Keo4NNzV57iN4aVPDhMd7uKCGdqnXf3N4ilphDsdvFmsvWYCnYa7+pyPDhzhcHMXy2dnERWuQwyov4mNcLFoUgpvFtdgjI7xHsi8DncRcYrIJyLyiudxsoi8JSL7PbfaMTqIVDZ18lZxLVMy4piVk2B1OSoAnT8jk0ONXZToMMABzRdH7t8G9gx5fAuw3hiTD6z3PFZBwBjD7WuKALh0bjaifdrVMJZNy0AEvaApwHkV7iKSC1wMPDpk8Qrgcc/9x4GV3ryHGj2v7qpmQ0kd503PICk63OpyVIBKi4tg/tgk3izWLpGBzNsj918APwCG9ovKMMZUA3hu04d7ooisFpEtIrKlvr7eyzKUt1o6+7hzbTGzcxNYOFGnzVPHdv6MDIqqWjnU2Gl1KeooRhzuIrIcqDPGbB3J840xDxtjCowxBWlpeoGM1e57fQ9Nnb3ce9ksHWJAHddfelG9tqva4krU0Xhz5L4IuFREKoBngCUi8gegVkSyADy3OoxcgCssO8LTmw7xlTPHM1O/RFUnYGxKNHNyE1i3s8rqUtRRjDjcjTG3GmNyjTF5wDXABmPM9cBaYJVns1XAGq+rVH7T0z/ArS/tYkxyFN9elm91OSqIXDInm92HWylv6LC6FDUMf/Rzvw84T0T2A+d5HqsA9cA7Byir7+BHK2cRHe6yuhwVRC6aNXhq5pUdevQeiHwS7saYd40xyz33jxhjlhpj8j23jb54D+V7pXVtPPBuKSvnZrNYBwZTJyk7MYpT85J4Zaeedw9EeoVqiHK7Dbe+uIuYCBf/vny61eWoILV8djZ7a9vYV6sXNAUaDfcQ9czmQ2yuaOK2i6aRGhthdTkqSF04KxOHwDo9NRNwNNxDUF1rN//1pz0snJDClfNzrS5HBbH0uEgWTUrlpU8O43brWDOBRMM9BN21rpiefjf3Xj5LhxhQXrtiXi6VTV1srtCv1wKJhnuIebu4lld3VfPtpfk6TrvyifNnZBAT7uTFbYetLkUNoeEeQjp6+rl9zW4mZ8TyT2dNsLocZRPR4S4unJXFq7uq6erVybMDhYZ7CPnF2/uoaunmvy6fRbhLd73yncvn5dDe06+DiQUQ/YSHiN2HW3jsgwq+eNpY5o9LtrocZTMLxqeQkxilp2YCiIZ7CBhwG257aRdJ0WHccsFUq8tRNuRwCJedksN7++s53NxldTkKDfeQ8GThp+yobOE/lk8nITrM6nKUTf3DqWMwwHObD1ldikLD3fZqW7u5//W9nJWfyqVzsq0uR9nYmORozspP47kth+gfcB//CcqvNNxt7q51RfQNuPnRypnap1353bWnjaG6pZt39+oEPFbTcLexDSW1vLarhpuX5jMuRfu0K/9bOi2DtLgInt500OpSQp6O8Roknio8uQ9Lb7+bX6zfR3pcBHGRrpN+vlIjEeZ0cHVBLg++e4Cq5i6yE6OsLilk6ZG7Ta0vqaW5s48Vc3NwOXQ3q9FzzaljMcAfPv7U6lJCmn7qbai6pYsPShsoGJekQwyoUTcmOZrzpmXw9KaDesWqhTTcbcZtDC9/cpioMCcXzMy0uhwVor585niaOvt4ebte1GQVDXeb2VTeyKGmLi6alaXT5inLnDY+mRnZ8Tz2fjnG6FDAVtBwt5HW7j7eKKphYloMc8ckWl2OCmEiwj8uGs/+unbeL22wupyQpOFuI6/urGbAbVgxN0f7tCvLLZ+TRWpsBI++V251KSFJw90m9tW2setwC4unpOm0eSogRLic3LQoj4376tl9uMXqckKOhrsN9A24WbujitTYCBbnp1ldjlJ/dcPCccRFuvj1O6VWlxJyNNxt4J29dTR29LJibjYup+5SFTjiI8NYtTCP14tqKK1rs7qckKJJEOTqWrt5b18Dp4xJZGJarNXlKPU5Ny3KI9Ll5IF3DlhdSkjRcA9ixhjW7KgizCVcOCvL6nKUGlZKbARfPG0sa3ZUUdHQYXU5IUPDPYh9cqiZ8oYOLpiRRWyE9mlXgetriycQ5hR+8fY+q0sJGRruQaqzt5/XdlUzNjmagrwkq8tR6pjS4yO58YzxrNlRRUlNq9XlhAQN9yD1+u4auvsGWDE3G4f2aVdB4GuLJxAb4eKnb+y1upSQoOEehD490sGWT5tYNDGVrAQdUlUFh8TocL569gTe3lPH1k8brS7H9jTcg8yA2/Dy9sMkRIWxZFq61eUodVJuWjSe1NgI7n2tRMec8TMN9yDzQWkDta09XDI7mwiX0+pylDopMREuvv+FyWz9tIm1O6qsLsfWRtzFQkTGAL8HMgE38LAx5pcikgw8C+QBFcDVxpgm70tVTZ29rC+pZVpWPNOz460uR4UgX8zo5TaG7IRIbl9TRFNHH+Gu4Y8xrz19rNfvFcq8OXLvB/7VGDMNWAB8Q0SmA7cA640x+cB6z2PlJWMM6zxHOpfM1j7tKng5RLh4djYtXX28t18n0vaXEYe7MabaGLPNc78N2APkACuAxz2bPQ6s9LZIBXuqWympaWPZtAwSo8OtLkcpr4xPjWFWTgIb99XT2NFrdTm25JNz7iKSB5wCFAIZxphqGPwDAAz7rZ+IrBaRLSKypb5e/3ofS0dPP+t2VpMZH8kZE1OtLkcpn7hoVhYOh7Bm+2H9ctUPvA53EYkF/gh8xxhzwlcnGGMeNsYUGGMK0tJ0JMNj+flb+2jp6mPF3GycDu3TruwhISqM86dnsL+unZ06JLDPeRXuIhLGYLA/aYx50bO4VkSyPOuzgDrvSgxtOw4189gH5ZyWl8y4FJ3sWtnLggkp5CRG8erOap1M28dGHO4yONXPb4E9xpj/HrJqLbDKc38VsGbk5YW23n43P/zjTtLiInSya2VLDhEuOyWHzt5+Xt2lXSN9yZsj90XADcASEdnu+bkIuA84T0T2A+d5HqsReGjjAUpq2rhn5Swiw7RPu7Kn7MQozp6cxraDzeyp1nFnfGXE/dyNMe8DRzsBvHSkr6sG7a9t43837OeSOdksm57hk/7FSgWqJVPTKalu4+VPDjMuOZpoHeXUa3qFagAacBt+8MedxEa4uOOS6VaXo5TfuRwOrpyfS0dvP2t2VGnvGR/QcA9Aj39YwScHm7n9kuk62bUKGdmJUSyblsGuwy1sO9hsdTlBT8M9wBxq7OQnb+zlnClprJybY3U5So2qsyenMT41hnU7qiirb7e6nKCm4R5ABtyG7z2/A4fAPZfNQnScdhViHCJcXTAGp0P41tOf0NOv3SNHSsM9gDz6XhmF5Y3ceekMchJ1nHYVmhKiwrhyfi5FVa3857piq8sJWhruAaKoqoWfvrmXC2ZkcuX8XKvLUcpS07Li+eriCTxZeJA/bq20upygpOEeALr7Bvjus9tJig7n3sv1dIxSAN8/fwoLJiRz28u7KK7S/u8nS8M9APz49RL21bbzk6vmkByjIz4qBeByOvjfL84jISqM1U9s4Uh7j9UlBRUNd4u9t7+e331QwY1n5LF4sg6gptRQaXERPHxDAfVtPXz9D9vo7XdbXVLQ0HC3UFNHL997fgeT0mO55cKpVpejVECaMyaR+6+czaaKRm5fs1svcDpBeo2vRdxuw788t52mjj5+u+pUHTtGqWNYMTeH/bXt/OqdUsamRPPP50yyuqSAp+FukQc3HuCdvfXcvXImM3MSrC5HqYD3L+dN5lBTJ/e/vpecxChW6EV+x6ThboEPSxv42Zt7WTE3m+t1EmClTojDIdx/5WxqW7v53vM7SImJ4Mx8nZnsaPSc+yg7eKSTbzy1jQlpsdyrV6EqdVIiXE5+c0MBE9NiWf3EFrYdbLK6pICl4T6K2rr7+MrvN+M28OiXCojRYU2VOmkJUWH8/sunkRYXwY2PbdIx4I9Cw32UDLgN3312OwfqO3jgunnkpeqUeUqNVHpcJH/48ulEh7u4/tFC9ta0WV1SwNFwHwXGGG5fs5u399RxxyXTWTRJzxMq5a0xydE8vXoBLqdw7SMfU1KjR/BDabiPgv/dUMqThQf52uKJfGlhntXlKGUb41NjeGb1QsKcDq59pJBdlS1WlxQwNNz97ImPKvjvt/ZxxbxcfnjBFKvLUcp2BgN+AVFhTr74yMd8eKDB6pICgoa7Hz3xUQX/saaIZdMyuO8K7RmjlL/kpcbwx6+fQXZiJDc+tplXd1ZbXZLlNNz95Pcf/SXY03ngunmEOfWfWil/ykyI5LmvLmRWbgLfeGobv9qwP6SHKtDE8TFjDP/91j5u/2uwzyfcpf/MSo2GxOhwnvzK6aycm81P39zHd5/dTldvaM7mpB2tfahvwM2/v7SbZ7cc4qr5udx7+Sw9YldqlEWGOfn5P8xlUnosP3trHyU1bTxw3TwmpMVaXdqo0uTxkbq2bq57pJBntxzi5iWTuP/K2RrsSllERPjmknz+76bTqG3t5tJffcALWytD6jSNpo8PbCpvZPn/vM+uwy388pq5/Mv5U/TLU6UCwOLJabx681lMy4rje8/v4KtPbKUhRCb90HD3QnffAD96pZh/ePgjosOdvPSNM3SkOqUCTHZiFM+sXsi/XTSVd/fWs/RnG/nDx58y4Lb3UbyG+wht3FfPRf/zHo++X851p4/l1ZvPYmpmvNVlKUqMSgYAAAeQSURBVKWG4XQIq8+eyGvfPpNpWXH8+8u7ueyBD2zdJ16/UD1J+2rbuP/1Et7eU8e4lGie+PJpnJWv0+MpFQwmpcfx9D8tYM32Ku77UwnXPlLIWfmpfGdZPvPHJVtdnk9puJ+gHYeaefDdA7xeVENshItbL5zKjYvyiHDpDEpKBRMRYeUpOVwwM5MnPvqUB94t5YoHP2Le2ES+ctYElk3LsEX3ZQ33Y2jq6OW13dU8vekguw+3Ehfp4uYlk7hp0XiSYsKtLk8p5YXIMCf/dPYErlswlue3VPLo+2X885PbSI4JZ+XcHJbPyWJubiIOR3B2jtBwH8IYQ2ldOx+UNrC+pI4PDxxhwG2YmhnHf66YwcpTcoiPDLO6TKWUD0WHu1h1Rh7XLxjHn/fX8/yWQzzxcQWPfVBORnwES6ams2hSKgsnpJASG2F1uSfMb+EuIhcAvwScwKPGmPv89V4j0dHTz6dHOqk40kFpXTs7K5vZfqiZhvZeAPJSoll99gQumpnFzJx47dqolM05HcK5U9I5d0o6LZ19bNhby+u7a3hlRzVPbzoEQHZCJNOzE5ieHc+M7HgmZ8SRlRAZkBPc+yXcRcQJ/Bo4D6gENovIWmNMsS/fp7tvgMqmLnr6B+jpd9PT56anf4Defjc9/W66+wZo6eqjqbOXxo4+Gjt6aGjv5WBjJ/Vtf+vrKgITUmM4Oz+N08Yns2hSKmOSo31ZqlIqiCREh3HZKblcdkou/QNudh5uYXN5I8XVrRRVtbKhpJahPSlTY8PJSogiOzGS1NgI4qPCSIgKIz5y8DYyzEGY04HLKYQ7B++HOR2Eu4T4yDDS4yN93gZ/HbmfBpQaY8oAROQZYAXg03AvqWlj5a8/OO52ToeQFB1OckwYyTHhnDsljXEpMeSlxDAuJZq81Bhidco7pdQwXE4H88YmMW9s0l+XdfUOUFLTyoH6Dqqbu6hq6aaquYsD9R1sqWiipauP/hPsR3/x7Cx+fe0839ft81cclAMcGvK4Ejh96AYishpY7XnYLiJ7fVxDKmDfTqx/o+20n1Bp6zHbed0oFuJnx2znA8ADI2/suKOt8Fe4D3eC+u/+jBljHgYe9tP7IyJbjDEF/nr9QKHttJ9Qaau207/81ZmzEhgz5HEuUOWn91JKKfUZ/gr3zUC+iIwXkXDgGmCtn95LKaXUZ/jltIwxpl9Evgm8wWBXyMeMMUX+eK9j8NspnwCj7bSfUGmrttOPJJTGN1ZKqVAR/AMoKKWU+hwNd6WUsqGgCncRSRaRt0Rkv+c2aZhtIkVkk4jsEJEiEbnrM+u/JSJ7PevuH7L8VhEp9az7wmi051i8bauI3Ckih0Vku+fnIs/yPBHpGrL8odFs12f5q52edQGzT33xu+vZ5nsiYkQk1fM4oPanpya/tNWzzDb7VETuFpGdnv32pohke5b7Zp8aY4LmB7gfuMVz/xbgx8NsI0Cs534YUAgs8Dw+F3gbiPA8TvfcTgd2ABHAeOAA4Azytt4JfG+Y5+QBu63el6PQzoDap96207NsDIOdFD4FUgNxf/q5rbbap0D8kO1uBh7y5T4NqiN3BocweNxz/3Fg5Wc3MIPaPQ/DPD9/+db468B9xpgez7Z1Q173GWNMjzGmHChlcAgFK3nb1mDhr3YG2j71RTt/DvyAwN/H/mqrrfapMaZ1yKYx+Hi/Blu4ZxhjqgE8t+nDbSQiThHZDtQBbxljCj2rJgNniUihiGwUkVM9y4cbLsHqyVC9bSvANz3/7XvsM/9lHC8in3j+Dc7yWwtOjL/aGWj71Kt2isilwGFjzI5hnhZI+xP811Zb7VPPuntE5BCDoy3cPuRpXu/TgBstS0TeBjKHWXXbib6GMWYAmCsiicBLIjLTGLObwfYmAQuAU4HnRGQCJzBcgj/4ua0PAncz2I67gZ8B/whUA2ONMUdEZD7wsojM+MxRhE9Z1M5R36f+aidQ5nmN84d5yqjvT7CsrbbZp57fXYwxtwG3icitwDeBO/DRPg24cDfGLDvaOhGpFZEsY0y1iGQx+JfwWK/VLCLvAhcAuxn8S/+iGTyxtUlE3AwO6mPJcAn+bKsxpnbIaz0CvOLZrgf4y2mprSJygMH/0Wzxtj3HqG3U24kF+9SP7XyDwXPMO2RwXoFcYJuInGaMqWGU96fnvUa9rdhrn+7+zOqngFeBO3z1GQ220zJrgVWe+6uANZ/dQETSPH8hEZEoYBlQ4ln9MrDEs24yEM7gaG1rgWtEJEJExgP5wCY/tuNEeNVWzy/bX1yG55fJ8xyn5/4EBtta5qc2nAi/tJPA26cjbqcxZpcxJt0Yk2eMyWMw5OYZY2oCcH+Cn9qKjfap53H+kE0vHbLcN/t0JN/CWvUDpADrgf2e22TP8mzgNc/92cAnwE4GP+i3D3l+OPAHz/JtwJIh625j8Nv3vcCFNmjrE8Auz7q1QJZn+RVAEYO9DrYBl9ixnYG2T71t52deq4K/9SAJqP3pz7babZ8Cf/Qs2wmsA3J8uU91+AGllLKhYDsto5RS6gRouCullA1puCullA1puCullA1puCullA1puCullA1puCullA39P4jqZ1Il6wgnAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
    "source": [
-    "sns.distplot(logZs)"
+    "can we wrap all of this functionality into something easy?\n"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 3,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "let's see if we can't get the twisting functions..."
+    "class CSMCWrapper(object):\n",
+    "    \"\"\"\n",
+    "    container for monitoring csmc\n",
+    "    \"\"\"\n",
+    "    def __init__(self, csmc_object, rs):\n",
+    "        \"\"\"\n",
+    "        wrap\n",
+    "        \"\"\"\n",
+    "        assert csmc_object.twisting_iteration == 1\n",
+    "        self.csmc_object = csmc_object\n",
+    "        self.rs = rs\n",
+    "        \n",
+    "        self.Xs_container = []\n",
+    "        self.agg_works = []\n",
+    "        self.bootstrap_logZs = []\n",
+    "        self.out_containers = []\n",
+    "    \n",
+    "    def run_twist_iteration(self):\n",
+    "        re_rs, run_rs = random.split(self.rs)\n",
+    "        self.rs = re_rs\n",
+    "        Xs, works = twisted_smc(self.csmc_object, run_rs, aggregate_works=False)\n",
+    "        bootstrap_logZs = bootstrap_logZ(works)\n",
+    "        adp_fns_dict = self.csmc_object.get_ADP_fn()\n",
+    "        out_container = adp_fns_dict['ADP'](Xs, works, verbose=True)\n",
+    "        self.csmc_object.update_cSMC(new_A_params=out_container['out_A_params'],\n",
+    "                                     new_b_params=out_container['out_b_params'],\n",
+    "                                     new_A0=out_container['out_A0'],\n",
+    "                                     new_b0=out_container['out_b0']\n",
+    "                                    )\n",
+    "        \n",
+    "        #report\n",
+    "        self.Xs_container.append(np.asarray(Xs))\n",
+    "        self.agg_works.append(np.asarray(jnp.cumsum(works, axis=0)))\n",
+    "        self.bootstrap_logZs.append(np.asarray(bootstrap_logZs))\n",
+    "        self.out_containers.append(out_container)\n",
+    "        \n",
+    "    "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
-      "dict_keys(['sum_square_diffs', 'loss', 'scipy_loss', 't0_scipy_loss', 'get_callback_fn', 'np_scipy_loss', 'np_t0_scipy_loss', 'np_scipy_loss_grad', 'np_t0_scipy_loss_grad', 'ADP'])\n"
+      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[2]),).\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[2]),).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[], weak_type=True)).\n",
+      "DEBUG:absl:Compiling _where for args (ShapedArray(bool[]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[])).\n",
+      "DEBUG:absl:Compiling _split for args (ShapedArray(uint32[1000,2]),).\n",
+      "DEBUG:absl:Compiling _cumulative_reduction for args (ShapedArray(float64[1]),).\n",
+      "DEBUG:absl:Compiling _uniform for args (ShapedArray(uint32[1000,2]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[], weak_type=True)).\n",
+      "DEBUG:absl:Compiling _searchsorted for args (ShapedArray(float64[1]), ShapedArray(float64[1000])).\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _normal for args (ShapedArray(uint32[1000,2]),).\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 13.29it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(float64[1000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 37.44it/s]\n",
+      "100%|██████████| 1000/1000 [00:01<00:00, 547.87it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      " 11%|█         | 1/9 [00:00<00:03,  2.06it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:02,  2.46it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:00<00:02,  2.88it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:01<00:01,  3.33it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:01,  3.75it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:01<00:00,  4.13it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:01<00:00,  4.45it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:01<00:00,  4.67it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "100%|██████████| 9/9 [00:02<00:00,  4.42it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 0\n",
+      "Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
+      "DEBUG:absl:Compiling _cumulative_reduction for args (ShapedArray(float64[10,1000]),).\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 16.00it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(float64[1000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 35.93it/s]\n",
+      "100%|██████████| 1000/1000 [00:01<00:00, 528.80it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:01,  5.09it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:01,  4.84it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:00<00:01,  4.88it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:00<00:00,  5.00it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:00,  4.84it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:01<00:00,  4.71it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:01<00:00,  4.77it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:01<00:00,  4.93it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "100%|██████████| 9/9 [00:01<00:00,  4.90it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 1\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 15.57it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(float64[1000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 36.36it/s]\n",
+      "100%|██████████| 1000/1000 [00:02<00:00, 412.81it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:02,  3.96it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:01,  4.04it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:00<00:01,  3.94it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:01<00:01,  3.79it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:01,  3.68it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:01<00:00,  3.65it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:01<00:00,  3.75it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:02<00:00,  3.67it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "100%|██████████| 9/9 [00:02<00:00,  3.79it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 2\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 11.79it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[1000,1]), ShapedArray(float64[1000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 32.15it/s]\n",
+      "100%|██████████| 1000/1000 [00:02<00:00, 399.87it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:02,  3.93it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:01,  4.04it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:00<00:01,  4.08it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:00<00:01,  4.06it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:01,  3.97it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:01<00:00,  4.03it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:01<00:00,  4.11it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:01<00:00,  4.21it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "100%|██████████| 9/9 [00:02<00:00,  4.17it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 3\n"
      ]
     }
    ],
    "source": [
-    "ADP_dict = smc_obj.get_ADP_fn()\n",
-    "print(ADP_dict.keys())\n",
-    "ADP_fn = ADP_dict['ADP']"
+    "controller = CSMCWrapper(smc_obj, rs = random.PRNGKey(42))\n",
+    "for i in range(4):\n",
+    "    controller.run_twist_iteration()"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 39,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/9 [00:00<?, ?it/s]Level 9:absl:get_compile_options: num_replicas=1 num_partitions=1 device_assignment=(0,)\n",
-      "100%|██████████| 9/9 [00:02<00:00,  4.22it/s]\n"
-     ]
-    }
-   ],
    "source": [
-    "out_dict = ADP_fn(Xs, logWs, prop_params, verbose=True)"
+    "let's plot the distribution of bootstrapped logZs"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'out_A_params': DeviceArray([[0.2411808 ],\n",
-       "              [0.21533811],\n",
-       "              [0.18930966],\n",
-       "              [0.16301932],\n",
-       "              [0.13656297],\n",
-       "              [0.10978213],\n",
-       "              [0.08282571],\n",
-       "              [0.0554628 ],\n",
-       "              [0.02790665]], dtype=float64),\n",
-       " 'out_b_params': DeviceArray([[0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.]], dtype=float64),\n",
-       " 'out_A0': DeviceArray([0.23910038], dtype=float64),\n",
-       " 'out_b0': DeviceArray([1.96265843e-05], dtype=float64),\n",
-       " 'loss_trace': [array([0.0954322 , 0.07760967, 0.03809855]),\n",
-       "  array([0.6508939]),\n",
-       "  array([0.64992903]),\n",
-       "  array([0.62721856]),\n",
-       "  array([0.62440323]),\n",
-       "  array([0.59485347]),\n",
-       "  array([0.55998865]),\n",
-       "  array([0.5919984]),\n",
-       "  array([0.55580362]),\n",
-       "  array([0.5492683])]}"
+       "Text(0.5, 1.0, 'bootstrapped logZs')"
       ]
      },
-     "execution_count": 40,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd5xU5dnw8d81ZQssSEcEHyEGNVIkFqzwoEYlRdREAvbOYyFq8lpjouR9NC+JxGgs8eFVFA0EMTH2FEuI9ZUAgmJBUUBWV8CFBbbNzsy53j/OmdnZZZadXfbM7Fmu7+czn5k5Zea+t8w1192OqCrGGGPMzoQKXQBjjDGdnwULY4wxrbJgYYwxplUWLIwxxrTKgoUxxphWWbAwxhjTKgsWptMQkbUi8q1ClyNIRGSGiPyhhX0TRKQ832UyXZMFC9PlicgiEbk4x2MfFpFb/S5TkIjIT0WkutmtRkRURM4tdPlMfliwMKYNRCRS6DLkm6r+UlXLMm/Ab4H3gT8XuHgmTyxYmM7mMBF5X0S2iMhDIlKS2iEil4jIahHZLCJPi8heGfuOEpF/i8hW7/4ob/ttwDjgHu8b8T3i+q2IbPSOf0dERorINOAs4Drv2Ge811grIteLyDtAjYhEROQGEflERLZ75T0toyzni8jrInK39/ofisjxGfsXicj/EZHF3v6nRKRPxv4jROQNEakSkRUiMiFj3zAR+Zf3vi8A/XL9wYrIN7z3rhKR90RkUsa+viLyjIhs835+t4rIay28zneAK4HTVbXG23a9iHzulWtVZn1NF6GqdrNbp7gBa4GVwN5AH+B14FZv33HAV8DBQDFwN/CKt68PsAU4B4gAZ3jP+3r7FwEXZ7zPScBSoBcgwDeAQd6+h1Pv2axcy71ylXrbJgN74X7hmgLUZLzG+UAC+DEQ9fZvBfpklOdzYCTQHffb+R+8fYOBSuA73muf4D3v7+1/E7jD+xmMB7anzs3y85wAlHuPo8Bq4KdAkffz3A7s7+1f4N26AQcC64HXsrzmUK88UzO27e8dv1fGMfsW+u/Jbh17s8zCdDb3qOp6Vd0M3Ib7wQ/uN/45qrpMVWPAjcCRIjIU+C7wsao+qqoJVf0j8CFwcgvvEQd6AAcAoqofqGpFK+X6nVeuOgBVfVxVv1BVR1UfAz4GxmYcvxG4U1Xj3v5VXjlTHlXVlep+M/858EMRCQNnA8+r6vPea78ALAG+IyL/ARwG/FxVY6r6CvBMK+VOOQIoA2aqaoOqvgw8C5zhve8PgFtUtVZV3wfmNn8BESkGHgfmqeqCjF1J3OB1oIhEVXWtqn6SY7lMQFiwMJ3N+ozH63C/vePdr0vtUNVq3G+4g5vvyzh3cLY38D4o7wHuBTaIyGwR6dmGciEi54rIcq9Jpwo3S8hsEvpcVTNX6cysS/PXW4f7zb8fsA8wOfW63msfAwzyzt/iBZjMc3OxF7BeVZ1m5w4G+uNmZJllalJfz124GdP/ytyoqquBq4EZwEYRWZDZRGi6BgsWprPZO+PxfwBfeI+/wP0gBUBEugN9cZtzmuzLOPdz7/EOSyur6u9U9RBgBLAfcG1LxzbfLiL7AP8XmI7b1NULt/lMMo4fLCKZzzPrkq2ecdxmtvW4WUevjFt3VZ0JVAC9vbpnnpuLL4C9RSTzfz71M9qEGwSGtFA+ROQc3Ozjh6oab/7iqjpfVY/B/T0o8Kscy2UCwoKF6WyuEJEhXofvT4HHvO3zgQtEZIzXHPJL4C1VXQs8D+wnImd6nc9TcNvdn/XO3QB8LfUGInKYiBwuIlHcvoZ63KaUHY5tQXfcD8RN3utdgJtZZBoAXCkiURGZjNsv8nzG/rNF5EAR6Qb8b+BPqpoE/gCcLCIniUhYRErEnS8xRFXX4TZJ/UJEikTkGFpuamvuLa+u13llmuCdu8B73yeAGSLSTUQOANJDYkVkJHAfcJaq7pBxiMj+InKc93upB+po/HmaLsKChels5gP/AD71brcCqOpLuG37f8b9hr0vMNXbVwl8D7d5pBK4Dvieqn7lveZdwOnijrD6HdATNzPYgtsUUwnM8o59ELftvUpEnsxWQK9N/ze4nc0bgFG4nfGZ3gKG42YLt+GOHKrM2P8obmf6l0AJ7ugivA/jU3AD5SbcTONaGv9XzwQOBzYDtwCPtPBzbF7mBmAS8G2vTPcB56rqh94h04E9vPI8CvwRiHn7foIbIJ+QHedb/BS3v2Km97pf4gbKn+ZSLhMc0rRZ1Rizq0TkfNzRV8e0sH8R7gimB/JZrrYQkV8Be6rqeYUui+kcLLMwxiAiB4jIaHGNBS4C/lLocpnOw7dgISJzxJ30tDJjWx8ReUFEPvbue2fsu1HcCVerROSkjO2HiMi73r7fNes0NMZ0jB64/RY1wELcZranCloi06n41gwlIuOBauARVR3pbfs1sFlVZ4rIDUBvVb1eRA7EbSMdizvE70VgP1VNishi4Crg/+F2EP5OVf/qS6GNMcZk5Vtm4U0Y2txs8yk0TvaZC5yasX2BN9FoDe5M07EiMgjoqapvemPWH8k4xxhjTJ7ke1G0gamZsqpaISIDvO2DcTOHlHJvW9x73Hx7VuKu7TMNoHv37occcMABHVh0Y9pv1apVAOy///4FLokxO7d06dKvVLV/8+2dZQXNbP0QupPtWanqbGA2wKGHHqpLlizpmNIZs4smTJgAwKJFiwpaDmNaIyJZVwXI92ioDV7TEt79Rm97OU1njA7BnXFaTtNZpantxhhj8ijfweJpIDVu+zwaR1s8DUwVkWIRGYY7mWmx12S1XdwlmwV3VqmN0DDGmDzzrRlKRP6Iu0RyP3Ev7XgL7izPhSJyEfAZ7jLPqOp7IrIQ92IqCeAKbwkCgMtwZ7qWAn/1bsYYY/LIt2Chqme0sCvrRVFU9TbcZRGab1/CjuvuGGN8EI/HKS8vp76+vtBFMT4rKSlhyJAhRKPRnI7vLB3cxphOoLy8nB49ejB06FBs/mvXpapUVlZSXl7OsGHDcjrHlvswxqTV19fTt29fCxRdnIjQt2/fNmWQFiyMMU1YoNg9tPX3bMHCGGNMq6zPwhjTovlvfdahr3fm4ble2C//Fi1aRFFREUcddVSbznv44YdZsmQJ99xzDzNmzKCsrIxrrrkm5/PLysqorq7eYfttt93G/PnzCYfDhEIh/ud//ofDDz+cCRMm8Omnn7Ju3bp0dnDqqafy4osvpl/no48+4uqrr+ajjz4iGo0yatQo7r77bgYOHNimumWyYGGMMbjBoqysLGuwSCQSRCL5+7h88803efbZZ1m2bBnFxcV89dVXNDQ0pPf36tWL119/nWOOOYaqqioqKirS++rr6/nud7/LHXfcwcknuxdS/Oc//8mmTZt2KVhYM5QxptNYu3YtI0c2jpSfNWsWM2bMANwlU66//nrGjh3Lfvvtx6uvvgpAMpnkmmuuYdSoUYwePZq7774bgJdeeolvfvObjBo1igsvvJBYzL3w39ChQ7nllls4+OCDGTVqFB9++CFr167l/vvv57e//S1jxozh1Vdf5fzzz+cnP/kJxx57LNdffz2bN2/m1FNPZfTo0RxxxBG88847O63LJ598wsSJEznkkEMYN24cH37oXpRwzZo1HHnkkRx22GH8/Oc/z3puRUUF/fr1o7i4GIB+/fqx1157pfdPnTqVBQsWAPDEE0/w/e9/P71v/vz5HHnkkelAAXDsscc2+bm2hwULY0xgJBIJFi9ezJ133skvfvELAGbPns2aNWt4++23eeeddzjrrLOor6/n/PPP57HHHuPdd98lkUjw+9//Pv06/fr1Y9myZVx22WXMmjWLoUOHcumll/LjH/+Y5cuXM27cOMBtznnxxRf5zW9+wy233MI3v/lN3nnnHX75y19y7rnnZi1jyrRp07j77rtZunQps2bN4vLLLwfgqquu4rLLLuPf//43e+65Z9ZzTzzxRNavX89+++3H5Zdfzr/+9a8m+48//nheeeUVkskkCxYsYMqUKel9K1eu5JBDDmn7D7cVFiyMMYGR+gZ9yCGHsHbtWgBefPFFLr300nQzUZ8+fVi1ahXDhg1jv/32A+C8887jlVde2enrZDN58mTC4TAAr732Gueccw4Axx13HJWVlWzdujXredXV1bzxxhtMnjyZMWPG8F//9V/ppqLXX3+dM85w5yynXq+5srIyli5dyuzZs+nfvz9Tpkzh4YcfTu8Ph8Mcc8wxPPbYY9TV1TF06NAW69BRrM/CGNNpRCIRHMdJP28+DyDVLBMOh0kkEoA7waz5MNDWLuqW7XWy6d69+05fs6Xhp47j0KtXL5YvX551fy7DVsPhMBMmTGDChAmMGjWKuXPncv7556f3T506ldNOOy3dTJcyYsSIHTKRjmCZhTGm0xg4cCAbN26ksrKSWCzGs88+2+o5J554Ivfff3/6Q3/z5s0ccMABrF27ltWrVwPw6KOP8p//+Z87fZ0ePXqwffv2FvePHz+eefPmAW5neL9+/ejZs2fWY3v27MmwYcN4/PHHATfQrFixAoCjjz463d+Qer3mVq1axccff5x+vnz5cvbZZ58mx4wbN44bb7wxnaWknHnmmbzxxhs899xz6W1/+9vfePfdd1usWy4sszDGtCjfQ12j0Sg333wzhx9+OMOGDSOXC5hdfPHFfPTRR4wePZpoNMoll1zC9OnTeeihh5g8eTKJRILDDjuMSy+9dKevc/LJJ3P66afz1FNPpTvJM82YMYMLLriA0aNH061bN+bOnZvlVRrNmzePyy67jFtvvZV4PM7UqVM56KCDuOuuuzjzzDO56667+MEPfpD13Orqan70ox9RVVVFJBLh61//OrNnz25yjIhkHaJbWlrKs88+y9VXX83VV19NNBpl9OjR3HXXXTstb2t8uwZ3odnFj0xnEpSLH33wwQd84xvfKHQxTJ5k+32LyFJVPbT5sdYMZYwxplUWLIwxxrTKgoUxxphWWbAwxhjTKgsWxhhjWmXBwhhjTKtsnoUxpmVLHurY1zv0gp3urqqqYv78+el1lHJx1FFH8cYbb7S4/5e//CU//elPs+676aabeOSRR9iyZUvWZcJNI8ssjDGdRlVVFffdd1+bztlZoAA3WLTk5JNPZvHixW16v92VZRbGmE7jhhtu4JNPPmHMmDGccMIJ1NTUMHHiRCZNmsRpp51G7969mTNnDg8++CBr1qzh1ltvTV88qKKigilTprBt27b0KrPPPfccdXV1jBkzhhEjRuywvMYRRxxRoJoGjwULY3ymqoRUceza1q2aOXMmK1euTC/At2DBAl599VUmTZrE559/nl659bXXXmPq1KlNzp0/fz4nnXQSN910E8lkktraWsaNG8c999zT4oJ+JnfWDGWMz7Y+8Rfu3bCRsozVVE1uxo0bx6uvvsr777/PgQceyMCBA6moqODNN9/c4Yp2hx12GA899BAzZszg3XffpUePHgUqdddkwcIYn1XOmQNAn2SywCUJnsGDB7Nlyxb+9re/MX78eMaNG8fChQspKyvbIRiMHz+eV155hcGDB3POOefwyCOPFKjUXZM1QxnjN2+xzlKnay7a2ZGyLRN+5JFHcuedd/Lyyy9TWVnJ6aefzumnn77DuevWrWPw4MFccskl1NTUsGzZMs4991yi0SjxeJxoNJqvanRJFiyMyZO9IjF4908wascPuk6rlaGuHa1v374cffTRjBw5km9/+9vcfvvtjBs3jn/84x98/etfZ5999mHz5s3py55mWrRoEbfffjvRaJSysrJ0ZjFt2jRGjx7NwQcfvEMH93XXXcf8+fOpra1lyJAhXHzxxTtcTMi4bIlyY3y2+oQTia9fDwdt4xvfqIYb1kNJ9ovmFJotUb57sSXKjelENBYDYK8Sr8+ivqqApTGmfSxYGJMn6SS+fltBy2FMe1iwMCZP1PHmWcRavs6zMZ2VBQtj8iSdWSRjBS2HMe1hwcKYfEllFsl4YcthTDtYsDAmTzQ1gTthmYUJHptnYUyepPsskg2FLUgbPP7R4x36epP3m7zT/flcory2tpbJkyfzySefEA6HOfnkk5k5c2bO77u7KUhmISI/FpH3RGSliPxRREpEpI+IvCAiH3v3vTOOv1FEVovIKhE5qRBlNqbdvM6Kxj6L4ASLfMv3EuXXXHMNH374IW+//Tavv/46f/3rX9v03ruTvAcLERkMXAkcqqojgTAwFbgBeElVhwMvec8RkQO9/SOAicB9IhLOd7mNaS/1FhAMYmaRb5lLlF977bVcfvnlPP300wCcdtppXHjhhQA8+OCD/OxnPwOgrKwMgIqKCsaPH8+YMWMYOXIkr776KjfccEN6ifKzzjqryXt169aNY489FoCioiIOPvhgysvL81XVwClUn0UEKBWRCNAN+AI4BZjr7Z8LnOo9PgVYoKoxVV0DrAbG5rm8xrSbJhLeA2+D9Vm0aObMmey7774sX76c22+/nfHjx/Pqq68C8Pnnn/P+++8D7hLlzZf8SC1Rvnz5clasWMGYMWOYOXMmpaWlLF++fIelPjJVVVXxzDPPcPzxx/tXuYDLe7BQ1c+BWcBnQAWwVVX/AQxU1QrvmApggHfKYGB9xkuUe9t2ICLTRGSJiCzZtGmTX1Uwpm3i7ugntdFQbZaPJcoTiQRnnHEGV155JV/72tf8qEaXUIhmqN642cIwYC+gu4icvbNTsmzLuqCVqs5W1UNV9dD+/fvvemGN6QCpzCI9GsrmWeQsH0uUT5s2jeHDh3P11Vf7UYUuoxCjob4FrFHVTQAi8gRwFLBBRAapaoWIDAI2eseXA3tnnD8Et9nKmEBIBwv1vvckrM+iJfleovxnP/sZW7du5YEHHvCtTl1FIYLFZ8ARItINqAOOB5YANcB5wEzv/inv+KeB+SJyB24mMhywK6ybQFDHgdQV8lL5sJMoWHnaqrWhrh0tn0uUl5eXc9ttt3HAAQdw8MEHAzB9+nQuvvji/FQ2YAqyRLmI/AKYAiSAt4GLgTJgIfAfuAFlsqpu9o6/CbjQO/5qVW11fJstUW46A6ehgVWjDwJgj6/VsNfYrXDMT+BbtxS4ZNnZEuW7l7YsUV6QSXmqegvQ/L8lhptlZDv+NuA2v8tlTIeLZ3Rmpzq4A5RZGJNiy30Y46P0sFkyJuU5di1uEzwWLIzxUWawaOyzsKGzJngsWBjjo6aZhTVDmeCyYGGMjzSeLbOwYGGCx4KFMX5KNDY5WZ+FCTJbotwYHzXtswheM9SWxxZ26Ov1nvLDne7P5xLlABMnTqSiooJEIsG4ceO49957CYdtndJsLLMwxkfZR0MFJ1jkW76XKF+4cCErVqxg5cqVbNq0iccf79jrd3QlllkY46MmfRY2z6JVmUuUn3DCCdTU1DBx4kQmTZrEaaedRu/evZkzZw4PPvgga9as4dZbb6WsrIzq6moqKiqYMmUK27ZtI5FI8Pvf/57nnnsuvUT5iBEjdlh5tmfPnoC7mGBDQwMi2ZaiM2CZhTG+0uZ9FqEo78S3UYiVE4KgEEuUn3TSSQwYMIAePXpkXXPKuCxYGOOnZs1Qfysr46zEJzy35rkCFio48rFE+d///ncqKiqIxWK8/PLLflSjS7BgYYyPUn0WSRRUeK+4CIAvqm3h5FzkY4lygJKSEiZNmsRTTz3V+sG7KQsWxvgoFSyckJtZlIr7L9dgl1bNamdLlKeCxaxZs7KuOrtu3ToGDBjAJZdcwkUXXcSyZcsA0kuUN5fq5wC3z+L555/ngAMO8KFWXYN1cBvjo1QHtyMKDogXLJz0lZA6t9aGuna0fC5RXlNTw6RJk4jFYiSTSY477jguvfTSvNU1aAqyRHk+2BLlpjPY9sILfP6jK6mPOOxRluSZ80t5oBQuGHEBPzn0J4Uu3g5sifLdS1uWKLdmKGP8lHRnazshQKE+5E74qkvUFbBQxrSdBQtjfKQJN1hoSFGFWMgdxx+z63CbgLFgYYyfUutAibvqbMyb9FWfqC9goYxpOwsWxvioSWbhQL03Qbguac1QJlgsWBjjpyaZBaQGzMYS1gxlgsWChTE+SmUWhBRVIZ5qhkpaM5QJFgsWxvhIk95yHyHAgdTUMOuzyK49q862xcMPP8z06dPbde69997LmDFj0reRI0ciInzwwQcdXMrOyYKFMX5KupPvUqOhEl6fhWUW2e0sWCSThb1o1BVXXMHy5cvTt0mTJnHWWWftNvNSLFgY4yNNfcCFABVSywrach/ZZS5Rfu2117Jo0SKOPfZYzjzzTEaNGsXatWsZOXJk+vhZs2YxY8YMAD755BMmTpzIIYccwrhx4/jwww93+l7r1q3j+OOPZ/To0Rx//PF89tln6dc54ogjOOyww7j55pspKyvb4dxXXnmFhQsX+poFdTa23IcxfnIy+ywam6Hizo5rFXVGEyZM6NDXW7Ro0U73z5w5k5UrV7J8+fL08YsXL2blypUMGzaMtWvXtnjutGnTuP/++xk+fDhvvfUWl19++U5XkZ0+fTrnnnsu5513HnPmzOHKK6/kySef5KqrruKqq67ijDPO4P7779/hvKqqKi644AIeeeSR9PUwdgcWLIzxUbqDWxQUEuIur5OwCyDlbOzYsQwbNmynx1RXV/PGG28wefLk9LZYbOcjzt58802eeOIJAM455xyuu+669PYnn3wSgDPPPJNrrrmmyXmXXXYZZ599NkcffXSb6xJkFiyM8ZMT7Gao1jKBfOjevXv6cSQSwXEaF2Gsr3f7fhzHoVevXumMpD1yuUre3LlzWbt2LY8++mi73yeorM/CGB+lMgsJeZmFtz0ozVD5lm2J8kwDBw5k48aNVFZWEovFePbZZwH38qjDhg1LX0NbVVmxYsVO3+uoo45iwYIFAMybN49jjjkGgCOOOII///nPAOn9AJ9++ik33XQT8+bNIxLZ/b5nW7AwxkfqJEEE8RYSTOA2QzUkG+zSqllkLlF+7bXX7rA/Go1y8803c/jhh/O9732vyfUn5s2bx4MPPshBBx3EiBEjWr2Q0e9+9zseeughRo8ezaOPPspdd90FwJ133skdd9zB2LFjqaioYI899gDgV7/6FTU1NXz/+99vMoQ2ddnXrs6WKDfGRxt/cweVc+ZQM3g73T/rxvQbitgobjPK2+e8TSTUub6h2hLlUFtbS2lpKSLCggUL+OMf/9hlr6DXliXKO9dfqjFdjCaTEAqRag5POoC7SjlxJ97pgoWBpUuXMn36dFSVXr16MWfOnEIXqVOwv1Rj/JRMIqEQoZCbwTsZmXxDsoHSSGmhSmZaMG7cuFb7O3ZH1mdhjI806fZZ4GUWjqOUeqN5Omsnd1dtmjZNtfX3bMHCGD85TZuhHEfp5rj/pPFk5wsWJSUlVFZWWsDo4lSVyspKSkpKcj7HmqGM8ZEmmjZDqQOl6nZcdMbMYsiQIZSXl7Np06ZCF8X4rKSkhCFDhuR8fEGChYj0Ah4ARgIKXAisAh4DhgJrgR+q6hbv+BuBi4AkcKWq/j3/pTam7bRZZhFSKPW+tXfGYBGNRludLW12T4VqhroL+JuqHgAcBHwA3AC8pKrDgZe854jIgcBUYAQwEbhPRMIFKbUxbZXImGeBGyxSzVBBmcVtDBQgWIhIT2A88CCAqjaoahVwCjDXO2wucKr3+BRggarGVHUNsBoYm99SG9M+mhoN5a0JFXagm3buDm5jsilEZvE1YBPwkIi8LSIPiEh3YKCqVgB49wO84wcD6zPOL/e27UBEponIEhFZYm2uplNIzbPw+ixCDpRaZmECqBDBIgIcDPxeVb8J1OA1ObUg2+peWYdqqOpsVT1UVQ/t37//rpfUmF2UnpSX2QzVifssjGlJIYJFOVCuqm95z/+EGzw2iMggAO9+Y8bxe2ecPwT4Ik9lNWbXOE2bodzMwpqhTPDkPVio6pfAehHZ39t0PPA+8DRwnrftPCC1GMvTwFQRKRaRYcBwYHEei2xMu6nXwR3KyCzSo6E64TwLY1pSqHkWPwLmiUgR8ClwAW7gWigiFwGfAZMBVPU9EVmIG1ASwBWqWtiL8RqTo9TQ2ZDXmBp2oMTrs0ioXQDJBEdBgoWqLgd2WNUQN8vIdvxtwG2+FsoYP3iT8jI7uEu8zCLp2HceExy23IcxPkpnFqlgoVCsllmY4LFgYYyfUn0Wmc1QllmYALJgYYyPtNkS5SFtDBaWWZggySlYiMhVItJTXA+KyDIROdHvwhkTeMlUM5T7NORAsTd01jILEyS5ZhYXquo24ESgP+7opZm+lcqYLkKTzfosHG1shrJBfSZAcg0WqVnU3wEeUtUVZJ9ZbYzJoM0n5WU2QznWDGWCI9dgsVRE/oEbLP4uIj0Ax79iGdNFpDq4vXWSMzu4LViYIMl1nsVFwBjgU1WtFZG+uE1RxpidUCeJRCJNlvuwZigTRLlmFi+o6jJvKXFUtRL4rX/FMqaL8CblhTPnWTg2dNYEz04zCxEpAboB/USkN439FD2BvXwumzGBp47TZDRU2IEoiiA2dNYESmvNUP8FXI0bGJbSGCy2Aff6WC5juoZEounQWYWIQgixPgsTKDsNFqp6F3CXiPxIVe/OU5mM6TI0mURECIcb+ywiqoRFrBnKBEpOHdyqereIHAUMzTxHVR/xqVzGdAnqeNfg9nLykAMRlLCErIPbBEpOwUJEHgX2BZYDqb9wBSxYGLMzSQdCkm7ADSlErRnKBFCuQ2cPBQ5U1ayXMzXGtCCZRATEGzob9pqhQohlFiZQch06uxLY08+CGNMVqeOASPo/LaTuN7SwWGZhgiXXzKIf8L6ILAZiqY2qOsmXUhnTVSSTIKT7LMKOGzcsszBBk2uwmOFnIYzpqlQVCQl4zVARb5GcsIQsszCBkutoqH/5XRBjuqSkmz2kMouIug/CllmYgMl1NNR23NFPAEVAFKhR1Z5+FcyYrsCdwd04dNabbuE2Q9k8CxMguWYWPTKfi8ipwFhfSmRMV+KNhmpshvIyC+vgNgHTrsuqquqTwHEdXBZjuhRVBdWmHdzpzMIuq2qCJddmqO9nPA3hzruwORfG7Ey6v6Jx6Gwqs4gQsmYoEyi5joY6OeNxAlgLnBVw3hwAABfvSURBVNLhpTGmC1HvWtuEsmcW1sFtgiTXPgu70JExbeVlFqlIkRQl7DSOhrI+CxMkOfVZiMgQEfmLiGwUkQ0i8mcRGeJ34YwJMk26mUUqq3CkMbMIY30WJlhy7eB+CHga97oWg4FnvG3GmJak+iSyBIuQLVFuAibXYNFfVR9S1YR3exjo72O5jAk+p1lmEYKwpjq4bVKeCZZcg8VXInK2iIS929lApZ8FMybo0h3cmZlFarkPsD4LEyi5BosLgR8CXwIVwOmAdXobszOpobPef1lmZmGjoUzQ5Dp09r+B81R1C4CI9AFm4QYRY0wW6czCk2ySWdhoKBMsuWYWo1OBAkBVNwPf9KdIxnQRyWYd3CEhlAoWinVwm0DJNViERKR36omXWeSalRizW9LmHdxNhs6KDZ01gZLrB/5vgDdE5E+4y3z8ELjNt1IZ0xWkMouQGyGcEITSk/IsszDBkusM7kdEZAnu4oECfF9V3/e1ZMYEXHpSHqkZ3E0n5VkHtwmSnJuSvODQYQFCRMLAEuBzVf2e17T1GDAUd+2pH2Z0qN8IXAQkgStV9e8dVQ5jfJPKHDJGQ4UyZ3BbB7cJkHYtUd5BrgI+yHh+A/CSqg4HXvKeIyIHAlOBEcBE4D4v0BjTqTWOhnIjRDJE0w5uyyxMgBQkWHjrSn0XeCBj8ynAXO/xXODUjO0LVDWmqmuA1diFl0wQpDq4m82zUNyU3jILEySFyizuBK4DMgeiD1TVCgDvfoC3fTCwPuO4cm/bDkRkmogsEZElmzZt6vhSG9MGmpqU1ySzUFTEmqFM4OQ9WIjI94CNqro011OybMt64SVVna2qh6rqof3729JVpsDS17Nw/4RTfRaKEAEUtRFRJjAKMVfiaGCSiHwHKAF6isgfgA0iMkhVK0RkELDRO74c2Dvj/CHAF3ktsTHtkZ6U15hZFDugIul/vIQmCGNdcKbzy3tmoao3quoQVR2K23H9sqqejbsE+nneYecBT3mPnwamikixiAwDhgOL81xsY9qscVKekiQ1z8LLLLzc2JqiTFB0plnYM4GFInIR8BkwGUBV3xORhbjDdhPAFao2jMQEQPoa3JAQcETcZigJpXMJCxYmKAoaLFR1EbDIe1wJHN/CcbdhM8ZNwKQm5YGSQNKZBUI6s4g78UIVz5g2KeQ8C2O6NqexzyIugiPeaChCRLwxGpZZmKCwYGGMTzKvwZ2QjNFQIkQtszABY8HCGL9o6kp5bjNUagZ3k9FQllmYgLBgYYxPNKODOy54zVCp0VDWDGWCxYKFMX7JGDqbELeDW1S9zMKChQkWCxbG+EQzJuUlkCaZRdQyCxMwFiyM8UtquY+MDm7x1oZKT8qzq+WZgLBgYYxPMhcSTHVwizcaKtVnEU/aaCgTDBYsjPFLeoly9WZwp+ZZNA6dtWYoExQWLIzxSbrPgowObm/obNRbnd+aoUxQWLAwxi/pSXkOcYSkNPZZhG1SngkYCxbG+ESdxsyigcYObmw0lAkgCxbG+MXx0ocQxEnNs0h1cHvNUBYsTEBYsDDGL15mEcJxM4smHdyWWZhgsWBhjE/SS5SL0pDKLLw+i1SwsD4LExQWLIzxS+YS5d48C1ILCTqWWZhgsWBhjE+0yWio5s1Q1mdhgsWChTF+cRqv/htHcETczRYsTABZsDDGJ5pILVHuNDZDAaoZS5TbpDwTEBYsjPGJJtzOawmpez2LdLAgnVlYB7cJCgsWxvhE43EIhRCvgzsdLAjZxY9M4FiwMMYnGo8j4TDgeH0W3nZHEFXCErbMwgSGBQtjfKLxOITDoI2jocC9+BE4hCVsmYUJDAsWxvgklVmIt+psUtymp3RmEQrb9SxMYFiwMMYnjZlF0m2G8paKUgRRh4hEaHAaCltIY3JkwcIYv8QTbp9FqhnK26wqiOMQDoVpSFqwMMFgwcIYn6QzCxziIqQXLFf3UquRUIRYMlbIIhqTMwsWxvgk3WehDgnAweuz0MZmKOuzMEFhwcIYn6TmWaQyi8zRUKJuM5RlFiYoLFgY45P0PAtNksjs4HZwM4uQdXCb4IgUugDGdFWNfRZKUjK2e81QYbGhsyY4LFgY45PGPoskCXHnVoAAIcRxrIPbBIo1QxnjE000Dp1NQHo0lKMQsmYoEzCWWRjjk8yhswkRQriZhTqCOEl3Up7NszABkffMQkT2FpF/isgHIvKeiFzlbe8jIi+IyMfefe+Mc24UkdUiskpETsp3mY1pjyYd3CIkMhYSDDlJm5RnAqUQzVAJ4H+p6jeAI4ArRORA4AbgJVUdDrzkPcfbNxUYAUwE7hORcAHKbUybpDILwSEp7h8+gJMUQpq05T5MoOQ9WKhqhaou8x5vBz4ABgOnAHO9w+YCp3qPTwEWqGpMVdcAq4Gx+S21MW3XmFk4XmbRuJAgQERCllmYwChoB7eIDAW+CbwFDFTVCnADCjDAO2wwsD7jtHJvW7bXmyYiS0RkyaZNm/wqtjE5yVyiPCmQGiTrXSTPgoUJlIIFCxEpA/4MXK2q23Z2aJZtmu1AVZ2tqoeq6qH9+/fviGIa026NFz9y+yziqT9bL7OISoikJu2aFiYQChIsRCSKGyjmqeoT3uYNIjLI2z8I2OhtLwf2zjh9CPBFvspqTLul+izUnZSXyJjBDRD1/v0suzBBUIjRUAI8CHygqndk7HoaOM97fB7wVMb2qSJSLCLDgOHA4nyV15j20ngcCYWAJMnMPotkY58FWLAwwVCIeRZHA+cA74rIcm/bT4GZwEIRuQj4DJgMoKrvichC4H3cASVXqGpyx5c1pvNQ1R36LHbILMQNGjYiygRB3oOFqr5G9n4IgONbOOc24DbfCmVMR0u4/RDiTcpLhjL6LLyvOhHv38AyCxMEttyHMT7QuDv2KXU9C0cg4WUUqby4yIKFCRALFsb4IBUsGpuhBAdFhYzMwuuzsGYoEwAWLIzxgTZphkriuP3caEjSF+NOZRa28qwJAgsWxvggW2bhLjcr6WaoYi9Y1CfqC1RKY3JnwcIYH6T7LEIhBKdpZpEOFu6/X12irkClNCZ3FiyM8UFjZhEiAagIklQvWLijoorFMgsTHBYsjPFB42goaPCCAgkgHEoHixJ1t1tmYYLAgoUxPtCGVDMUxFPBIp1ZuE9LvD6L2kRtIYpoTJtYsDDGB+nMQpSG1BTURNNmqFSwsMzCBIEFC2N8oInGzKJJM1TI7bsAKPImdFuwMEFg1+A2xgfpDu6Q0kBGM1S4MbMI4xANRS1YmECwzMIYH6SCRShEY7BINO2zCCUTFIWLLFiYQLBgYYwPGudZOBkd3EBGn0U42WCZhQkMCxbG+CGzGUqaZhaSESyKQkXUxS1YmM7PgoUxPmhshnIaR0Ol+iy8C1uEEw1Ew5ZZmGCwYGGMDxqHziazjoZSIOI1Q9UnbQa36fwsWBjjg/SqsxJvNikvhCQckqEI4USDdXCbwLBgYYwP0jO4Jd6YWSRTfRYOiVDEOrhNoFiwMMYHGncvaBQi3qQZSkPiZhbhCJFEzM0srIPbBIAFC2N8oA1esAg1UJcKFnGFsDRphrLMwgSFBQtjfODEYhAKEaKB2lDY3djgNkOFkkpc3MzCgoUJCgsWxvhAYw1IJII49dSJt6pO3JvBDTSEiyhqqCEajpLQBPFkvIClNaZ1FiyM8YHGYu4lVZ0YtaEQNCiiuDO4gZgUUxyrpihUBNgy5abzs2BhjA80nplZhN3+CnAn5QENUkxRrJqisBssrCnKdHYWLIzxgROLecEiRl0oDA1esEg1Q0kRRfE6SkJuE1V1Q3XBympMLixYGOODpn0WAnHH3R51O7vjSTej6O64QaQ6bsHCdG4WLIzxgTY0QCSCOLXUeX0WAE7E/ZeLJ92g0SPprldeE68pTEGNyZEFC2N8oKlmqGQN1RnBIpVZJJJu81NPbxSUZRams7NgYYwPnIYYEg4jyRq2hoBatxnKibr/com4Gyx6xdyObcssTGdnwcIYHzg1tUg0jKBsDSnUgUZK2B4pBWBbXQkApdVuRrFh+xaqahvYVh+nJpYg6fVlGNNZ2DW4jWmjRNJhU3WMiq31fLm1noqt9WzcXs/W2jhb6+Jsq49zeflG1vcZwFCgKqTEhn2XhtNP5NpEjL9wE/9atTcTRpWw+p06GA6/ffldfrXwhSbvUxQJ0a0oTGk0TKl3360oTIl33704Qu9uRfQqjdKrW5Re3Yrc+9IienePMrBnCdGwfR80HcOChTFZ1DUkWfNVDZ9+Vc0nG937Zeu2sK0+wfb6OM2/+IdDQrdomJLUh3ushm7RBNtDIRAIffYR0Q8qOeGgvYlFIowJr2Z7pBsHdttISIv42sAw+w4ahAKOo8STDvGkQ0NSiSccGrznlTUNxBMO8aRSH09SG0/SkHCy1kGAfj2KGbRHCXv2LGHQHiUM3MO9H9yrG4N7lzKwRzERCygmBxYszG5LVflyWz2fbqrhsX+vZ9P2GF9Vx9hUHaOqtnH5DQF6dYvSp3sR+/YvY4/SCD1Lo/QqjdKzNMoepVFKo2HEWzBQEnFK59Szb2kdX3kfxOHV7xL6oI6jRx+FUxpir4avaCiOsFd4MyWRnvTsVs/Rg/u1qx4Jx6GuIUltQzJ9XxNLsLU+zrY6N9tZvr6KVz6OUx9vGlhCAoP2KGVw71KG9Cplr17u48EZ9yVep7zZvVmwMF2aqrJxe4y1X9WwrrKWtZWN92u/qqGmIZk+tigSon9ZMUP7dqffPkX0Kyumf49i+pUVt6k5p2T9Gvf19nBYH4m65dicSO+Pl0Yo3RqjOlLKoNg2ikOD2J6obHcdI6EQPUpC9CiJtnpsLJFka12cqtrUrYFe3aJ8XlXHW2s2U7G1boesqV9ZUZPg4T7ult7WsySSDpSm67JgYQJJVamLJ9lSG2fT9hhfev0GX26tZ8O2GBu21bNhWz3lW+qoizcGhJBA725F9C0rYvTeveifERA66kOv++oPACjru52PI2Xuxs2NZWgojdBzQy3bw6Xs31BOSbg71bsQLNqiOBJmQI8wA3qUZN2fdJRt9Y2BZIt3X1UXZ/GaLVTVbiDRLJoURULsURJl/z17sKfXzDVoj1K3+ct7vkdp1AJKwAUmWIjIROAuIAw8oKozC1wk006qSn3coaYhQU0sQU0sSW1DgupYIt2EUhNzn1fVxqnyvglvrWtIP99aG6chuWNbfSQkDOhRzICeJezbv4xxw/vzVXWMvt2L6FtWzB6lUcIhfz+0yj5aSaJbd3qXfMGK4t70aohQWdtY1lhZEUXrtrEh0Z2IJumrEd6PbyLu1BMNZf8Qz5dwSOjdrYje3YqA7jvsV1VqGpJNAkmqqWtdZQ3vlFexvT5B87Fc0bDQsyTKfgN70KfM7ZTvneqQ71ZEb+++rDhCSTREqdf/UxIJEw2LBZpOIBDBQkTCwL3ACUA58G8ReVpV3y9syTqWqmY89u6z7Ndmx7jbdIdtzV+r+XGJpJJwHBJeh2rSUeJJ9e7d5wnH7UxNeB2q9Ykk9XGHmHdfH08SiyepT7iP3Zv32NtW15BMB4bamPs415GhReEQpUXhJqOChvbtRumeEXdbUZgexW4fQo+SCN2LI4SafbB8fUBZbm/WASRWT4+VS3EG9SEsH7O8tC9DqovJzBvqerhLfWyvKoUwjK2tYWU4yfKqv3NYn1PyVtb2EBHKiiOUFUcY0jv7MUlHqY4l2OoFka11jX0nDUmHD77YxpbaBrbW7ThQIJtwSCiJhCiOhikKhyiKeLdsjzO3tbQ943FxJEQ0nLoJReEQ0Ujj8+b7IuEQIXF/DiJuf1Yo/di79x6nj8PbFvCAF4hgAYwFVqvqpwAisgA4BejwYDHpntdYvbF6px/ETf6+tekxLR23sw/6riAaFiKhpv9gEW9bcSRE9yJ3mGdx6p80HKIoGnbvvX9a9z6c/kcuiYSCNVLHSXLgjZcQqa1hyNByJg/ei60Rh5OquvNOxmF1vUpoKInw9Wc+4+PT9+Kqz17jjX0O4MWNs/mkZglT9/7vglWhI4RDwh5ex//OOKrE4g61DW5GWduQTI/6cm+No8LiCfdLTcJR70uMkkw6bkd+naa/2CSSjfvdYxu3dYZ/uVSAyQwckrGvcVuTJzkfm9q+7OcndPjABNEAfGqJyOnARFW92Ht+DnC4qk5vdtw0YJr3dH9gVY5v0Q/4qoOK25ntDvXcHeoIVs+upjPVcx9V7d98Y1Ayi2z52w5RTlVnA7Pb/OIiS1T10PYULEh2h3ruDnUEq2dXE4R6BiXHLwf2zng+BPiiQGUxxpjdTlCCxb+B4SIyTESKgKnA0wUukzHG7DYC0QylqgkRmQ78HXfo7BxVfa8D36LNTVcBtTvUc3eoI1g9u5pOX89AdHAbY4wprKA0QxljjCkgCxbGGGNatVsECxHpIyIviMjH3n0Lc0/d2eIi8raIPNue8wspl3KKSImILBaRFSLynoj8ImPfGBH5fyKyXESWiMjY/NYgN7taT2//j0Rklbfv1/krfe46op7eMdeIiIpI+5a19VkH/N3eLiIfisg7IvIXEemV3xrkpgPqWdDPod0iWAA3AC+p6nDgJe95S64CPtiF8wspl3LGgONU9SBgDDBRRI7w9v0a+IWqjgFu9p53RrtUTxE5FncFgNGqOgKYlZ9it9mu/j4Rkb1xl8n5LA/lba9drecLwEhVHQ18BNyYhzK3x67Ws7CfQ6ra5W+4M7kHeY8HAataOG6I90s4Dni2recX+tbWcgLdgGW4s+HBHW02xXt8BjC/0HXyqZ4LgW8Vuh5+19Pb9ifgIGAt0K/QdfKrnhn7TgPmFbpOftSz0J9Du0tmMVBVKwC8+wEtHHcncB3QfDnTXM8vtJzK6TW1LQc2Ai+o6lverquB20VkPe637c76DW1X67kfME5E3hKRf4nIYXkpddvtUj1FZBLwuaquyFeB22lXf5+ZLgT+6ltJd82u1rOgn0OBmGeRCxF5Edgzy66bcjz/e8BGVV0qIhM6smwdaVfrCaCqSWCM17b7FxEZqaorgcuAH6vqn0Xkh8CDwLc6otxt5XM9I0Bv4AjgMGChiHxNva9s+eRXPYFPvdc4sUMKuot8/n2m3uMmIAHM29Xytlc+6lkoXSZYqGqLH2oiskFEBqlqhYgMwo3YzR0NTBKR7wAlQE8R+YOqng3kcn5edEA9M1+rSkQWAROBlcB5uH02AI8DD3RMqdvO53qWA094wWGxiDi4C7lt6rAK5MjHev4dGAasEHcp0iHAMhEZq6pfdlgFcuTz7xMROQ/4HnB8IYJ+Rtn8rGdBP4d2l2aop3E/CPHun2p+gKreqKpDVHUo7nIiL3uBIqfzO4lWyyki/VOjRUSkFDdz+NDb/QXwn97j44CPfS1t++1qPZ/ErR8ish9QROdZ8TNTu+upqu+q6gBVHer9TZcDBxciUORgl36f4l4Y7XpgkqrW5qXE7bOrf7eF/RzKZwdJoW5AX9yO64+9+z7e9r2A57McP4GmHdxZz+9st1zqCYwG3gbewf22cnPG+ccAS4EVwFvAIYWuk0/1LAL+4G1fhjv6pOD16uh6NnuttXTeDu5d/X2uBtYDy73b/YWuk0/1LOjnkC33YYwxplW7SzOUMcaYXWDBwhhjTKssWBhjjGmVBQtjjDGtsmBhjDGmVRYsjOkgIlLdzvP2Fnel38zbNhH5VUeX0Zj2sqGzxnQQEalW1bIOeJ1RwPPAWPXWAjKm0CyzMKaDiet2EVkpIu+KyBRve0hE7vOuU/CsiDwvIqc3O7cEd22jKyxQmM6ky6wNZUwn8n3caxEchLvm1L9F5BXc9ceGAqNwVwz9AJjT7NxfA6+r6tN5K60xObBgYUzHOwb4o7qrh24QkX/hrm57DPC4qjrAlyLyz8yTROTbuGsBHZrvAhvTGgsWxnQ8aeN2RKQ/8D/AKdq5F8MzuynrszCm470CTPEuYtMfGA8sBl4DfuD1XQzEXbAyZQ5wt6q+nffSGpMDGw1lTAdJjYYS9wISvwa+DShwq6o+JiIh4D7c4PERUAzcAVQDb+CuNJr5D/mCql6bzzoY0xILFsbkkYiUqWq1iPTFzTaO1s55jQljmrA+C2Py61nv4jZFwH9boDBBYZmFMcaYVlkHtzHGmFZZsDDGGNMqCxbGGGNaZcHCGGNMqyxYGGOMadX/B4YFaKb53//DAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "out_dict"
+    "sns.distplot(controller.bootstrap_logZs[0], label=f\"uncontrolled SMC\")\n",
+    "sns.distplot(controller.bootstrap_logZs[1], label=f\"twist 1\")\n",
+    "sns.distplot(controller.bootstrap_logZs[2], label=f\"twist 2\")\n",
+    "sns.distplot(controller.bootstrap_logZs[3], label = f\"twist 3\")\n",
+    "plt.vlines(dG, 0,1000, label=f\"true logZ\")\n",
+    "plt.ylim(0, 1000)\n",
+    "plt.legend()\n",
+    "plt.ylabel('counts')\n",
+    "plt.xlabel(f\"logZ\")\n",
+    "plt.title(f\"bootstrapped logZs\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "alright, can we update the twisting iteration?"
+    "can we plot the starting and final distributions?"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "smc_obj.update_cSMC(out_dict['out_A_params'], out_dict['out_b_params'], out_dict['out_A0'], out_dict['out_b0'])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "well that worked. now we have to see if we can run smc again (twisted) and try to observe an improvement"
+    "from scipy.stats import multivariate_normal"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "2"
-      ]
-     },
-     "execution_count": 42,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "smc_obj.twisting_iteration"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/100 [00:00<?, ?it/s]DEBUG:absl:Compiling vSIS_lower_bound for args (ShapedArray(float64[9,1]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[10,1]), ShapedArray(float64[10,1]), ShapedArray(int64[10]), ShapedArray(uint32[2]), ShapedArray(float64[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1,1])).\n",
-      "100%|██████████| 100/100 [00:03<00:00, 32.27it/s]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
-    "twist1_logZs = []\n",
-    "\n",
-    "for i in tqdm.trange(100):\n",
-    "    rs, run_rs = random.split(rs)\n",
-    "    out_logZ = jvSIS(prop_params, model_params, y,  run_rs, init_params, prop, logw, (init_Xs, init_logws))\n",
-    "    twist1_logZs.append(out_logZ)"
+    "support = np.linspace(-4,4,100)[..., np.newaxis]\n",
+    "init_untwist_dist = np.exp(multivariate_normal.logpdf(support, mean = mu, cov = cov))\n",
+    "_, _, (twist_mu0, twist_cov0) = get_twisted_gmm(controller.csmc_object.init_params['mixture_weights'], \n",
+    "                                               controller.csmc_object.init_params['mus'],\n",
+    "                                               controller.csmc_object.init_params['covs'],\n",
+    "                                               controller.csmc_object.A0,\n",
+    "                                               controller.csmc_object.b0)\n",
+    "init_twist_dist = np.exp(multivariate_normal.logpdf(support, mean = twist_mu0[0], cov = twist_cov0[0]))\n",
+    "final_dist = np.exp(multivariate_normal.logpdf(support, mean = mu, cov = np.array([1.])))\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7ff3d988a048>"
+       "<matplotlib.legend.Legend at 0x7f60dece5860>"
       ]
      },
-     "execution_count": 44,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -338,11 +430,12 @@
     }
    ],
    "source": [
-    "sns.distplot(logZs, label='twist=0 (uncontrolled)')\n",
-    "sns.distplot(twist1_logZs, label='twist=1 (controlled)')\n",
-    "plt.xlabel(f\"logZ\")\n",
-    "plt.vlines(dG,0,1000, label=f\"True logZ\")\n",
-    "plt.ylim(0,1000)\n",
+    "plt.plot(support, init_untwist_dist, lw=3, alpha=.5, label = f\"t=0 untwisted distribution\")\n",
+    "plt.plot(support, init_twist_dist, lw=3, alpha=.5, label=f\"t=0 twisted distribution\")\n",
+    "plt.plot(support, final_dist, lw=3, alpha=.5, label=f\"t=9 (last) final target distribution\")\n",
+    "plt.xlabel(f\"x\")\n",
+    "plt.ylabel(f\"density\")\n",
+    "plt.title(f\"initial and final target distributions\")\n",
     "plt.legend()"
    ]
   },
@@ -350,163 +443,326 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "now, we have to generate ensemble trajectories and works so that we can twist _again_"
+    "so it would appear that we can recover the exact posterior since the prior family includes the posterior.\n",
+    "\n",
+    "In a physics context, this is akin to annealing between an oscillator of spring constant $K_0$ to a spring constant of $2K_0$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, I'll attempt to anneal between two springs of a constant $K_0$ but from $r_0=0$ to $r_1=2$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def new_potential(pos, parameter):\n",
+    "    mod_parameter = parameter[0]\n",
+    "    dim = pos.shape[0]\n",
+    "    r0, r1 = jnp.array([0.0]), jnp.array([2.0])\n",
+    "    k0 = jnp.diag(jnp.ones(dim))\n",
+    "    delta0, delta1 = pos-r0, pos-r1\n",
+    "    return 0.5*((1. - mod_parameter) * jnp.dot(jnp.dot(delta0, k0), delta0) + mod_parameter*jnp.dot(jnp.dot(delta1, k0), delta1))\n",
+    "\n",
+    "#make a dummy potential for fun\n",
+    "def dummy_potential(pos, parameter):\n",
+    "    return 0."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 170,
    "metadata": {},
    "outputs": [],
    "source": [
-    "twist_1_Xs = generate_trajs(prop_params, model_params, y, rs, init_params, init_Xs, prop)\n",
-    "twist_1_logWs = SIS_logW(twist_1_Xs, prop_params, model_params, y, init_params, logw, init_logws, aggregate_works=False)"
+    "#wrap an initializer\n",
+    "def get_test_potential_initializer(dimension):\n",
+    "    potential = new_potential\n",
+    "    mu, cov = jnp.zeros(dimension), jnp.diag(jnp.ones(dimension))\n",
+    "    dG = 0.\n",
+    "    return potential, (mu, cov), dG\n",
+    "\n",
+    "#define some _vanilla_ A, b fns\n",
+    "A_fn = lambda x, params: params\n",
+    "b_fn = lambda x, params: params\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "next, I'll anneal between a gaussian with a covariance of 1 centered at 0 and anneal to the same gaussian, except centered at x=2 (again, over 10 steps)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 268,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
-      "dict_keys(['sum_square_diffs', 'loss', 'scipy_loss', 't0_scipy_loss', 'get_callback_fn', 'np_scipy_loss', 'np_t0_scipy_loss', 'np_scipy_loss_grad', 'np_t0_scipy_loss_grad', 'ADP'])\n"
+      "DEBUG:csmc:instantiating super\n",
+      "DEBUG:csmc:define A, b functions\n",
+      "DEBUG:csmc:getting the parameter lengths\n",
+      "DEBUG:csmc:getting x dimension\n",
+      "DEBUG:csmc:getting the terminal time\n",
+      "DEBUG:csmc:getting the maximum number of twists\n",
+      "DEBUG:csmc:getting prop_params\n",
+      "DEBUG:csmc:getting init_params\n",
+      "DEBUG:csmc:getting model_params\n",
+      "DEBUG:csmc:getting y\n",
+      "DEBUG:csmc:define twisting parameters and parameter caches\n",
+      "DEBUG:csmc:define psi twisting functions\n"
      ]
     }
    ],
    "source": [
-    "ADP_dict = smc_obj.get_ADP_fn()\n",
-    "print(ADP_dict.keys())\n",
-    "ADP_fn = ADP_dict['ADP']"
+    "N,T,Dx = 10000, 10, 1\n",
+    "potential, (mu, cov), dG = get_test_potential_initializer(Dx)\n",
+    "cov = cov[0]\n",
+    "potential_params = jnp.linspace(0,1,T)[..., jnp.newaxis] #define the potential parameters\n",
+    "\n",
+    "prop_params = {\n",
+    "               'potential_params': potential_params,\n",
+    "               'forward_potential_params': potential_params,\n",
+    "               'backward_potential_params': potential_params[1:],\n",
+    "               'dt': dt\n",
+    "               } #potential parameters dictionary goes here\n",
+    "init_params = {'mus': jnp.array([mu]), \n",
+    "               'covs': jnp.array([cov]),\n",
+    "               'mixture_weights': jnp.array([1.])} #define the initial params\n",
+    "model_params=None #there are no model parameters\n",
+    "y=jnp.arange(T) #the y data aren't important. just know that there are the same number of them as there are data\n",
+    "rs = random.PRNGKey(6) #define a random number \n",
+    "\n",
+    "#create the csmc container object\n",
+    "smc_obj= StaticULAControlledSMC(N, \n",
+    "                            potential=potential,\n",
+    "                            forward_potential=potential, \n",
+    "                            backward_potential=potential, \n",
+    "                            A_fn = A_fn,\n",
+    "                            b_fn = b_fn,\n",
+    "                            params_len=1,\n",
+    "                            Dx=1,\n",
+    "                            T=T,\n",
+    "                            max_twists=10,\n",
+    "                            prop_params=prop_params,\n",
+    "                            init_params=init_params,\n",
+    "                            model_params=model_params,\n",
+    "                            y=None\n",
+    "                           ) #create a controlled smc class"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 269,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 9/9 [00:02<00:00,  4.09it/s]\n"
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 19.81it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(float64[10000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 38.91it/s]\n",
+      "100%|██████████| 1000/1000 [00:02<00:00, 444.52it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:02,  3.94it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:01,  3.94it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:00<00:01,  3.94it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n",
+      " 44%|████▍     | 4/9 [00:01<00:01,  3.45it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:01,  3.11it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:01<00:01,  2.95it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:02<00:00,  3.01it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:02<00:00,  2.90it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n",
+      "100%|██████████| 9/9 [00:02<00:00,  3.02it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 0\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 14.91it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(float64[10000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 26.99it/s]\n",
+      "100%|██████████| 1000/1000 [00:03<00:00, 297.99it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:03,  2.40it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:02,  2.51it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:01<00:02,  2.49it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:01<00:01,  2.55it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:01,  2.64it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:02<00:01,  2.73it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:02<00:00,  2.81it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:02<00:00,  2.88it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "100%|██████████| 9/9 [00:03<00:00,  2.80it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 1\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 14.79it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(float64[10000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 22.22it/s]\n",
+      "100%|██████████| 1000/1000 [00:03<00:00, 332.59it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:03,  2.55it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:02,  2.58it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:01<00:02,  2.44it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:01<00:02,  2.34it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:02<00:01,  2.35it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:02<00:01,  2.43it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:02<00:00,  2.30it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n",
+      " 89%|████████▉ | 8/9 [00:03<00:00,  2.19it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH'\n",
+      "100%|██████████| 9/9 [00:03<00:00,  2.27it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 2\n",
+      "DEBUG:csmc:generating SMC variable initializer function\n",
+      "DEBUG:csmc:generating simulation propagation function\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling prop for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(uint32[2])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 14.87it/s]\n",
+      "DEBUG:csmc:generating SMC log weight initializer function\n",
+      "DEBUG:csmc:generating the log weight calculator\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:absl:Compiling log_weights for args (ShapedArray(int64[], weak_type=True), ShapedArray(float64[10000,1]), ShapedArray(float64[10000,1])).\n",
+      "100%|██████████| 9/9 [00:00<00:00, 27.23it/s]\n",
+      "100%|██████████| 1000/1000 [00:03<00:00, 325.51it/s]\n",
+      "DEBUG:csmc:generating approximate dynamic programming functions\n",
+      "DEBUG:csmc:iterating backward...\n",
+      "  0%|          | 0/9 [00:00<?, ?it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 11%|█         | 1/9 [00:00<00:03,  2.67it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 22%|██▏       | 2/9 [00:00<00:02,  2.60it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 33%|███▎      | 3/9 [00:01<00:02,  2.54it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 44%|████▍     | 4/9 [00:01<00:01,  2.53it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 56%|█████▌    | 5/9 [00:01<00:01,  2.57it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 67%|██████▋   | 6/9 [00:02<00:01,  2.64it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 78%|███████▊  | 7/9 [00:02<00:00,  2.71it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      " 89%|████████▉ | 8/9 [00:03<00:00,  2.75it/s]DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "100%|██████████| 9/9 [00:03<00:00,  2.67it/s]\n",
+      "DEBUG:csmc:conducting t=0 twist...\n",
+      "DEBUG:csmc:minimizer message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n",
+      "DEBUG:csmc:finished optimizations; terminating...\n",
+      "DEBUG:csmc:updating cSMC with new parameters\n",
+      "DEBUG:csmc:cacheing parameters at index 3\n"
      ]
     }
    ],
    "source": [
-    "out_dict = ADP_fn(twist_1_Xs, twist_1_logWs, prop_params, verbose=True)"
+    "#29 random key\n",
+    "controller = CSMCWrapper(smc_obj, rs = random.PRNGKey(27))\n",
+    "for i in range(4):\n",
+    "    controller.run_twist_iteration()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 271,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'out_A_params': DeviceArray([[1.14078437],\n",
-       "              [0.92719429],\n",
-       "              [0.73231083],\n",
-       "              [0.55587318],\n",
-       "              [0.40075045],\n",
-       "              [0.26908349],\n",
-       "              [0.16247449],\n",
-       "              [0.08182895],\n",
-       "              [0.02742049]], dtype=float64),\n",
-       " 'out_b_params': DeviceArray([[0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.],\n",
-       "              [0.]], dtype=float64),\n",
-       " 'out_A0': DeviceArray([1.21034982], dtype=float64),\n",
-       " 'out_b0': DeviceArray([0.0048561], dtype=float64),\n",
-       " 'loss_trace': [array([2232.38811346,  821.13728281,  819.6326252 ,  818.34456201,\n",
-       "          818.34456201]),\n",
-       "  array([651.39607831,  30.73995716]),\n",
-       "  array([189.80606019,  24.69034995]),\n",
-       "  array([2223.89044803,   18.82275719]),\n",
-       "  array([5998.92824669,   15.92329024]),\n",
-       "  array([10.63161091]),\n",
-       "  array([7.22675448]),\n",
-       "  array([4.78205351]),\n",
-       "  array([2.68082285]),\n",
-       "  array([1.15562279])]}"
+       "Text(0.5, 1.0, 'bootstrapped logZs')"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 271,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "out_dict"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "on a note, its strange that the new A parameters have changed more in this iteration than they have in the previous...i suspect this will be detrimental to the smc logZ estimator. let's find out."
+    "sns.distplot(controller.bootstrap_logZs[0], label=f\"uncontrolled SMC\")\n",
+    "sns.distplot(controller.bootstrap_logZs[1], label=f\"twist 1\")\n",
+    "sns.distplot(controller.bootstrap_logZs[2], label=f\"twist 2\")\n",
+    "sns.distplot(controller.bootstrap_logZs[3], label = f\"twist 3\")\n",
+    "#sns.distplot(controller.bootstrap_logZs[4], label = f\"twist 4\")\n",
+    "#sns.distplot(controller.bootstrap_logZs[5], label = f\"twist 5\")\n",
+    "#sns.distplot(controller.bootstrap_logZs[6], label = f\"twist 5\")\n",
+    "plt.vlines(dG, 0,1000, label=f\"true logZ\")\n",
+    "plt.ylim(0, 100)\n",
+    "plt.legend()\n",
+    "plt.ylabel('counts')\n",
+    "plt.xlabel(f\"logZ\")\n",
+    "plt.title(f\"bootstrapped logZs\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 274,
    "metadata": {},
    "outputs": [],
    "source": [
-    "smc_obj.update_cSMC(out_dict['out_A_params'], out_dict['out_b_params'], out_dict['out_A0'], out_dict['out_b0'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "  0%|          | 0/100 [00:00<?, ?it/s]DEBUG:absl:Compiling vSIS_lower_bound for args (ShapedArray(float64[9,1]), ShapedArray(float64[], weak_type=True), ShapedArray(float64[10,1]), ShapedArray(float64[10,1]), ShapedArray(int64[10]), ShapedArray(uint32[2]), ShapedArray(float64[1,1]), ShapedArray(float64[1]), ShapedArray(float64[1,1])).\n",
-      "100%|██████████| 100/100 [00:03<00:00, 28.93it/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "prop, logw, (init_Xs, init_logws) = smc_obj.get_fns() #pull the necessary functions from it\n",
-    "twist2_logZs = []\n",
-    "\n",
-    "for i in tqdm.trange(100):\n",
-    "    rs, run_rs = random.split(rs)\n",
-    "    out_logZ = jvSIS(prop_params, model_params, y,  run_rs, init_params, prop, logw, (init_Xs, init_logws))\n",
-    "    twist2_logZs.append(out_logZ)"
+    "support = np.linspace(-4,4,100)[..., np.newaxis]\n",
+    "init_untwist_dist = np.exp(multivariate_normal.logpdf(support, mean = mu, cov = cov))\n",
+    "_, _, (twist_mu0, twist_cov0) = get_twisted_gmm(controller.csmc_object.init_params['mixture_weights'], \n",
+    "                                               controller.csmc_object.init_params['mus'],\n",
+    "                                               controller.csmc_object.init_params['covs'],\n",
+    "                                               controller.csmc_object.A0,\n",
+    "                                               controller.csmc_object.b0)\n",
+    "init_twist_dist = np.exp(multivariate_normal.logpdf(support, mean = twist_mu0[0], cov = twist_cov0[0]))\n",
+    "final_dist = np.exp(multivariate_normal.logpdf(support, mean = 2., cov = np.array([1.])))\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 276,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7ff3d877add8>"
+       "<matplotlib.legend.Legend at 0x7f5fcf9d5438>"
       ]
      },
-     "execution_count": 51,
+     "execution_count": 276,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -518,12 +774,12 @@
     }
    ],
    "source": [
-    "sns.distplot(logZs, label='twist=0 (uncontrolled)')\n",
-    "sns.distplot(twist1_logZs, label='twist=1 (controlled)')\n",
-    "sns.distplot(twist2_logZs, label='twist=2 (controlled)')\n",
-    "plt.xlabel(f\"logZ\")\n",
-    "plt.vlines(dG,0,1000, label=f\"True logZ\")\n",
-    "plt.ylim(0,100)\n",
+    "plt.plot(support, init_untwist_dist, lw=3, alpha=.5, label = f\"t=0 untwisted distribution\")\n",
+    "plt.plot(support, init_twist_dist, lw=3, alpha=.5, label=f\"t=0 twisted distribution\")\n",
+    "plt.plot(support, final_dist, lw=3, alpha=.5, label=f\"t=9 (last) final target distribution\")\n",
+    "plt.xlabel(f\"x\")\n",
+    "plt.ylabel(f\"density\")\n",
+    "plt.title(f\"initial and final target distributions\")\n",
     "plt.legend()"
    ]
   },
@@ -531,15 +787,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "so there might be a problem :/"
+    "cool"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "source": [
+    "NOTES:\n",
+    "- in both of these examples, the twisting functions that control the variance and mean of the propagations are _independent_ of the position of the latent variable, which is perhaps an unnecessary constraint\n",
+    "- to fix this ^, I will write more expressive functions (while maintaining the constraint that the covariance must be positive-definite)\n",
+    "- I need to fix some of the loggings since they are perhaps a little overly verbose\n"
+   ]
   }
  ],
  "metadata": {
diff --git a/melange/smc.py b/melange/smc.py
index 43218df..a8d846e 100644
--- a/melange/smc.py
+++ b/melange/smc.py
@@ -7,6 +7,7 @@
 from jax.scipy.special import logsumexp
 import numpy as np
 from melange.reporters import BaseSMCReporter
+import tqdm
 import jax
 from jax.config import config; config.update("jax_enable_x64", True)
 
@@ -180,3 +181,26 @@ def scanner(none, t):
     out_works = jnp.vstack((init_logWs, logW_matrix))
 
     return cond(aggregate_works, lambda x: jnp.cumsum(x, axis=0), lambda x: x, out_works)
+
+def bootstrap_logZ(incremental_work_array, num_bootstraps=1000):
+    """
+    bootstrap resample the logZ estimate
+
+    arguments
+        incremental_work_array : np.array(T,N)
+            work array (unaggregated)
+        num_bootstraps : int, default 1000
+            number of bootstraps to conduct
+
+    returns
+        bootstraps : np.array(num_bootstraps)
+            logZ estimates
+    """
+    T, N = incremental_work_array.shape
+    final_works = np.cumsum(incremental_work_array, axis=0)[-1]
+    bootstraps = np.zeros(num_bootstraps)
+    for i in tqdm.trange(num_bootstraps):
+        _works = np.random.choice(final_works, size=N, replace=True)
+        logZ = logsumexp(_works) - np.log(N)
+        bootstraps[i] = logZ
+    return bootstraps