{ "cells": [ { "cell_type": "markdown", "id": "dc15734d-8749-49ae-be80-c3392e9699e1", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "# Time Evolution\n", "\n", "Time evolutions in `quimb` are handled by the class {class}`~quimb.evo.Evolution`, which is initialized with a starting state and hamiltonian.\n", "\n", "## Basic Usage\n", "\n", "Set up the {class}`~quimb.evo.Evolution` object with a initial state and hamiltonian." ] }, { "cell_type": "code", "execution_count": 1, "id": "1330c133-a456-4273-b4e9-0f5edab0040d", "metadata": {}, "outputs": [], "source": [ "from quimb import *\n", "\n", "p0 = rand_ket(2**10)\n", "h = ham_heis(10, sparse=True)\n", "evo = Evolution(p0, h)" ] }, { "cell_type": "markdown", "id": "bad44ff5-2dcc-43e1-912c-aff549e44221", "metadata": {}, "source": [ "Update it in a single shot to a new time and get the state," ] }, { "cell_type": "code", "execution_count": 2, "id": "2edbe41e-48c8-4e69-b393-f3dbce606845", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[0.006074+0.011257j]\n", " [0.028495+0.016557j]\n", " [0.01617 -0.015705j]\n", " ...\n", " [0.018271+0.026071j]\n", " [0.018582-0.016482j]\n", " [0.027511+0.048377j]]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "evo.update_to(1)\n", "evo.pt" ] }, { "cell_type": "markdown", "id": "b5764132-0502-4650-a401-0c83f4cf23d6", "metadata": {}, "source": [ "Lazily generate the state at multiple times:" ] }, { "cell_type": "code", "execution_count": 3, "id": "2b138fbe-6ac1-4ceb-beb8-6b5c2e3e0184", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.003244693043705576\n", "0.008360765055266119\n", "0.009413166876677937\n" ] } ], "source": [ "for pt in evo.at_times([2, 3, 4]):\n", " print(expec(pt, p0))" ] }, { "cell_type": "markdown", "id": "3c8ea54a-ac64-4afd-81ef-7e87608aaaef", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "## Methods of Updating\n", "\n", "There are three methods of updating the state:\n", "\n", "> - `Evolution(..., method='integrate')`: use definite integration.\n", "> Get system at each time step, only need action of Hamiltonian on\n", "> state. Generally efficient. For pure and mixed states. The\n", "> additional option `int_small_step={False, True}` determines\n", "> whether a low or high order adaptive stepping scheme is used,\n", "> giving naturally smaller or larger times steps. See\n", "> {class}`scipy.integrate.ode` for details, `False` corresponds\n", "> to `\"dop853\"`, `True` to `\"dopri5\"`.\n", "> - `Evolution(..., method='solve')`. Diagonalize the hamiltonian,\n", "> which once done, allows quickly updating to arbitrary times.\n", "> Supports pure and mixed states, recomended for small systems.\n", "> - `Evolution(..., method='expm')`: compute the evolved state\n", "> using the action of the matrix exponential in a 'single shot'\n", "> style. Only needs action of Hamiltonian, for very large systems\n", "> can use distributed MPI. Only for pure states.\n", "\n", "## Computing on the fly\n", "\n", "Sometimes, if integrating, it is best to just query the state at time-steps chosen dynamically by the adaptive scheme. This is achieved using the `compute` keyword supplied to `Evolution`. It can also just be a convenient way to set up calculations as well:" ] }, { "cell_type": "code", "execution_count": 4, "id": "0dc964f7-5ac2-44ad-aaeb-320609078861", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|##########| 100/100 [00:00<00:00, 20144.58%/s]\n" ] } ], "source": [ "p0 = rand_product_state(10)\n", "h = ham_heis(10, sparse=True)\n", "\n", "dims = [2] * 10\n", "sysa, sysb = (0, 1), (2, 3)\n", "\n", "def calc_t_and_logneg(t, pt):\n", " ln = logneg_subsys(pt, dims, sysa, sysb)\n", " return t, ln\n", "\n", "evo = Evolution(p0, h, compute=calc_t_and_logneg, progbar=True)\n", "evo.update_to(1)\n", "\n", "ts, lns = zip(*evo.results)" ] }, { "cell_type": "code", "execution_count": 5, "id": "2387b525-54e8-4dca-ae42-8d5eca0b9916", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.0,\n", " 0.2494153162899183,\n", " 0.4631400312076022,\n", " 0.6768647461252861,\n", " 0.9475557600771725,\n", " 1.0)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ts" ] }, { "cell_type": "code", "execution_count": 6, "id": "0908d890-675e-449e-aa3c-a82c7d03aab8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.0,\n", " 0.2589846231770502,\n", " 0.4423181326621942,\n", " 0.592697104829058,\n", " 0.7379099150663264,\n", " 0.7601643146969251)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lns" ] }, { "cell_type": "markdown", "id": "2636ba38-c42b-4f56-b495-e968c8d8d464", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "If a dict of callables is supplied to `compute`, (each should take two arguments, the time, and the state, as above), `Evolution.results` will itself be a dictionary containing the results of each function at each time step, under the respective key. This can be more convenient:" ] }, { "cell_type": "code", "execution_count": 7, "id": "55c0a8d7-ad7b-43ff-8b6d-ff60560001f6", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|##########| 100/100 [00:00<00:00, 18631.41%/s]\n" ] } ], "source": [ "def calc_t(t, _):\n", " return t\n", "\n", "def calc_logneg(_, pt):\n", " return logneg_subsys(pt, [2]*10, 0, 1)\n", "\n", "evo = Evolution(p0, h, compute={'t': calc_t, 'ln': calc_logneg}, progbar=True)\n", "evo.update_to(1)" ] }, { "cell_type": "code", "execution_count": 8, "id": "972f485b-64c4-46e5-86b4-16cbd93d81a2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'t': [0.0,\n", " 0.2494153162899183,\n", " 0.4631400312076022,\n", " 0.6768647461252861,\n", " 0.9475557600771725,\n", " 1.0],\n", " 'ln': [0.0,\n", " 0.150158101589196,\n", " 0.23732495484813082,\n", " 0.2922696608578911,\n", " 0.3242059171688551,\n", " 0.3263498611123527]}" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "evo.results" ] }, { "cell_type": "markdown", "id": "d904d5df-f633-4b96-98cd-234f326e98fa", "metadata": { "raw_mimetype": "text/restructuredtext" }, "source": [ "(time-dependent-evolution)=\n", "\n", "## Time-Dependent Evolutions\n", "\n", "If you are using `method='integrate'` you can supply a callable to `ham` to evolve the state with a time dependent Hamiltonian. It should take a single argument `t` and return the Hamiltonian at the time. It probably makes sense to use a custom class here to avoid reconstructing as much of the Hamiltonian as possible at each step.\n", "\n", "Here we'll evolve the Neel state:\n", "\n", "$$\n", "| \\psi(0) \\rangle = | \\uparrow \\downarrow \\uparrow \\downarrow \\uparrow \\ldots \\rangle\n", "$$\n", "\n", "with the Hamiltonian:\n", "\n", "$$\n", "H(t) = \\sum_{i = 0}^{L - 1} S^Z_{i} S^Z_{i + 1} + \\cos(t) \\sum_{i}^{L} S^X_i\n", "$$" ] }, { "cell_type": "code", "execution_count": 9, "id": "c64f70b8-a689-4fc9-ac49-eb90e2c5921c", "metadata": {}, "outputs": [], "source": [ "class MyTimeDepIsingHam:\n", "\n", " def __init__(self, L):\n", " self.h_interaction = ham_ising(L, sparse=True, jz=1.0, bx=0.0, cyclic=False)\n", " self.h_field = ham_ising(L, sparse=True, jz=0.0, bx=1.0, cyclic=False)\n", "\n", " def __call__(self, t):\n", " return self.h_interaction + cos(t) * self.h_field" ] }, { "cell_type": "code", "execution_count": 10, "id": "1480b979-aa44-4726-b01d-830f767613e4", "metadata": {}, "outputs": [], "source": [ "L = 16\n", "\n", "# our initial state\n", "psi0 = neel_state(L)\n", "\n", "# instantiate the ham object, it's __call__ method will be used by Evolution\n", "fn_ham_t = MyTimeDepIsingHam(L)" ] }, { "cell_type": "markdown", "id": "0a86b6c6-8a02-44b0-ac25-85f074af69c5", "metadata": {}, "source": [ "We still want to compute some properties during the evolution:" ] }, { "cell_type": "code", "execution_count": 11, "id": "67a204ea-4f14-435d-b68d-746756ad77e1", "metadata": {}, "outputs": [], "source": [ "compute = {\n", " 'time': lambda t, p: t,\n", " 'entropy': lambda t, p: entropy_subsys(p, dims=[2] * L, sysa=range(L // 2))\n", "}" ] }, { "cell_type": "markdown", "id": "256af3bb-af91-4139-bfa9-68f6703403c9", "metadata": {}, "source": [ "Now we set up the evolution object again:" ] }, { "cell_type": "code", "execution_count": 12, "id": "e2608200-f85e-461f-b347-116b8b464d24", "metadata": {}, "outputs": [], "source": [ "evo = Evolution(psi0, fn_ham_t, progbar=True, compute=compute)" ] }, { "cell_type": "code", "execution_count": 13, "id": "d26978f4-1fb2-4f8a-b0d6-1338fff320f6", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|##########| 100/100 [00:07<00:00, 12.53%/s]\n" ] } ], "source": [ "evo.update_to(10)" ] }, { "cell_type": "markdown", "id": "4735d921-676f-4db6-8dc8-573b42f44f3f", "metadata": {}, "source": [ "We can plot the half chain entropy that we computed on the fly:" ] }, { "cell_type": "code", "execution_count": 14, "id": "e4d8cb4e-16ab-47dd-8a01-e0c91836b5dc", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "with plt.style.context(NEUTRAL_STYLE):\n", " plt.plot(evo.results['time'], evo.results['entropy'])" ] }, { "cell_type": "markdown", "id": "59aa8c6a-e5ee-4720-a132-f54966e3a9d7", "metadata": {}, "source": [ "Or we can use the final state:" ] }, { "cell_type": "code", "execution_count": 15, "id": "81f8058b-7128-42f5-9e70-56699dc6ff32", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.003302180752068547" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fidelity(psi0, evo.pt)" ] } ], "metadata": { "celltoolbar": "Raw Cell Format", "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" }, "vscode": { "interpreter": { "hash": "39c10650315d977fb13868ea1402e99f3e10e9885c2c202e692ae90b8995050d" } } }, "nbformat": 4, "nbformat_minor": 4 }