04_Classical_and_Quantum_Many-Body_Physics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available frameworks:\n",
      "Qiskit\n",
      "D-Wave Ocean\n"
     ]
    }
   ],
   "source": [
    "%run -i \"assignment_helper.py\"\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Ising model\n",
    "\n",
    "**Exercise 1** (1 point). The Ising model is a basic model of statistical mechanics that explains a lot about how quantum optimizers work. Its energy is described by its Hamiltonian:\n",
    "\n",
    "$$ H=-\\sum_{<i,j>} J_{ij} \\sigma_i \\sigma_{j} - \\sum_i h_i \\sigma_i$$\n",
    "\n",
    "Write a function that calculates this energy amount for a linear chain of spins. The function takes three arguments: `J`, `h`, and `σ`, corresponding to the coupling strengths, the onsite field at each site, and the specific spin configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:27.336290Z",
     "start_time": "2018-11-19T20:00:27.331856Z"
    }
   },
   "outputs": [],
   "source": [
    "def calculate_energy(J, h, σ):\n",
    "    ###\n",
    "    ### YOUR CODE HERE\n",
    "    ###\n",
    "\n",
    "    magnetic_interaction = np.array(h).dot(np.array(σ))\n",
    "    \n",
    "    coupling_interaction = 0.\n",
    "    \n",
    "    try:\n",
    "        for i in range(len(J)):\n",
    "            coupling_interaction = coupling_interaction + ( J[i] * σ[i] * σ[i+1] )\n",
    "        \n",
    "        return np.negative(coupling_interaction + magnetic_interaction)\n",
    "    \n",
    "    except:\n",
    "        print(\"An exception occurred\")\n",
    "        return False\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:27.358242Z",
     "start_time": "2018-11-19T20:00:27.340861Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise1",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "J = [1.0, -1.0]\n",
    "σ = [+1, -1, +1]\n",
    "h = [0.5, 0.5, 0.4]\n",
    "assert abs(calculate_energy(J, h, σ)+0.4) < 0.01\n",
    "J = [-1.0, 0.5, 0.9]\n",
    "σ = [+1, -1, -1, -1]\n",
    "h = [4, 0.2, 0.4, 0.7]\n",
    "assert abs(calculate_energy(J, h, σ)+5.1) < 0.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2** (2 points). The sign of the coupling defines the nature of the interaction, ferromagnetic or antiferromagnetic, corresponding to positive and negative J values, respectively. Setting the couplings to zero, we have a non-interacting model. Create an arbitrary antiferromagnetic model on three sites with no external field. Define the model through variables `J` and `h`. Iterate over all solutions and write the optimal one in a variable called `σ`. If the optimum is degenerate, that is, you have more than one optimal configuration, keep one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:27.407303Z",
     "start_time": "2018-11-19T20:00:27.389825Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2.0 (1.0, -1.0, 1.0)\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "h = [0., 0., 0.]\n",
    "J = [-1., -1.]\n",
    "all_σ_permutations = [p for p in itertools.product([1.,-1.], repeat=3)]\n",
    "\n",
    "\n",
    "solutions = []\n",
    "\n",
    "for σ_i in all_σ_permutations:\n",
    "    energy = calculate_energy(J, h, σ_i)\n",
    "    solutions.append((energy, σ_i))\n",
    "    \n",
    "\n",
    "solutions.sort(key=lambda x:x[0])\n",
    "σ = solutions[0][1]\n",
    "print(solutions[0][0], σ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise2",
     "locked": true,
     "points": "2",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert all([J_i < 0 for J_i in J])\n",
    "assert all([h_i == 0 for h_i in h])\n",
    "assert len(J) == 2\n",
    "assert len(h) == 3\n",
    "assert all([σ[i]*σ[i+1] == -1 for i, _ in enumerate(J)]), \"The configuration is not the optimum of an antiferromagnetic system\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3** (1 point). Iterating over all solutions is clearly not efficient, since there are exponentially many configurations in the number of sites. From the perspective of computer science, this is a combinatorial optimization problem, and it is a known NP-hard problem. Many heuristic methods have been invented to tackle the problem. One of them is simulated annealing. It is implemented in dimod. Create the same antiferromagnetic model in dimod as above. Keep in mind that dimod uses a plus and not a minus sign in the Hamiltonian, so the sign of your couplings should be reversed. Store the model in an object called `model`, which should be a `BinaryQuadraticModel`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:27.549002Z",
     "start_time": "2018-11-19T20:00:27.454734Z"
    }
   },
   "outputs": [],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "h = {0: 0, 1: 0, 2: 0}\n",
    "J = {(0, 1): 1., (1, 2): 1.}\n",
    "\n",
    "model = dimod.BinaryQuadraticModel(h, J, 0.0, dimod.SPIN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simulated annealing solver requires us to define the couplings as a dictionary between spins, and we must also pass the external field values as a dictionary. The latter is all zeros for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:27.555690Z",
     "start_time": "2018-11-19T20:00:27.551785Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise3",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert isinstance(model, dimod.binary_quadratic_model.BinaryQuadraticModel), \"Wrong model type\"\n",
    "assert model.vartype == dimod.SPIN, \"Wrong variables: binary model instead of spin system\"\n",
    "assert all([J_i > 0 for J_i in J.values()]), \"The model is not antiferromagnetic\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4** (1 point). Sample the solution space a hundred times and write the response in an object called `response`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:27.575330Z",
     "start_time": "2018-11-19T20:00:27.557800Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    0  1  2 energy num_oc.\n",
      "0  +1 -1 +1   -2.0       1\n",
      "2  +1 -1 +1   -2.0       1\n",
      "7  -1 +1 -1   -2.0       1\n",
      "10 -1 +1 -1   -2.0       1\n",
      "22 +1 -1 +1   -2.0       1\n",
      "24 +1 -1 +1   -2.0       1\n",
      "27 -1 +1 -1   -2.0       1\n",
      "28 +1 -1 +1   -2.0       1\n",
      "36 +1 -1 +1   -2.0       1\n",
      "50 +1 -1 +1   -2.0       1\n",
      "51 +1 -1 +1   -2.0       1\n",
      "53 -1 +1 -1   -2.0       1\n",
      "54 +1 -1 +1   -2.0       1\n",
      "58 -1 +1 -1   -2.0       1\n",
      "59 -1 +1 -1   -2.0       1\n",
      "61 -1 +1 -1   -2.0       1\n",
      "83 -1 +1 -1   -2.0       1\n",
      "87 -1 +1 -1   -2.0       1\n",
      "88 +1 -1 +1   -2.0       1\n",
      "91 +1 -1 +1   -2.0       1\n",
      "92 -1 +1 -1   -2.0       1\n",
      "95 +1 -1 +1   -2.0       1\n",
      "96 +1 -1 +1   -2.0       1\n",
      "97 +1 -1 +1   -2.0       1\n",
      "1  -1 -1 +1    0.0       1\n",
      "3  +1 +1 -1    0.0       1\n",
      "4  -1 +1 +1    0.0       1\n",
      "5  +1 +1 -1    0.0       1\n",
      "8  +1 +1 -1    0.0       1\n",
      "11 -1 +1 +1    0.0       1\n",
      "13 -1 +1 +1    0.0       1\n",
      "14 +1 -1 -1    0.0       1\n",
      "16 -1 -1 +1    0.0       1\n",
      "17 +1 +1 -1    0.0       1\n",
      "18 +1 +1 -1    0.0       1\n",
      "19 -1 +1 +1    0.0       1\n",
      "20 -1 -1 +1    0.0       1\n",
      "21 -1 +1 +1    0.0       1\n",
      "23 -1 +1 +1    0.0       1\n",
      "25 -1 +1 +1    0.0       1\n",
      "26 +1 +1 -1    0.0       1\n",
      "29 -1 +1 +1    0.0       1\n",
      "31 +1 -1 -1    0.0       1\n",
      "35 +1 -1 -1    0.0       1\n",
      "37 +1 +1 -1    0.0       1\n",
      "39 +1 +1 -1    0.0       1\n",
      "40 +1 +1 -1    0.0       1\n",
      "41 -1 -1 +1    0.0       1\n",
      "42 -1 +1 +1    0.0       1\n",
      "44 -1 -1 +1    0.0       1\n",
      "45 -1 -1 +1    0.0       1\n",
      "46 -1 +1 +1    0.0       1\n",
      "47 -1 -1 +1    0.0       1\n",
      "49 +1 -1 -1    0.0       1\n",
      "55 -1 -1 +1    0.0       1\n",
      "57 -1 +1 +1    0.0       1\n",
      "60 +1 -1 -1    0.0       1\n",
      "63 -1 +1 +1    0.0       1\n",
      "64 -1 -1 +1    0.0       1\n",
      "65 +1 +1 -1    0.0       1\n",
      "67 +1 +1 -1    0.0       1\n",
      "68 +1 +1 -1    0.0       1\n",
      "70 +1 -1 -1    0.0       1\n",
      "72 -1 +1 +1    0.0       1\n",
      "73 +1 -1 -1    0.0       1\n",
      "74 -1 -1 +1    0.0       1\n",
      "75 -1 -1 +1    0.0       1\n",
      "76 +1 -1 -1    0.0       1\n",
      "80 -1 +1 +1    0.0       1\n",
      "81 +1 +1 -1    0.0       1\n",
      "84 -1 +1 +1    0.0       1\n",
      "85 -1 +1 +1    0.0       1\n",
      "90 -1 +1 +1    0.0       1\n",
      "93 +1 +1 -1    0.0       1\n",
      "94 +1 -1 -1    0.0       1\n",
      "99 +1 +1 -1    0.0       1\n",
      "6  +1 +1 +1    2.0       1\n",
      "9  -1 -1 -1    2.0       1\n",
      "12 +1 +1 +1    2.0       1\n",
      "15 +1 +1 +1    2.0       1\n",
      "30 +1 +1 +1    2.0       1\n",
      "32 -1 -1 -1    2.0       1\n",
      "33 +1 +1 +1    2.0       1\n",
      "34 +1 +1 +1    2.0       1\n",
      "38 -1 -1 -1    2.0       1\n",
      "43 +1 +1 +1    2.0       1\n",
      "48 -1 -1 -1    2.0       1\n",
      "52 +1 +1 +1    2.0       1\n",
      "56 -1 -1 -1    2.0       1\n",
      "62 +1 +1 +1    2.0       1\n",
      "66 -1 -1 -1    2.0       1\n",
      "69 +1 +1 +1    2.0       1\n",
      "71 +1 +1 +1    2.0       1\n",
      "77 +1 +1 +1    2.0       1\n",
      "78 -1 -1 -1    2.0       1\n",
      "79 +1 +1 +1    2.0       1\n",
      "82 +1 +1 +1    2.0       1\n",
      "86 +1 +1 +1    2.0       1\n",
      "89 -1 -1 -1    2.0       1\n",
      "98 -1 -1 -1    2.0       1\n",
      "['SPIN', 100 rows, 100 samples, 3 variables]\n"
     ]
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "sampler = dimod.RandomSampler()\n",
    "response = sampler.sample(model, num_reads=100)\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise4",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert len(response) == 100, \"Not the correct number of samples\"\n",
    "sample = response.first.sample\n",
    "assert all([sample[i]*sample[i+1] == -1 for i, _ in enumerate(J.values())]), \"The optimal configuration is not antiferromagnetic\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The transverse-field Ising model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 5** (1 point). Adiabatic quantum computation and quantum annealing rely on quantum variants of the classical Ising model, and so do some variational algorithms like the quantum approximate optimization algorithm. To understand the logic behind these simple quantum-many body systems, first let us take another look at the classical Ising model, but write the Hamiltonian of the system in the quantum mechanical formalism, that is, with operators:\n",
    "\n",
    "$$ H=-\\sum_{<i,j>} J_{ij} \\sigma^Z_i \\sigma^Z_{j} - \\sum_i h_i \\sigma^Z_i$$\n",
    "\n",
    "Assume that you only have two sites. Create the Hamiltonian: $$H=-\\sigma^Z_1\\sigma^Z_2$$ as a 4 x 4 numpy array called `H`. Recall that on a single site, the Pauli-Z is: $$\\sigma^Z = \\begin{bmatrix}1 & 0\\\\ 0& -1\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:28.652206Z",
     "start_time": "2018-11-19T20:00:28.578778Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  0  0  0]\n",
      " [ 0  1  0  0]\n",
      " [ 0  0  1  0]\n",
      " [ 0  0  0 -1]]\n"
     ]
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "sz_1 = np.matrix([[1,0],[0,-1]])\n",
    "sz_2 = np.matrix([[1,0],[0,-1]])\n",
    "\n",
    "H = np.kron(sz_1, sz_2).dot(-1)\n",
    "print(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise5",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "###\n",
    "### AUTOGRADER TEST - DO NOT REMOVE\n",
    "###\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now take a look at the eigenvector corresponding to the two smallest eigenvalues (both are -1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]]\n",
      "[[0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [1.]]\n",
      "(array([-1., -1.,  1.,  1.]), matrix([[1., 0., 0., 0.],\n",
      "        [0., 0., 0., 1.],\n",
      "        [0., 0., 1., 0.],\n",
      "        [0., 1., 0., 0.]]))\n"
     ]
    }
   ],
   "source": [
    "eigenvalues, eigenvectors = np.linalg.eigh(H)\n",
    "print(eigenvectors[:, 0:1])\n",
    "print(eigenvectors[:, 1:2])\n",
    "\n",
    "print(np.linalg.eigh(H))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is just the |00> and |11> states, confirming our classical intuition that in this ferromagnetic case (J=1), the two spins should be aligned to get the minimum energy, the ground state energy.\n",
    "\n",
    "We copy the function that calculates the energy expectation value of a Hamiltonian H and check the expectation value in the |00> state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def calculate_energy_expectation(state, hamiltonian):\n",
    "    return float(np.dot(state.T.conj(), np.dot(hamiltonian, state)).real)\n",
    "\n",
    "ψ = np.kron([[1], [0]], [[1], [0]])\n",
    "calculate_energy_expectation(ψ, H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It comes to -1.\n",
    "\n",
    "**Exercise 6** (1 point). If we add a term that does not commute with the Pauli-Z operator, the Hamiltonian will display non-classical effects. Add a Pauli-X term to both sites, so your total Hamiltonian will be: $$H=-\\sigma^Z_1\\sigma^Z_2-\\sigma^X_1-\\sigma^X_2$$ in the object `H`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T20:00:28.755692Z",
     "start_time": "2018-11-19T20:00:28.731315Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1. -1. -1.  0.]\n",
      " [-1.  1.  0. -1.]\n",
      " [-1.  0.  1. -1.]\n",
      " [ 0. -1. -1. -1.]]\n"
     ]
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "sx_1 = np.matrix([[0,1],[1,0]])\n",
    "sx_2 = np.matrix([[0,1],[1,0]])\n",
    "\n",
    "\n",
    "\n",
    "H_x1 = np.kron(sx_1, np.identity(2)).dot(-1)\n",
    "H_x2 = np.kron(np.identity(2), sx_2).dot(-1)\n",
    "\n",
    "H = H + H_x1 + H_x2\n",
    "\n",
    "print(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise6",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "###\n",
    "### AUTOGRADER TEST - DO NOT REMOVE\n",
    "###\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you take a look at the matrix of the Hamiltonian, it has off-diagonal terms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[-1., -1., -1.,  0.],\n",
       "        [-1.,  1.,  0., -1.],\n",
       "        [-1.,  0.,  1., -1.],\n",
       "        [ 0., -1., -1., -1.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The energy expectation value in the |00> is not affected, the transverse field only lowers the ground state energy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [0]\n",
      " [0]\n",
      " [0]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ψ = np.kron([[1], [0]], [[1], [0]])\n",
    "print(ψ)\n",
    "calculate_energy_expectation(ψ, H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 7** (1 point). Is this the ground state energy? Use the eigenvector corresponding to the smallest eigenvalue and calculate the expectation value of it. Store the value in a variable called `energy_expectation_value`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.0\n",
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "energy_expectation_value = calculate_energy_expectation(eigenvectors[:, 0:1], H)\n",
    "print(energy_expectation_value)\n",
    "energy_expectation_value = calculate_energy_expectation(eigenvectors[:, 1:2], H)\n",
    "print(energy_expectation_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise7",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "###\n",
    "### AUTOGRADER TEST - DO NOT REMOVE\n",
    "###\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naturally, this value also corresponds to the lowest eigenvalue and indeed, this is the ground state energy. So by calculating the eigendecomposition of the typically non-diagonal Hamiltonian, we can extract both the ground state and its energy. The difficulty comes from the exponential scaling of the matrix representing the Hamiltonian as a function of the number of sites. This is the original reason going back to the early 1980s to build a quantum computer: this device would implement (or simulate) the Hamiltonian in hardware. Say, a couple of hundred spins would be beyond the computational capacity of supercomputers, but having the physical spins and being able to set a specific Hamiltonian, we can extract quantities of interest, such the ground state."
   ]
  }
 ],
 "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.8.8"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  },
  "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
}