00_core.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp core"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ihu\n",
    "\n",
    "> Evolve any unitary using solve_ivp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "from nbdev.export import notebook2script\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from scipy.integrate import solve_ivp\n",
    "from numpy.random import random_sample\n",
    "from numpy import array, linspace\n",
    "from math import sqrt\n",
    "from ihu.herm import rand_herm_ndarray, test_herm_ndarray\n",
    "from ihu.unitary import rand_unitary_ndarray, test_unitary_ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def ihu(ham_func, u0, evolution_time, no_time_step_for_eval, **kwargs):\n",
    "    r\"\"\"evolves the unitary\n",
    "        \n",
    "    Parameters\n",
    "    ----------\n",
    "    ham_func : function\n",
    "        Function which produces the Hamiltonian \n",
    "        as it appears at time t\n",
    "        form ham_func(t)\n",
    "    u0 : ndarray\n",
    "        Unitary at time 0\n",
    "    evolution_time : float\n",
    "        Evolution time\n",
    "    no_time_step_for_eval : int\n",
    "        no of time steps for evaluation in the \n",
    "        final output\n",
    "    **kwargs\n",
    "        Arbitrary optional keyword arguments.\n",
    "        w : float\n",
    "            Defaults to 6.28\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Bunch object with the following fields defined:\n",
    "    t  : [ndarray, shape (n_points,)] \n",
    "        Time points.        \n",
    "    y  : [ndarray, shape (n, n_points)] \n",
    "        Values of the solution at t.\n",
    "    sol: [OdeSolution or None] \n",
    "        Found solution as OdeSolution instance; None if\n",
    "        dense_output was set to False.\n",
    "    t_events: [list of ndarray or None]\n",
    "        Contains for each event type a list of arrays at which an event of\n",
    "        that type event was detected. None if events was None.\n",
    "    nfev: [int] \n",
    "        Number of evaluations of the right-hand side.\n",
    "    njev: [int]\n",
    "        Number of evaluations of the Jacobian.\n",
    "    nlu :[int] \n",
    "        Number of LU decompositions.\n",
    "    status [int] \n",
    "        Reason for algorithm termination:\n",
    "        • -1: Integration step failed.\n",
    "        • 0: The solver successfully reached the end of tspan.\n",
    "        • 1: A termination event occurred.\n",
    "    message: [string] \n",
    "        Human-readable description of the termination reason.\n",
    "    success: [bool] \n",
    "        True if the solver reached the interval end or a \n",
    "        termination event occurred (status\n",
    "    >= 0).\n",
    "    \n",
    "    u_series :[ndarray, shape (sqrt(n), sqrt(n), n_points)] \n",
    "        Values of the solution at t.\n",
    "    \n",
    "    \"\"\"\n",
    "    u_shape = u0.shape\n",
    "    \n",
    "    check_for_stupidity(ham_func, u0, )\n",
    "    T = evolution_time\n",
    "    Nt = no_time_step_for_eval\n",
    "    dt = T/Nt\n",
    "    y0 = u0.ravel()\n",
    "    t_eval_span = linspace(0, T, Nt)\n",
    "    \n",
    "    result = solve_ivp(fun=y_der, t_span=(0, T), y0=y0, \n",
    "                       t_eval=t_eval_span, args=(u_shape, ham_func))\n",
    "    # Will expose other options later on\n",
    "    \n",
    "    print(result.message)\n",
    "    \n",
    "    u_series = result.y.reshape(u_shape[0], u_shape[0], result.y.shape[-1])\n",
    "\n",
    "    return u_series, result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Steps:\n",
    "   - Determines Shape of U0.\n",
    "   - Determines Shape of H (at any random time t).\n",
    "   - If anyone of U, H are non square exit.\n",
    "   - If shapes match proceed else exit.\n",
    "   - make sure Output of H is Hermitian \n",
    "      (by trying it out at 3 different times)\n",
    "   - Initialize inputs T, Nt\n",
    "   - Flatten u0 to get y0\n",
    "   - calculate dt = T/ Nt\n",
    "   - make y_der\n",
    "   - evolve y\n",
    "   - collect results\n",
    "   - y_series to u_series\n",
    "   - print messages\n",
    "   - return stuff + u_series\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call syntax\n",
    "\n",
    "u_series, result = ihu(ham_func, u0, T, no_time_step_for_eval, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linspace(1, 10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  1.09090909,  1.18181818,  1.27272727,  1.36363636,\n",
       "        1.45454545,  1.54545455,  1.63636364,  1.72727273,  1.81818182,\n",
       "        1.90909091,  2.        ,  2.09090909,  2.18181818,  2.27272727,\n",
       "        2.36363636,  2.45454545,  2.54545455,  2.63636364,  2.72727273,\n",
       "        2.81818182,  2.90909091,  3.        ,  3.09090909,  3.18181818,\n",
       "        3.27272727,  3.36363636,  3.45454545,  3.54545455,  3.63636364,\n",
       "        3.72727273,  3.81818182,  3.90909091,  4.        ,  4.09090909,\n",
       "        4.18181818,  4.27272727,  4.36363636,  4.45454545,  4.54545455,\n",
       "        4.63636364,  4.72727273,  4.81818182,  4.90909091,  5.        ,\n",
       "        5.09090909,  5.18181818,  5.27272727,  5.36363636,  5.45454545,\n",
       "        5.54545455,  5.63636364,  5.72727273,  5.81818182,  5.90909091,\n",
       "        6.        ,  6.09090909,  6.18181818,  6.27272727,  6.36363636,\n",
       "        6.45454545,  6.54545455,  6.63636364,  6.72727273,  6.81818182,\n",
       "        6.90909091,  7.        ,  7.09090909,  7.18181818,  7.27272727,\n",
       "        7.36363636,  7.45454545,  7.54545455,  7.63636364,  7.72727273,\n",
       "        7.81818182,  7.90909091,  8.        ,  8.09090909,  8.18181818,\n",
       "        8.27272727,  8.36363636,  8.45454545,  8.54545455,  8.63636364,\n",
       "        8.72727273,  8.81818182,  8.90909091,  9.        ,  9.09090909,\n",
       "        9.18181818,  9.27272727,  9.36363636,  9.45454545,  9.54545455,\n",
       "        9.63636364,  9.72727273,  9.81818182,  9.90909091, 10.        ])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linspace(1, 10, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def y_der(t, y, u_shape, ham_func):\n",
    "    r\"\"\"Basically dy/dt\n",
    "    \n",
    "    Does some stuff.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    t : float\n",
    "        Current time value during the integration\n",
    "    y : ndarray\n",
    "        flattened unitary at the current time\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    dydt : ndarray\n",
    "        flattened derivative of the unitary\n",
    "    \n",
    "    \"\"\"\n",
    "    # u_shape = int(sqrt(y.shape[0]))\n",
    "    u_curr = y.reshape(u_shape[0], u_shape[0])\n",
    "    hamiltonian_curr = ham_func(t)\n",
    "    dudt = -1j*hamiltonian_curr@u_curr\n",
    "    dydt = dudt.ravel()\n",
    "    \n",
    "    return dydt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def check_for_stupidity(ham_func, u0, ):\n",
    "    r\"\"\"Perform checks for invalid inputs and the lot\"\"\"\n",
    "    u0_shape = u0.shape\n",
    "    ham_shape = ham_func(0.2).shape\n",
    "    \n",
    "    \n",
    "    try:\n",
    "        assert u0_shape[0] == u0_shape[1]\n",
    "    except AssertionError as e1:\n",
    "        print('Initial unitary is not a square matrix')\n",
    "        raise AssertionError\n",
    "        \n",
    "    try:\n",
    "        assert ham_shape[0] == ham_shape[1]\n",
    "    except AssertionError as e2:\n",
    "        print('Hamiltonian is not a square matrix') \n",
    "        raise AssertionError\n",
    "    \n",
    "    try:\n",
    "        assert u0_shape == ham_shape\n",
    "    except AssertionError as e3:\n",
    "        print('Hamiltonian shape is not same as that of the initial unitary.')\n",
    "        raise AssertionError\n",
    "    \n",
    "    try:\n",
    "        assert test_unitary_ndarray(u0) is True\n",
    "    except AssertionError as e4:\n",
    "        print('Initial unitary is not unitary')\n",
    "        raise AssertionError\n",
    "        \n",
    "    try:\n",
    "        assert test_herm_ndarray(ham_func(0.42)) is True\n",
    "    except AssertionError as e5:\n",
    "        print('Hamiltonian is not Hermitian')\n",
    "        raise AssertionError\n",
    "        \n",
    "    \n",
    "    \n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_core.ipynb.\n",
      "Converted 01_reshape.ipynb.\n",
      "Converted 02_herm.ipynb.\n",
      "Converted 03_unitary.ipynb.\n",
      "Converted 04_tests.ipynb.\n",
      "Converted index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}