TDVP .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Theoretical predictions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sprawdzone i działa na:**\n",
    "\n",
    "**For state $|1 \\rangle$ and $H = - Z \\otimes Z$:**\n",
    "    $$\\langle 1 \\otimes X \\rangle = 0 $$\n",
    "    $$\\langle Z \\otimes Z \\rangle = 1$$\n",
    "   \n",
    "**For state $|1 \\rangle$ and $H = 1 \\otimes X$:** \n",
    "    $$\\langle 1 \\otimes X \\rangle = 0$$\n",
    "    $$\\langle Z \\otimes Z \\rangle = \\cos^{2} \\frac{2t}{\\hbar}$$\n",
    "\n",
    "\n",
    "**For state $\\frac{|0\\rangle + |1 \\rangle}{2}$ and $H = 1 \\otimes X$:**\n",
    "    $$\\langle 1 \\otimes X \\rangle = 1 $$\n",
    "    $$\\langle Z \\otimes Z \\rangle = 0 $$\n",
    "\n",
    "**For state $\\frac{|0\\rangle + |1 \\rangle}{2}$ and $H = -Z \\otimes Z$:**\n",
    "    $$\\langle 1 \\otimes X \\rangle = \\cos^{2} \\frac{2t}{\\hbar}$$\n",
    "    $$\\langle Z \\otimes Z \\rangle = 0 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TDVP code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.sparse.linalg as ssl\n",
    "import scipy.linalg as sc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.set_printoptions(threshold=np.inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "global J, h, D, d, Dmax\n",
    "J = 1 #Hamiltonian\n",
    "h = 0.1 #Hamiltonian\n",
    "D = 6 #Bond dimension\n",
    "Dmax = 50\n",
    "d = 2 #Physical dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hamiltonian:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sz = [[1, 0], [0,-1]]\n",
    "sx = [[0,1], [1,0]]\n",
    "on = [[1,0], [0,1]]\n",
    "\n",
    "X1 = np.tensordot(sx, on, axes=([],[]))\n",
    "X2 = np.tensordot(on, sx, axes=([],[]))\n",
    "ZZ = np.tensordot(sz, sz, axes=([],[]))\n",
    "H = -J*ZZ - h*0.5*X1 - h*0.5*X2\n",
    "\n",
    "I = np.tensordot(on, on, axes=([],[]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **MPS:  (Nieważne bo na dole uzyskuje AL, AR, C z A ogólnego)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "AC = np.zeros((D, d, D)).astype(complex)\n",
    "AR = np.zeros((D, d, D)).astype(complex)\n",
    "AL = np.zeros((D, d, D)).astype(complex)\n",
    "C = np.identity(D).astype(complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\rightrightarrows$ state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#NIE wazne \n",
    "\n",
    "AC[0,0,0] = 1/np.sqrt(2)\n",
    "AC[0,1,0] = 1/np.sqrt(2)\n",
    "\n",
    "AR[0,0,0] = 1/np.sqrt(2)\n",
    "AR[0,1,0] = 1/np.sqrt(2)\n",
    "\n",
    "AL[0,0,0] = 1/np.sqrt(2)\n",
    "AL[0,1,0] = 1/np.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\upuparrows$  state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "AC[0,0,0] = 1\n",
    "AR[0,0,0] = 1\n",
    "AL[0,0,0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A defining \n",
    "### Finding AL, C, AR from A\n",
    "#### Right-Left Canonical is needed to get proper observables regardless of bond dimension D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.zeros((D, d, D)).astype(complex)\n",
    "\n",
    "#do testów i symulacji używam tych dwóch stanów:\n",
    "\n",
    "#state 01/sqrt(2):\n",
    "A[0,0,0] = 1/np.sqrt(2)\n",
    "A[0,1,0] = 1/np.sqrt(2)\n",
    "\n",
    "#state 0:\n",
    "#A[0,0,0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Left.png\" width=\"700\">\n",
    "<img src=\"Mix.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Funkcja z A robiaca AL, AR, C \n",
    "\n",
    "def leftOrthonormalise(A, mu):\n",
    "    L = np.random.rand(D,D)\n",
    "    L = np.divide( L, np.linalg.norm(L) )\n",
    "    Lold = L\n",
    "    al, L = np.linalg.qr( np.reshape( np.tensordot(L, A, axes=([1], [0])), (D*d, D)) )\n",
    "    if np.array_equal(L, -1*Lold):\n",
    "        al = -1*al #fixing positive sign with singular value\n",
    "        L = -1*L\n",
    "    lamb = np.linalg.norm(L)\n",
    "    L = np.divide(L, lamb)\n",
    "    delta = np.linalg.norm( np.subtract(L, Lold) )\n",
    "\n",
    "    while delta > mu:\n",
    "        #Tu jest jakies przyspieszenie z Arnoldim ale go nie rozumie, a nie jeskt kluczowe\n",
    "        _, L = np.linalg.qr(L)\n",
    "        L = np.divide( L, np.linalg.norm(L) )\n",
    "        Lold = L\n",
    "        al, L = np.linalg.qr( np.reshape( np.tensordot(L, A, axes=([1], [0])), (D*d, D)) )\n",
    "        if np.array_equal(L, -1*Lold):\n",
    "            al = -1*al\n",
    "            L = -1*L\n",
    "        lamb = np.linalg.norm(L)\n",
    "        L = np.divide( L, lamb )\n",
    "        delta = np.linalg.norm( np.subtract(L, Lold) )\n",
    "    \n",
    "    al = np.reshape(al, (D,d,D))\n",
    "    return al, L, lamb\n",
    "\n",
    "def rightOrthonormalise(A, mu):\n",
    "    C = np.random.rand(D,D)\n",
    "    C = C/np.linalg.norm(C)\n",
    "    Cold = C  \n",
    "    ar, C = np.linalg.qr( np.transpose( np.reshape( np.tensordot(A, C, axes=([2], [0])), (D, d*D)) ) )\n",
    "    if np.array_equal(C, -1*Cold):\n",
    "        ar = -1*np.transpose(ar) #fixing positive sign\n",
    "        C = -1*np.transpose(C)\n",
    "    lamb = np.linalg.norm(C)\n",
    "    C = np.divide(C, lamb)\n",
    "    delta = np.linalg.norm( np.subtract(C, Cold) )\n",
    "    \n",
    "    while delta > mu:\n",
    "        _, C = np.linalg.qr(np.transpose(C))\n",
    "        C = np.transpose(C)\n",
    "        C = np.divide( C, np.linalg.norm(C) )\n",
    "        Cold = C\n",
    "        ar, C = np.linalg.qr( np.transpose( np.reshape( np.tensordot(A, C, axes=([2], [0])), (D, d*D)) ) )\n",
    "        if np.array_equal(C, -1*Cold):\n",
    "            ar = -1*np.transpose(ar) #fixing positive sign\n",
    "            C = -1*np.transpose(C)\n",
    "        lamb = np.linalg.norm(C)\n",
    "        C = np.divide( C, lamb )\n",
    "\n",
    "        delta = np.linalg.norm( np.subtract(C, Cold) )\n",
    "    \n",
    "    ar = np.reshape(ar, (D,d,D))\n",
    "    return ar, C, lamb\n",
    "\n",
    "def mixedCanonical(A, mu = 10e-10):\n",
    "    AL, _,lamb = leftOrthonormalise(A, mu) \n",
    "    AR, C, _ = rightOrthonormalise(AL, mu)\n",
    "    U, C, V = np.linalg.svd(C)   #moze wziac dagger z V?\n",
    "    \n",
    "    AL = np.reshape(np.dot(np.reshape(AL,(d*D,D)),U), (D,d*D))\n",
    "    AL = np.reshape(np.array(np.dot(np.matrix(U).getH(), AL)), (D,d,D))\n",
    "    \n",
    "    AR = np.reshape(np.dot(np.reshape(AR,(d*D,D)),V), (D,d*D))\n",
    "    AR = np.reshape(np.array(np.dot(np.matrix(V).getH(), AR)), (D,d,D))\n",
    "\n",
    "    return AL, AR, np.diag(C), lamb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "AL, AR, C, _ = mixedCanonical(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Calculating observables - contracting and Hamiltonian normalization*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contractHamiltonian(al, c, ar, HH):\n",
    "    AA = np.tensordot(al, c, axes=([2], [0]))\n",
    "    AA = np.tensordot(AA, ar, axes=([2], [0]))\n",
    "    O = np.tensordot(AA, HH, axes=([1,2], [0,2]))\n",
    "    O = np.tensordot(np.conjugate(AA), O, axes=([0,3,1,2], [0,1,2,3]))\n",
    "    cc = np.asscalar(np.tensordot(c, np.conjugate(c), axes=([0,1], [0,1])))\n",
    "    return np.asscalar(O)/cc\n",
    "\n",
    "def normalizeHamiltonian(al, c, ar, HH):\n",
    "    EH = contractHamiltonian(al, c, ar, HH)\n",
    "    HH = HH - EH*I\n",
    "    return HH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding G1 and G2:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](LH.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](G1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buildLH(al, HH):\n",
    "    EL = np.tensordot(al, np.conjugate(al), axes=([1],[1]))\n",
    "    III = np.tensordot(np.identity(D),np.identity(D), axes=([],[]))\n",
    "    EL = III - EL\n",
    "    EL = np.reshape(np.swapaxes(EL, 1,2), (D*D, D*D))\n",
    "    EL = np.reshape(sc.pinv(EL, rcond=1e-14), (D,D,D,D))\n",
    "    \n",
    "    AA = np.tensordot(al, al, axes=([2], [0]))\n",
    "    O = np.tensordot(AA, HH, axes=([1,2], [0,2]))\n",
    "    O = np.tensordot(O, np.conjugate(AA), axes=([0,2,3], [0,1,2]))\n",
    "    \n",
    "    LH = np.tensordot(O, EL, axes=([0,1],[0,1]))\n",
    "    \n",
    "    return LH\n",
    "\n",
    "def buildRH(ar, HH):\n",
    "    ER = np.tensordot(ar, np.conjugate(ar), axes=([1],[1]))\n",
    "    III = np.tensordot(np.identity(D),np.identity(D), axes=([],[]))\n",
    "    ER = III - ER\n",
    "    ER = np.reshape(np.swapaxes(ER, 1,2), (D*D, D*D))\n",
    "    ER = np.reshape(sc.pinv(ER, rcond=1e-14), (D,D,D,D))\n",
    "    \n",
    "    AA = np.tensordot(ar, ar, axes=([2], [0]))\n",
    "    O = np.tensordot(AA, HH, axes=([1,2], [0,2]))\n",
    "    O = np.tensordot(O, np.conjugate(AA), axes=([1,2,3], [3,1,2]))\n",
    "    \n",
    "    RH = np.tensordot(O, ER, axes=([0,1],[2,3]))\n",
    "    \n",
    "    return RH\n",
    "\n",
    "def buildG(al, ar, HH):\n",
    "    LH = buildLH(al, HH)\n",
    "    RH = buildRH(ar, HH)\n",
    "    \n",
    "    IID = np.identity(D)\n",
    "    IId = np.identity(d)\n",
    "    \n",
    "    #MAKE G1:\n",
    "    \n",
    "    LHII = np.tensordot(LH, IId, axes=([],[]))\n",
    "    LHII = np.tensordot(LHII, IID, axes=([],[]))\n",
    "    LHII = np.swapaxes(np.swapaxes( np.swapaxes(LHII, 1,2), 2,4), 4,3)\n",
    "    \n",
    "    IIRH = np.tensordot(IID, IId, axes=([],[]))\n",
    "    IIRH = np.tensordot(IIRH, RH, axes=([],[]))\n",
    "    IIRH = np.swapaxes(np.swapaxes( np.swapaxes(IIRH, 1,2), 2,4), 4,3)\n",
    "    \n",
    "    a = np.tensordot(al,HH, axes=([1],[0]))\n",
    "    a = np.tensordot(a, np.conjugate(al), axes=([0,2],[0,1]))\n",
    "    a = np.swapaxes(a, 2,3)\n",
    "    ALHI = np.tensordot(a, IID, axes=([],[]))\n",
    "    ALHI = np.swapaxes(np.swapaxes(ALHI, 2,4), 3,4)\n",
    "    \n",
    "    b = np.tensordot(ar,HH, axes=([1],[2]))\n",
    "    b = np.tensordot(b, np.conjugate(ar), axes=([1,4],[2,1]))\n",
    "    b = np.swapaxes(b, 0,1)\n",
    "    IHAR = np.tensordot( IID, b, axes=([],[]))\n",
    "    IHAR = np.swapaxes(np.swapaxes(IHAR, 1,2), 2,3)\n",
    "    \n",
    "    G1 = LHII + IIRH + ALHI + IHAR\n",
    "    \n",
    "    #MAKE G2:\n",
    "    \n",
    "    LHII2 = np.tensordot(LH, al, axes=([0],[0]))\n",
    "    LHII2 = np.tensordot(LHII2, np.conjugate(al), axes=([0,1],[0,1]) )\n",
    "    LHII2 = np.tensordot(LHII2, IID, axes=([],[]) )\n",
    "    LHII2 = np.swapaxes(LHII2, 1,2)\n",
    "    \n",
    "    IIRH2 = np.tensordot(al, np.conjugate(al), axes=([0,1],[0,1]))\n",
    "    IIRH2 = np.tensordot(IIRH2, RH, axes=([],[]))\n",
    "    IIRH2 = np.swapaxes(IIRH2, 1,2)\n",
    "    \n",
    "    a = np.tensordot(al, al, axes=([2], [0]))                     \n",
    "    aa = np.tensordot(a, HH, axes=([1,2], [0,2]))                  \n",
    "    ALHI2 = np.tensordot(aa, np.conjugate(a), axes=([0,2,3], [0,1,2]))\n",
    "    ALHI2 = np.tensordot(ALHI2, IID, axes=([],[]))\n",
    "    ALHI2 = np.swapaxes(ALHI2, 1,2)\n",
    "                         \n",
    "    b = np.tensordot(al,HH, axes=([1],[0]))\n",
    "    b = np.tensordot(b,ar, axes=([3],[1]))\n",
    "    b = np.tensordot(b, np.conjugate(al), axes=([0,2],[0,1]))\n",
    "    IHAR2 = np.tensordot(b, np.conjugate(ar), axes=([1,3],[1,2]))                     \n",
    "    \n",
    "    G2 = LHII2 + IIRH2 + ALHI2 + IHAR2\n",
    "    \n",
    "    return G1, G2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding AL, AR:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"alar.png\" width=\"600\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findALAR(AC, C):\n",
    "    ULA, PLA = sc.polar( np.reshape(AC,(d*D, D)), side='left')\n",
    "    ULC, PLC = sc.polar(C, side='left')\n",
    "    \n",
    "    al = np.array( np.dot(ULA, np.matrix(ULC).getH()) ) \n",
    "    \n",
    "    URA, PRA = sc.polar( np.reshape(AC, (D,d*D)), side='right')\n",
    "    URC, PRC = sc.polar(C, side='right')\n",
    "    \n",
    "    ar = np.array( np.dot(np.matrix(URC).getH(), URA) )\n",
    "    \n",
    "    al = np.reshape(al, (D,d,D))\n",
    "    ar = np.reshape(ar, (D,d,D))\n",
    "    return al, ar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Increasing D while executing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def increaseD(al, c, ar, HH, dt):\n",
    "    global D\n",
    "    ds = 1e-8\n",
    "    \n",
    "    #Build projection operator\n",
    "    III = np.swapaxes(np.tensordot(np.identity(D),np.identity(d), axes=([],[])), 1,2)\n",
    "    TL = np.tensordot(al, np.conjugate(al), axes=([2],[2]))\n",
    "    TR = np.swapaxes( np.swapaxes( np.tensordot(np.conjugate(ar), ar, axes=([0],[0])), 0,1 ), 2,3)\n",
    "    PL = III - TL\n",
    "    PR = III - TR\n",
    "\n",
    "    #Evolve Hamiltonian\n",
    "    HH = np.reshape( np.swapaxes(HH, 1,2), (d*d, d*d))\n",
    "    EH = sc.expm(-1j*dt*HH)\n",
    "    EH = np.reshape(EH, (d,d,d,d))\n",
    "    \n",
    "    #Contract and make SVD\n",
    "    a = np.tensordot(al, c, axes=([2],[0]))\n",
    "    a = np.tensordot(a, ar, axes=([2],[0]))\n",
    "    a = np.tensordot(a, EH, axes=([1,2],[0,1]))\n",
    "    a = np.tensordot(PL, a, axes=([2,3],[0,2]))\n",
    "    a = np.tensordot(a, PR, axes=([2,3],[0,1]))\n",
    "    a = np.reshape(a, (D*d, D*d))\n",
    "    \n",
    "    U, S, V = np.linalg.svd(a) \n",
    "    \n",
    "    \n",
    "    i = 0\n",
    "    AL0 = []\n",
    "    AL1 = []\n",
    "    AR0 = []\n",
    "    AR1 = []\n",
    "    while(S[i] > ds and Dmax > D + i):\n",
    "        u = np.reshape(U[:,i], (D,d))\n",
    "        v = np.reshape(V[:,i], (D,d))\n",
    "        \n",
    "        #Czy to dobrze sklada...\n",
    "        AL0.extend(u[:,0])\n",
    "        AL1.extend(u[:,1])\n",
    "        AR0.extend(v[:,0])\n",
    "        AR1.extend(v[:,1])\n",
    "        \n",
    "        i = i + 1\n",
    "    \n",
    "    #Create bigger matrixes with vectors\n",
    "    if i > 0:\n",
    "        print(\"Dodane i: \",i)\n",
    "        bigAR = np.zeros((D+i, d, D+i)).astype(complex)\n",
    "        bigAR[0:D, :, 0:D] = ar\n",
    "        bigAL = np.zeros((D+i, d, D+i)).astype(complex)\n",
    "        bigAL[0:D, :, 0:D] = al\n",
    "        \n",
    "        #Czy to dziala dobrze..\n",
    "        bigAL[0:D, 0, D:D+i] = np.reshape(AL0, (D, i))\n",
    "        bigAL[0:D, 1, D:D+i] = np.reshape(AL1, (D, i))\n",
    "        \n",
    "        bigAR[D:D+i, 0, 0:D] = np.conjugate( np.transpose( np.reshape(AR0, (D, i)) ))\n",
    "        bigAR[D:D+i, 1, 0:D] = np.conjugate( np.transpose( np.reshape(AR1, (D, i)) ))\n",
    "        \n",
    "        bigC = np.zeros((D+i, D+i)).astype(complex)\n",
    "        bigC[0:D, 0:D] = c\n",
    "        c = bigC\n",
    "        \n",
    "        D = D + i\n",
    "        al = bigAL\n",
    "        ar = bigAR\n",
    "    \n",
    "    return al, c, ar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TDVP algorithm:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"algo.png\" width=\"700\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "outcomesX = []\n",
    "outcomesZ = []\n",
    "outcomesH = []\n",
    "timing = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tdvp(al, c, ar, HH):\n",
    "    dt = 0.01\n",
    "    time = 100\n",
    "    #Normowac Hamiltonian do sredniej zera z każdą petlą?\n",
    "    \n",
    "    outcomesX.clear()\n",
    "    outcomesZ.clear()\n",
    "    outcomesH.clear()\n",
    "    timing.clear()\n",
    "    \n",
    "    #HH = normalizeHamiltonian(al, c, ar, HH)\n",
    "    for i in range(time):\n",
    "        #print(i)\n",
    "        G1, G2 = buildG(al, ar, HH)\n",
    "        G1 = np.reshape(G1, (D*d*D, D*d*D))\n",
    "        G2 = np.reshape(G2, (D*D, D*D))\n",
    "        \n",
    "        AC = np.reshape( np.tensordot(al, c, axes=([2],[0]) ), (D*d*D,1) )\n",
    "        c = np.reshape(c, (D*D, 1))\n",
    "        \n",
    "        #Pade approximation so D^3\n",
    "        AC = np.dot( sc.expm(-1j*dt*G1), AC)\n",
    "        c = np.dot( sc.expm(-1j*dt*G2), c)\n",
    "\n",
    "        AC = np.reshape(AC, (D,d,D))\n",
    "        c = np.reshape(c, (D,D))\n",
    "        \n",
    "        al, ar = findALAR(AC,c)\n",
    "        \n",
    "        outcomesX.append( contractHamiltonian(al, c, ar, X1)) \n",
    "        outcomesZ.append( contractHamiltonian(al, c, ar, ZZ))\n",
    "        outcomesH.append( contractHamiltonian(al, c, ar, H) )\n",
    "        timing.append(i*dt)\n",
    "        \n",
    "        #Powiększenie D wymiaru  #Na razie opcjonalne\n",
    "        #if D < Dmax:\n",
    "         #   al, c, ar = increaseD(al, c, ar, HH, dt)\n",
    "        #print(\"Actualne D: \", D)\n",
    "        \n",
    "    return al, c, ar, outcomesX, outcomesZ, outcomesH, timing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Main:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "AL, C, AR, _, _, _ , _= tdvp(AL, C, AR, H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OBSERWABLA 1X w czasie:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/justyna/anaconda3/envs/datascience/lib/python3.6/site-packages/numpy/core/numeric.py:501: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  return array(a, dtype, copy=False, order=order)\n"
     ]
    },
    {
     "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(timing, outcomesX)\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('<x>')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OBSERWABLA ZZ w czasie:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": [
    "plt.plot(timing, outcomesZ)\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('<Z>')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OBSERWABLA H w czasie:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": [
    "plt.plot(timing, outcomesH)\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('<H>')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code to get results for different D:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPlots(HH):\n",
    "    global D\n",
    "    listX = []\n",
    "    listZ = []\n",
    "    listH = []\n",
    "    \n",
    "    for DD in range(2,14,2):\n",
    "        D = DD\n",
    "        print(D)\n",
    "\n",
    "        A = np.zeros((D, d, D)).astype(complex)\n",
    "        A[0,0,0] = 1/np.sqrt(2)\n",
    "        A[0,1,0] = 1/np.sqrt(2)\n",
    "        \n",
    "        al, ar, c, _ = mixedCanonical(A)\n",
    "    \n",
    "        _, _, _, ox, oz, oh, t = tdvp(al, c, ar, HH)\n",
    "        \n",
    "        listX.append(ox[:])\n",
    "        listZ.append(oz[:])\n",
    "        listH.append(oh[:])\n",
    "        \n",
    "    return listX, listZ, listH, t   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "LX, LZ, LH, T = getPlots(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**X Observable for many**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "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": [
    "plt.plot(T, LX[0], label='D = 2')\n",
    "plt.plot(T, LX[1], label='D = 4')\n",
    "plt.plot(T, LX[2], label='D = 6')\n",
    "plt.plot(T, LX[3], label='D = 8')\n",
    "plt.plot(T, LX[4], label='D = 10')\n",
    "plt.plot(T, LX[5], label='D = 12')\n",
    "#plt.plot(T, LX[6], label='D = 14')\n",
    "plt.legend()\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('<X>')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ZZ Observable for many**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "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": [
    "plt.plot(T, LZ[0], label='D = 2')\n",
    "plt.plot(T, LZ[1], label='D = 4')\n",
    "plt.plot(T, LZ[2], label='D = 6')\n",
    "plt.plot(T, LZ[3], label='D = 8')\n",
    "plt.plot(T, LZ[4], label='D = 10')\n",
    "plt.plot(T, LZ[5], label='D = 12')\n",
    "#plt.plot(T, LZ[6], label='D = 14')\n",
    "plt.legend()\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('<ZZ>')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**H Observable for many**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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": [
    "plt.plot(T, LH[0], label='D = 2')\n",
    "plt.plot(T, LH[1], label='D = 4')\n",
    "plt.plot(T, LH[2], label='D = 6')\n",
    "plt.plot(T, LH[3], label='D = 8')\n",
    "plt.plot(T, LH[4], label='D = 10')\n",
    "plt.plot(T, LH[5], label='D = 12')\n",
    "#plt.plot(T, LH[6], label='D = 14')\n",
    "plt.legend()\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('<H>')\n",
    "plt.show()"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}