{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Optimization of Dissipative Qubit Reset" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.374878Z", "start_time": "2019-02-12T04:47:25.200533Z" }, "attributes": { "classes": [], "id": "", "n": "1" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "krotov 0.1.0.post1+dev\n", "matplotlib.pylab 1.15.4\n", "qutip 4.3.1\n", "numpy 1.15.4\n", "matplotlib 3.0.2\n", "scipy 1.2.0\n", "CPython 3.6.8\n", "IPython 7.2.0\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "%load_ext watermark\n", "import qutip\n", "import numpy as np\n", "import scipy\n", "import matplotlib\n", "import matplotlib.pylab as plt\n", "import krotov\n", "%watermark -v --iversions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\newcommand{tr}[0]{\\operatorname{tr}}\n", "\\newcommand{diag}[0]{\\operatorname{diag}}\n", "\\newcommand{abs}[0]{\\operatorname{abs}}\n", "\\newcommand{pop}[0]{\\operatorname{pop}}\n", "\\newcommand{aux}[0]{\\text{aux}}\n", "\\newcommand{int}[0]{\\text{int}}\n", "\\newcommand{opt}[0]{\\text{opt}}\n", "\\newcommand{tgt}[0]{\\text{tgt}}\n", "\\newcommand{init}[0]{\\text{init}}\n", "\\newcommand{lab}[0]{\\text{lab}}\n", "\\newcommand{rwa}[0]{\\text{rwa}}\n", "\\newcommand{bra}[1]{\\langle#1\\vert}\n", "\\newcommand{ket}[1]{\\vert#1\\rangle}\n", "\\newcommand{Bra}[1]{\\left\\langle#1\\right\\vert}\n", "\\newcommand{Ket}[1]{\\left\\vert#1\\right\\rangle}\n", "\\newcommand{Braket}[2]{\\left\\langle #1\\vphantom{#2} \\mid\n", "#2\\vphantom{#1}\\right\\rangle}\n", "\\newcommand{op}[1]{\\hat{#1}}\n", "\\newcommand{Op}[1]{\\hat{#1}}\n", "\\newcommand{dd}[0]{\\,\\text{d}}\n", "\\newcommand{Liouville}[0]{\\mathcal{L}}\n", "\\newcommand{DynMap}[0]{\\mathcal{E}}\n", "\\newcommand{identity}[0]{\\mathbf{1}}\n", "\\newcommand{Norm}[1]{\\lVert#1\\rVert}\n", "\\newcommand{Abs}[1]{\\left\\vert#1\\right\\vert}\n", "\\newcommand{avg}[1]{\\langle#1\\rangle}\n", "\\newcommand{Avg}[1]{\\left\\langle#1\\right\\rangle}\n", "\\newcommand{AbsSq}[1]{\\left\\vert#1\\right\\vert^2}\n", "\\newcommand{Re}[0]{\\operatorname{Re}}\n", "\\newcommand{Im}[0]{\\operatorname{Im}}$\n", "This example provides an example for an optimization in an open quantum system,\n", "where the dynamics is governed by the Liouville-von Neumann equation. Hence,\n", "states are represented by density matrices $\\op{\\rho}(t)$ and the time-evolution\n", "operator is given by a general dynamical map $\\DynMap$.\n", "\n", "## Define parameters" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.385786Z", "start_time": "2019-02-12T04:47:26.379865Z" }, "attributes": { "classes": [], "id": "", "n": "2" } }, "outputs": [], "source": [ "omega_q = 1.0 # qubit level splitting\n", "omega_T = 3.0 # TLS level splitting\n", "J = 0.1 # qubit-TLS coupling\n", "kappa = 0.04 # TLS decay rate\n", "beta = 1.0 # inverse bath temperature\n", "T = 25.0 # final time\n", "nt = 2500 # number of time steps" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define the Liouvillian\n", "\n", "The system is given by a qubit with Hamiltonian\n", "$\\op{H}_{q}(t) = - \\omega_{q} \\op{\\sigma}_{z} - \\epsilon(t) \\op{\\sigma}_{z}$,\n", "where $\\omega_{q}$ is a static energy level splitting which can time-dependently\n", "be modified by $\\epsilon(t)$. This qubit couples strongly to another two-level\n", "system (TLS) with Hamiltonian $\\op{H}_{t} = - \\omega_{t} \\op{\\sigma}_{z}$ with\n", "static energy level splitting $\\omega_{t}$. The coupling strength between both\n", "systems is given by $J$ with the interaction Hamiltonian given by $\\op{H}_{\\int}\n", "= J \\op{\\sigma}_{x} \\otimes \\op{\\sigma}_{x}$. The Hamiltonian for the system of\n", "qubit and TLS is\n", "\n", "\\begin{equation}\n", " \\op{H}(t) = \\op{H}_{q}(t) \\otimes\n", "\\identity_{t} + \\identity_{q} \\otimes \\op{H}_{t} + \\op{H}_{\\int}.\n", "\\end{equation}\n", "In addition, the TLS is embedded in a heat bath with inverse temperature\n", "$\\beta$. The TLS couples to the bath with rate $\\kappa$. In order to simulate\n", "the dissipation arising from this coupling, we consider the two Lindblad\n", "operators $\\op{L}_{1} =\n", "\\sqrt{\\kappa (N_{th}+1)} \\identity_{q} \\otimes\n", "\\ket{0}\\bra{1}$ and $\\op{L}_{2} =\n", "\\sqrt{\\kappa N_{th}} \\identity_{q} \\otimes\n", "\\ket{1}\\bra{0}$ with $N_{th} =\n", "1/(e^{\\beta \\omega_{t}} - 1)$. The dynamics of\n", "the qubit-TLS system state\n", "$\\op{\\rho}(t)$ is then governed by the Liouville-von\n", "Neumann equation\n", "\\begin{equation}\n", " \\frac{\\partial}{\\partial t} \\op{\\rho}(t) =\n", "\\Liouville(t) \\op{\\rho}(t)\n", "=\n", " - i \\left[\\op{H}(t), \\op{\\rho}(t)\\right]\n", " +\n", "\\sum_{k=1,2} \\left(\n", "\\op{L}_{k} \\op{\\rho}(t) \\op{L}_{k}^\\dagger\n", " - \\frac{1}{2}\n", "\\op{L}_{k}^\\dagger\n", "\\op{L}_{k} \\op{\\rho}(t)\n", " - \\frac{1}{2} \\op{\\rho}(t)\n", "\\op{L}_{k}^\\dagger\n", "\\op{L}_{k}\n", " \\right).\n", "\\end{equation}" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.423183Z", "start_time": "2019-02-12T04:47:26.389295Z" }, "attributes": { "classes": [], "id": "", "n": "3" } }, "outputs": [], "source": [ "def liou_and_states(omega_q, omega_T, J, kappa, beta):\n", " \"\"\"Liouvillian for the coupled system of qubit and TLS\"\"\"\n", "\n", " # drift qubit Hamiltonian\n", " H0_q = 0.5*omega_q*np.diag([-1,1])\n", " # drive qubit Hamiltonian\n", " H1_q = 0.5*np.diag([-1,1])\n", "\n", " # drift TLS Hamiltonian\n", " H0_T = 0.5*omega_T*np.diag([-1,1])\n", "\n", " # Lift Hamiltonians to joint system operators\n", " H0 = np.kron(H0_q, np.identity(2)) + np.kron(np.identity(2), H0_T)\n", " H1 = np.kron(H1_q, np.identity(2))\n", "\n", " # qubit-TLS interaction\n", " H_int = J*np.fliplr(np.diag([0,1,1,0]))\n", "\n", " # convert Hamiltonians to QuTiP objects\n", " H0 = qutip.Qobj(H0+H_int)\n", " H1 = qutip.Qobj(H1)\n", "\n", " # Define Lindblad operators\n", " N = 1.0/(np.exp(beta*omega_T)-1.0)\n", " # Cooling on TLS\n", " L1 = np.sqrt(kappa * (N+1))\\\n", " * np.kron(np.identity(2), np.array([[0,1],[0,0]]))\n", " # Heating on TLS\n", " L2 = np.sqrt(kappa * N)\\\n", " * np.kron(np.identity(2), np.array([[0,0],[1,0]]))\n", "\n", " # convert Lindblad operators to QuTiP objects\n", " L1 = qutip.Qobj(L1)\n", " L2 = qutip.Qobj(L2)\n", "\n", " # generate the Liouvillian\n", " L0 = qutip.liouvillian(H=H0, c_ops=[L1,L2])\n", " L1 = qutip.liouvillian(H=H1)\n", "\n", " # define qubit-TLS basis in Hilbert space\n", " psi_00 = qutip.Qobj(np.kron(np.array([1,0]), np.array([1,0])))\n", " psi_01 = qutip.Qobj(np.kron(np.array([1,0]), np.array([0,1])))\n", " psi_10 = qutip.Qobj(np.kron(np.array([0,1]), np.array([1,0])))\n", " psi_11 = qutip.Qobj(np.kron(np.array([0,1]), np.array([0,1])))\n", "\n", " # take as guess field a filed putting qubit and TLS into resonance\n", " eps0 = lambda t, args: omega_T - omega_q\n", "\n", " return ([L0, [L1, eps0]], psi_00, psi_01, psi_10, psi_11)\n", "\n", "L, psi_00, psi_01, psi_10, psi_11= liou_and_states(\n", " omega_q=omega_q, omega_T=omega_T, J=J, kappa=kappa, beta=beta)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.443310Z", "start_time": "2019-02-12T04:47:26.430875Z" }, "attributes": { "classes": [], "id": "", "n": "4" } }, "outputs": [], "source": [ "proj_00 = psi_00 * psi_00.dag()\n", "proj_01 = psi_01 * psi_01.dag()\n", "proj_10 = psi_10 * psi_10.dag()\n", "proj_11 = psi_11 * psi_11.dag()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define the optimization target\n", "\n", "The time grid is given by `nt` equidistant\n", "time steps between $t=0$ and $t=T$." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.453602Z", "start_time": "2019-02-12T04:47:26.448090Z" }, "attributes": { "classes": [], "id": "", "n": "5" } }, "outputs": [], "source": [ "tlist = np.linspace(0, T, nt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The initial state of qubit and TLS are assumed to be in thermal equilibrium with\n", "the heat bath (although only the TLS is directly interacting with the bath).\n", "Both states are given by\n", "\n", "\\begin{equation}\n", " \\op{\\rho}_{\\alpha}^{th} =\n", "\\frac{e^{x_{\\alpha}} \\ket{0}\\bra{0} + e^{-x_{\\alpha}} \\ket{1}\\bra{1}}{2\n", "\\cosh(x_{\\alpha})},\n", " \\qquad\n", " x_{\\alpha} = \\frac{\\omega_{\\alpha} \\beta}{2},\n", "\\end{equation}\n", "\n", "with $\\alpha = q,t$. The initial state of the bipartite system\n", "of qubit and TLS is given by the thermal state $\\op{\\rho}_{th} =\n", "\\op{\\rho}_{q}^{th} \\otimes \\op{\\rho}_{t}^{th}$." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.466604Z", "start_time": "2019-02-12T04:47:26.457181Z" }, "attributes": { "classes": [], "id": "", "n": "6" } }, "outputs": [], "source": [ "x_q = omega_q*beta/2.0\n", "rho_q_th = np.diag([np.exp(x_q),np.exp(-x_q)])/(2*np.cosh(x_q))\n", "\n", "x_T = omega_T*beta/2.0\n", "rho_T_th = np.diag([np.exp(x_T),np.exp(-x_T)])/(2*np.cosh(x_T))\n", "\n", "rho_th = qutip.Qobj(np.kron(rho_q_th, rho_T_th))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since we are in the end only interested in the state of the qubit, we define\n", "`trace_TLS`, which calculates the partial trace over the TLS degrees of freedom.\n", "Hence, by passing the state $\\op{\\rho}$ of the bipartite system of qubit and\n", "TLS, it returns the reduced state of the qubit, $\\op{\\rho}_{q} =\n", "\\tr_{t}\\{\\op{\\rho}\\}$." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.482459Z", "start_time": "2019-02-12T04:47:26.472974Z" }, "attributes": { "classes": [], "id": "", "n": "7" } }, "outputs": [], "source": [ "def trace_TLS(rho):\n", " \"\"\"Partial trace over the TLS degrees of freedom\"\"\"\n", " rho_q = np.zeros(shape=(2,2), dtype=np.complex_)\n", " rho_q[0,0] = rho[0,0] + rho[1,1]\n", " rho_q[0,1] = rho[0,2] + rho[1,3]\n", " rho_q[1,0] = rho[2,0] + rho[3,1]\n", " rho_q[1,1] = rho[2,2] + rho[3,3]\n", " return qutip.Qobj(rho_q)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As target state we take (temporarily) the ground state of the bipartite system,\n", "i.e., $\\op{\\rho}_{\\tgt} = \\ket{00}\\bra{00}$. Note that in the end we will only\n", "optimize the reduced state of the qubit." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.496869Z", "start_time": "2019-02-12T04:47:26.485940Z" }, "attributes": { "classes": [], "id": "", "n": "8" } }, "outputs": [], "source": [ "rho_q_trg = np.diag([1,0])\n", "rho_T_trg = np.diag([1,0])\n", "rho_trg = np.kron(rho_q_trg, rho_T_trg)\n", "rho_trg = qutip.Qobj(rho_trg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, the list of `objectives` is defined, which contains the initial and target\n", "state and the Liouvillian $\\Liouville(t)$ determining the evolution of the\n", "system." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.506011Z", "start_time": "2019-02-12T04:47:26.501241Z" }, "attributes": { "classes": [], "id": "", "n": "9" } }, "outputs": [], "source": [ "objectives = [\n", " krotov.Objective(initial_state=rho_th, target=rho_trg, H=L)\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following, we define the shape function $S(t)$, which we use in order to\n", "ensure a smooth switch on and off in the beginning and end. Note that at times\n", "$t$ where $S(t)$ vanishes, the updates of the field is suppressed. A priori,\n", "this has\n", "nothing to do with the shape of the field on input." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.514731Z", "start_time": "2019-02-12T04:47:26.508936Z" }, "attributes": { "classes": [], "id": "", "n": "10" } }, "outputs": [], "source": [ "def S(t):\n", " \"\"\"Shape function for the field update\"\"\"\n", " return krotov.shapes.flattop(\n", " t, t_start=0, t_stop=T,\n", " t_rise=0.05*T, t_fall=0.05*T,\n", " func='sinsq')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, we also want to start with a shaped field on input. Hence, we use the\n", "previously defined shape function $S(t)$ to shape $\\epsilon_{0}(t)$." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.524627Z", "start_time": "2019-02-12T04:47:26.517577Z" }, "attributes": { "classes": [], "id": "", "n": "11" } }, "outputs": [], "source": [ "def shape_field(eps0):\n", " \"\"\"Applies the shape function S(t) to the guess field\"\"\"\n", " eps0_shaped = lambda t, args: eps0(t, args)*S(t)\n", " return eps0_shaped\n", "\n", "L[1][1] = shape_field(L[1][1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At last, before heading to the actual optimization below, we assign the shape\n", "function $S(t)$ to the OCT parameters of the control and choose `lambda_a`, a\n", "numerical\n", "parameter that controls the field update magnitude in each iteration." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.534872Z", "start_time": "2019-02-12T04:47:26.527916Z" } }, "outputs": [], "source": [ "pulse_options = {\n", " L[1][1]: dict(lambda_a=0.01, shape=S)\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulate the dynamics of the guess field" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.545108Z", "start_time": "2019-02-12T04:47:26.537953Z" }, "attributes": { "classes": [], "id": "", "n": "13" } }, "outputs": [], "source": [ "def plot_pulse(pulse, tlist):\n", " fig, ax = plt.subplots()\n", " if callable(pulse):\n", " pulse = np.array([pulse(t, args=None) for t in tlist])\n", " ax.plot(tlist, pulse)\n", " ax.set_xlabel('time')\n", " ax.set_ylabel('pulse amplitude')\n", " plt.show(fig)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following plot shows the guess field $\\epsilon_{0}(t)$, which is, as chosen\n", "above, just a constant field that puts qubit and TLS into resonance (with a\n", "smooth switch-on and switch-off)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.773279Z", "start_time": "2019-02-12T04:47:26.547926Z" }, "attributes": { "classes": [], "id": "", "n": "14" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_pulse(L[1][1], tlist)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before optimizing, we solve the equation of motion for the guess field\n", "$\\epsilon_{0}(t)$." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:26.872504Z", "start_time": "2019-02-12T04:47:26.775372Z" }, "attributes": { "classes": [], "id": "", "n": "15" } }, "outputs": [], "source": [ "guess_dynamics = objectives[0].mesolve(\n", " tlist, e_ops=[proj_00, proj_01, proj_10, proj_11])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By inspecting the population dynamics of qubit and TLS ground state, we see that\n", "both are oscillating and especially the qubit's ground state population reaches\n", "a maximal value at intermediate times $t < T$. This maximum is indeed the\n", "maximum that is physically possible. However, we want to reach this maximum at\n", "final time $T$ (not before), so the guess field is not doing the right thing so\n", "far." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:27.116092Z", "start_time": "2019-02-12T04:47:26.874340Z" }, "attributes": { "classes": [], "id": "", "n": "16" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def plot_population(result):\n", " fig, ax = plt.subplots()\n", " ax.plot(result.times, np.array(result.expect[0])+np.array(result.expect[1]),\n", " label='qubit 0')\n", " ax.plot(result.times, np.array(result.expect[0])+np.array(result.expect[2]),\n", " label='TLS 0')\n", " ax.legend()\n", " ax.set_xlabel('time')\n", " ax.set_ylabel('population')\n", " plt.show(fig)\n", "\n", "plot_population(guess_dynamics)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimize" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our optimization target is the ground state $\\ket{\\Psi_{q}^{\\tgt}}\n", "= \\ket{0}$ of the qubit, irrespective of the state of the TLS. Thus, our\n", "optimization functional reads\n", "\n", "\\begin{equation}\n", " F_{re} = 1 -\n", "\\Braket{\\Psi_{q}^{\\tgt}}{\\tr_{t}\\{\\op{\\rho}(T)\\} \\,|\\; \\Psi_{q}^{\\tgt}}\n", "\\end{equation}\n", "\n", "and we first define `print_qubit_error`, which prints out the\n", "above functional after each iteration." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:27.124250Z", "start_time": "2019-02-12T04:47:27.118668Z" } }, "outputs": [], "source": [ "def print_qubit_error(**args):\n", " \"\"\"Utility function writing the qubit error to screen\"\"\"\n", " taus = []\n", " for state_T in args['fw_states_T']:\n", " state_q_T = trace_TLS(state_T)\n", " taus.append(state_q_T[0,0].real)\n", " J_T_re = 1 - np.average(taus)\n", " print(\" qubit error: %.1e\" % J_T_re)\n", " return J_T_re" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In order to minimize the above functional, we need to provide the correct\n", "`chi_constructor` for the Krotov optimization, as it contains all necessary\n", "information. Given our bipartite system and choice of $F_{re}$, the\n", "$\\op{\\chi}(T)$ reads\n", "\n", "\\begin{equation}\n", " \\op{\\chi}(T) =\n", " \\sum_{k=0,1} a_{k}\n", "\\op{\\rho}_{q}^{\\tgt} \\otimes \\ket{k}\\bra{k}\n", "\\end{equation}\n", "\n", "with $\\{\\ket{k}\\}$ a\n", "basis for the TLS Hilbert space." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:27.144420Z", "start_time": "2019-02-12T04:47:27.132277Z" }, "attributes": { "classes": [], "id": "", "n": "18" } }, "outputs": [], "source": [ "def TLS_onb_trg():\n", " \"\"\"Returns the tensor product of qubit target state\n", " and a basis for the TLS Hilbert space\"\"\"\n", " rho1 = qutip.Qobj(np.kron(rho_q_trg, np.diag([1,0])))\n", " rho2 = qutip.Qobj(np.kron(rho_q_trg, np.diag([0,1])))\n", " return [rho1, rho2]\n", "\n", "TLS_onb = TLS_onb_trg()\n", "\n", "def chis_qubit(states_T, objectives, tau_vals):\n", " \"\"\"Calculate chis for the chosen functional\"\"\"\n", " chis = []\n", " for state_i_T in states_T:\n", " chis_i = np.zeros(shape=(4,4), dtype=np.complex_)\n", " for state_k in TLS_onb:\n", " a_i_k = krotov.optimize._overlap(state_i_T, state_k)\n", " chis_i += a_i_k * state_k\n", " chis.append(qutip.Qobj(chis_i))\n", " return chis" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following carries out the optimization." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 0\n", " objectives:\n", " 1:Herm[4,4] - {[[[4,4],[4,4]], [[[4,4],[4,4]], u1(t)]]} - Herm[4,4]\n", " adjoint objectives:\n", " 1:Herm[4,4] - {[[[4,4],[4,4]], [[[4,4],[4,4]], u1(t)]]} - Herm[4,4]\n", " S(t) (ranges): [0.000000, 1.000000]\n", " duration: 0.5 secs (started at 2019-02-12 16:43:15)\n", " optimized pulses (ranges): [0.00, 2.00]\n", " ∫gₐ(t)dt: 0.00e+00\n", " λₐ: 1.00e-02\n", " storage (bw, fw, fw0): None, None, None\n", " fw_states_T norm: 1.000000\n", " τ: (7.97e-01:0.00π)\n", " qubit error: 1.1e-01\n", "Iteration 1\n", " duration: 2.8 secs (started at 2019-02-12 16:43:16)\n", " optimized pulses (ranges): [0.00, 2.06]\n", " ∫gₐ(t)dt: 7.72e-02\n", " λₐ: 1.00e-02\n", " storage (bw, fw, fw0): [1 * ndarray(2500)] (1.3 MB), None, None\n", " fw_states_T norm: 1.000000\n", " τ: (7.98e-01:0.00π)\n", " qubit error: 1.1e-01\n", "Iteration 2\n", " duration: 2.8 secs (started at 2019-02-12 16:43:19)\n", " optimized pulses (ranges): [0.00, 2.23]\n", " ∫gₐ(t)dt: 5.72e-01\n", " λₐ: 1.00e-02\n", " storage (bw, fw, fw0): [1 * ndarray(2500)] (1.3 MB), None, None\n", " fw_states_T norm: 1.000000\n", " τ: (8.01e-01:0.00π)\n", " qubit error: 6.7e-02\n", "Iteration 3\n", " duration: 2.8 secs (started at 2019-02-12 16:43:22)\n", " optimized pulses (ranges): [0.00, 2.33]\n", " ∫gₐ(t)dt: 8.11e-02\n", " λₐ: 1.00e-02\n", " storage (bw, fw, fw0): [1 * ndarray(2500)] (1.3 MB), None, None\n", " fw_states_T norm: 1.000000\n", " τ: (7.99e-01:0.00π)\n", " qubit error: 5.0e-02\n", "Iteration 4\n", " duration: 2.8 secs (started at 2019-02-12 16:43:24)\n", " optimized pulses (ranges): [0.00, 2.19]\n", " ∫gₐ(t)dt: 2.16e-01\n", " λₐ: 1.00e-02\n", " storage (bw, fw, fw0): [1 * ndarray(2500)] (1.3 MB), None, None\n", " fw_states_T norm: 1.000000\n", " τ: (8.02e-01:0.00π)\n", " qubit error: 4.9e-02\n", "Iteration 5\n", " duration: 2.9 secs (started at 2019-02-12 16:43:27)\n", " optimized pulses (ranges): [0.00, 2.15]\n", " ∫gₐ(t)dt: 6.38e-02\n", " λₐ: 1.00e-02\n", " storage (bw, fw, fw0): [1 * ndarray(2500)] (1.3 MB), None, None\n", " fw_states_T norm: 1.000000\n", " τ: (8.03e-01:0.00π)\n", " qubit error: 4.9e-02\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "# the DensityMatrixODEPropagator is not sufficiently exact to guarantee that\n", "# you won't get very slightly different results in the optimization when\n", "# running this on different systems\n", "oct_result = krotov.optimize_pulses(\n", " objectives, pulse_options, tlist,\n", " propagator=krotov.propagators.DensityMatrixODEPropagator(\n", " atol=1e-10, rtol=1e-8\n", " ),\n", " chi_constructor=chis_qubit,\n", " info_hook=krotov.info_hooks.chain(\n", " krotov.info_hooks.print_debug_information,\n", " print_qubit_error,\n", " ),\n", " check_convergence=krotov.convergence.check_monotonic_error,\n", " iter_stop=5)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:39.603540Z", "start_time": "2019-02-12T04:47:39.598097Z" }, "attributes": { "classes": [], "id": "", "n": "20" } }, "outputs": [ { "data": { "text/plain": [ "Krotov Optimization Result\n", "--------------------------\n", "- Started at 2019-02-12 16:43:15\n", "- Number of objectives: 1\n", "- Number of iterations: 5\n", "- Reason for termination: Reached 5 iterations\n", "- Ended at 2019-02-12 16:43:30" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "oct_result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulate the dynamics of the optimized field\n", "\n", "The plot of the optimized field\n", "shows, that the optimization slightly shifts the field such that qubit and TLS\n", "are no longer perfectly in resonance." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:39.774187Z", "start_time": "2019-02-12T04:47:39.607074Z" }, "attributes": { "classes": [], "id": "", "n": "21" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_pulse(oct_result.optimized_controls[0], tlist)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This slight shift of qubit and TLS out of resonance delays the population\n", "oscillations between\n", "qubit and TLS ground state such that the qubit ground state\n", "is maximally\n", "populated at final time $T$." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "ExecuteTime": { "end_time": "2019-02-12T04:47:40.231722Z", "start_time": "2019-02-12T04:47:39.777301Z" }, "attributes": { "classes": [], "id": "", "n": "22" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "optimized_dynamics = oct_result.optimized_objectives[0].mesolve(\n", " tlist, e_ops=[proj_00, proj_01, proj_10, proj_11])\n", "\n", "plot_population(optimized_dynamics)" ] } ], "metadata": { "hide_input": false, "jupytext": { "formats": "" }, "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.8" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }