03_Evolution_in_Closed_and_Open_Systems.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": [
    "\n",
    "# Unitary evolution\n",
    "\n",
    "**Exercise 1** (1 point). The conjugate transpose of a unitary matrix is its inverse. Write a function that checks if a 2 x 2 numpy array is unitary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:49:07.614968Z",
     "start_time": "2018-11-19T19:49:07.530927Z"
    }
   },
   "outputs": [],
   "source": [
    "def is_unitary(matrix):\n",
    "    \n",
    "    ###\n",
    "    ### YOUR CODE HERE\n",
    "    ###\n",
    "\n",
    "    m = np.asmatrix(matrix)\n",
    "    identity = np.asmatrix(np.identity(m.shape[0]))\n",
    "    \n",
    "    '''\n",
    "    print('matrix')\n",
    "    print(matrix)\n",
    "    \n",
    "    print('m.dot(m.getH())')\n",
    "    print(m.dot(m.getH()))\n",
    "    print(np.allclose(m.dot(m.getH()), identity))\n",
    "    \n",
    "    print('m.getH().dot(m)')\n",
    "    print(m.getH().dot(m))\n",
    "    print(np.allclose(m.getH().dot(m), identity))\n",
    "    '''\n",
    "    \n",
    "    if np.allclose(m.dot(m.getH()), identity) and np.allclose(m.getH().dot(m), identity):\n",
    "        return True\n",
    "    else: \n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise1",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "X = np.array([[0, 1], [1, 0]])\n",
    "H = 1/np.sqrt(2)*np.array([[1, 1], [1, -1]])\n",
    "random_matrix = np.random.rand(2, 2)\n",
    "assert is_unitary(X)\n",
    "assert is_unitary(H)\n",
    "assert not is_unitary(random_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2** (1 point). The eigenvalues of unitary operators always lie on the complex unit circle. We exploit this property over and over again. For instance, the quantum phase estimation algorithm estimates the eigenvalues through the phase that describes the eigenvalues angle on the complex unit circle. Calculate the eigenvalues of the Hadamard gate and store them in a numpy array called `eigenvalues`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:49:07.626531Z",
     "start_time": "2018-11-19T19:49:07.618259Z"
    }
   },
   "outputs": [],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "eigenvalues = np.linalg.eig(H)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise2",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "###\n",
    "### AUTOGRADER TEST - DO NOT REMOVE\n",
    "###\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3** (1 point). Unitary operations are reversible. In fact, we often reverse them on purpose: this is called uncomputing, and used, for instance, in the quantum matrix inversion algorithm that underlies many coherent quantum machine learning protocols. The reason we do that is to remove the entanglement we might have created, so that tracing out a subsystem would not interfere with our calculations (the remaining system will not be a mixed state). Create a circuit in your preferred framework that applies the X and H gates in this sequence. The circuit should be in an object called `circuit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:49:08.710098Z",
     "start_time": "2018-11-19T19:49:07.629733Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌───┐┌───┐\n",
       "q0_0: ┤ X ├┤ H ├\n",
       "      └───┘└───┘</pre>"
      ],
      "text/plain": [
       "      ┌───┐┌───┐\n",
       "q0_0: ┤ X ├┤ H ├\n",
       "      └───┘└───┘"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "circuit = QuantumCircuit()\n",
    "qr = QuantumRegister(1)\n",
    "circuit.add_register(qr)\n",
    "\n",
    "circuit.x(qr[0])\n",
    "circuit.h(qr[0])\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise3",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "amplitudes = get_amplitudes(circuit)\n",
    "assert np.allclose(amplitudes, np.array([1/np.sqrt(2), -1/np.sqrt(2)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4** (1 point). Extend this circuit to reverse the calculations you have done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌───┐┌───┐┌───┐┌───┐\n",
       "q0_0: ┤ X ├┤ H ├┤ H ├┤ X ├\n",
       "      └───┘└───┘└───┘└───┘</pre>"
      ],
      "text/plain": [
       "      ┌───┐┌───┐┌───┐┌───┐\n",
       "q0_0: ┤ X ├┤ H ├┤ H ├┤ X ├\n",
       "      └───┘└───┘└───┘└───┘"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "circuit.h(qr[0])\n",
    "circuit.x(qr[0])\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "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": [
    "amplitudes = get_amplitudes(circuit)\n",
    "program_length = get_circuit_length(circuit)\n",
    "assert np.allclose(amplitudes, np.array([1, 0])), \"The circuit is not successfully reversed\"\n",
    "assert program_length == 4, \"The circuit does not have the right number of gates\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interaction with the environment: open systems\n",
    "\n",
    "**Exercise 5** (2 points). Contemporary quantum computers are open systems: they interact with the environment. The nature of the interaction can often be characterized by noise models. Even if the system starts in a pure state, the interaction with the environment will turn it into a mixed state. The state loses coherence (the off-diagonal terms in the density matrix). Furthermore, increasing noise may completely destroy entanglement, so we can no longer use it as a resource for calculations. In general, it is a very hard problem to tell how much noise can be tolerated so that the remaining state is still useful for some calculations.\n",
    "\n",
    "We introduced a simple function called `mixed_state` that interpolated a pure state with the maximally mixed state: $$\\mathbb{1}/d$$ where *d* is the dimension of the system. We also talked about thermal states: at infinite temperature, you recover the uniform distribution over the energy levels of the system. This is, in fact, is just the maximally mixed state.\n",
    "\n",
    "We talk about energy levels and Hamiltonians in the subsequent notebook. For the time being, imagine that you have a qubit system: this has two levels, in other words, two possible energies. Let's make these -1.0 and +1.0. The thermal state of this qubit will have the Boltzmann distribution in its diagonal. Calculate this density matrix at temperature T=1 and store it in a numpy array called `dm`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:49:08.730307Z",
     "start_time": "2018-11-19T19:49:08.714253Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "energies = np.array([-1.0, +1.0])\n",
    "T = 1\n",
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "pi = np.exp(-energies/T)\n",
    "Z = pi.sum()\n",
    "pi /= Z\n",
    "dm = np.diag(pi)"
   ]
  },
  {
   "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": [
    "The thermal state itself is interesting for calculations. It is the property of a system in equilibrium with the environment. Classical simulations of achieving an equilibrium are often computationally expensive: for instance, inference in probabilistic graphical models requires this. This is where quantum protocols that create a thermal state become important."
   ]
  }
 ],
 "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"
  },
  "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
}