02_Measurements_and_Mixed_States.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": false,
     "locked": true,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/gianlucafugante/anaconda3/lib/python3.8/site-packages/qiskit/aqua/__init__.py:86: DeprecationWarning: The package qiskit.aqua is deprecated. It was moved/refactored to qiskit-terra For more information see <https://github.com/Qiskit/qiskit-aqua/blob/main/README.md#migration-guide>\n",
      "  warn_package('aqua', 'qiskit-terra')\n"
     ]
    },
    {
     "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": [
    "# Measurements\n",
    "\n",
    "**Exercise 1** (1 point). Measurements in the quantum computers we can access today always measure in the computational basis. This means that either the projection |0><0| or the |1><1| is applied on the qubit we are measuring, corresponding to the outcome 0 or 1. The Born rule tells us that we get either of these with the probability of the absolute value of the probability amplitude squared. The qubit afterwards is |0> or |1>, respectively.\n",
    "\n",
    "First, create a circuit in your preferred framework with two classical registers (and one quantum register if you're using Qiskit). The object should be called `circuit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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: \n",
       "      \n",
       "c0: 2/\n",
       "      </pre>"
      ],
      "text/plain": [
       "      \n",
       "q0_0: \n",
       "      \n",
       "c0: 2/\n",
       "      "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "circuit = QuantumCircuit()\n",
    "\n",
    "classical_register = ClassicalRegister(2)\n",
    "quantum_register   = QuantumRegister(1)\n",
    "\n",
    "circuit.add_register(classical_register)\n",
    "circuit.add_register(quantum_register)\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "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": [
    "classical_bits = get_classical_bits(circuit)\n",
    "assert classical_bits == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2** (1 point). Next, extend the circuit with a Hadamard gate and a measurement on the qubit. Write the measurement result in the first classical register. You will get a probabilistic outcome of 0 or 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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: ┤ H ├┤M├\n",
       "      └───┘└╥┘\n",
       "c0: 2/══════╩═\n",
       "            0 </pre>"
      ],
      "text/plain": [
       "      ┌───┐┌─┐\n",
       "q0_0: ┤ H ├┤M├\n",
       "      └───┘└╥┘\n",
       "c0: 2/══════╩═\n",
       "            0 "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "circuit.h(quantum_register[0])\n",
    "circuit.measure(quantum_register[0], classical_register[0])\n",
    "\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:48:31.136144Z",
     "start_time": "2018-11-19T19:48:30.043322Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise2",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "counts = get_single_measurement_counts(circuit)\n",
    "assert abs(counts['00']/100-.5) < 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3** (1 point). To see that the quantum state collapses to the basis state indicated by the outcome, apply a second measurement on the same circuit, but write the result in the second register. Executing the program should always give the same outcome in the two subsequent measurements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:48:31.147404Z",
     "start_time": "2018-11-19T19:48:31.139100Z"
    }
   },
   "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: ┤ H ├┤M├┤M├\n",
       "      └───┘└╥┘└╥┘\n",
       "c0: 2/══════╩══╩═\n",
       "            0  1 </pre>"
      ],
      "text/plain": [
       "      ┌───┐┌─┐┌─┐\n",
       "q0_0: ┤ H ├┤M├┤M├\n",
       "      └───┘└╥┘└╥┘\n",
       "c0: 2/══════╩══╩═\n",
       "            0  1 "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "circuit.measure(quantum_register[0], classical_register[1])\n",
    "\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise3",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "counts = get_counts(circuit)\n",
    "assert abs(counts['00']/100-.5) < 0.1\n",
    "assert abs(counts['11']/100-.5) < 0.1\n",
    "assert sum(counts.values()) == 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measuring multiqubit systems\n",
    "\n",
    "**Exercise 4** (1 point). We typically work with local measurements, meaning that the qubits are measured separately. Create a two-qubit circuit with measurements included that reproduces the uniform distribution on four outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:48:31.367295Z",
     "start_time": "2018-11-19T19:48:31.193956Z"
    }
   },
   "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",
       " q25_0: ┤ H ├─░─┤M├───\n",
       "        ├───┤ ░ └╥┘┌─┐\n",
       " q25_1: ┤ H ├─░──╫─┤M├\n",
       "        └───┘ ░  ║ └╥┘\n",
       "meas: 2/═════════╩══╩═\n",
       "                 0  1 </pre>"
      ],
      "text/plain": [
       "        ┌───┐ ░ ┌─┐   \n",
       " q25_0: ┤ H ├─░─┤M├───\n",
       "        ├───┤ ░ └╥┘┌─┐\n",
       " q25_1: ┤ H ├─░──╫─┤M├\n",
       "        └───┘ ░  ║ └╥┘\n",
       "meas: 2/═════════╩══╩═\n",
       "                 0  1 "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "circuit = QuantumCircuit()\n",
    "\n",
    "qr = QuantumRegister(2)\n",
    "circuit.add_register(qr)\n",
    "\n",
    "#circuit.initialize([1., 0., 0., 0.], circuit.qubits)\n",
    "\n",
    "circuit.h(qr)\n",
    "circuit.measure_all()\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise4",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "counts = get_counts(circuit)\n",
    "assert abs(counts['00']/100-.25) < 0.1\n",
    "assert abs(counts['01']/100-.25) < 0.1\n",
    "assert abs(counts['11']/100-.25) < 0.1\n",
    "assert sum(counts.values()) == 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 5** (1 point). This is a typical product state, showing no correlation between the qubits. In contrast, if you make simultaneous measurements on an entangled state, for instance the $$|\\phi^+\\rangle \\space or \\space the \\space |\\phi^-\\rangle$$ state, the measurement outcomes will be correlated. Create either of these states and measure both qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:48:31.507651Z",
     "start_time": "2018-11-19T19:48:31.369445Z"
    }
   },
   "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",
       " q37_0: ┤ H ├──■───░─┤M├───\n",
       "        └───┘┌─┴─┐ ░ └╥┘┌─┐\n",
       " q37_1: ─────┤ X ├─░──╫─┤M├\n",
       "             └───┘ ░  ║ └╥┘\n",
       "meas: 2/══════════════╩══╩═\n",
       "                      0  1 </pre>"
      ],
      "text/plain": [
       "        ┌───┐      ░ ┌─┐   \n",
       " q37_0: ┤ H ├──■───░─┤M├───\n",
       "        └───┘┌─┴─┐ ░ └╥┘┌─┐\n",
       " q37_1: ─────┤ X ├─░──╫─┤M├\n",
       "             └───┘ ░  ║ └╥┘\n",
       "meas: 2/══════════════╩══╩═\n",
       "                      0  1 "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "\n",
    "circuit = QuantumCircuit()\n",
    "\n",
    "qr = QuantumRegister(2)\n",
    "circuit.add_register(qr)\n",
    "\n",
    "\n",
    "circuit.h(qr[0])\n",
    "circuit.cx(qr[0], qr[1])\n",
    "circuit.measure_all()\n",
    "\n",
    "circuit.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise5",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "counts = get_counts(circuit)\n",
    "assert abs(counts['00']/100-.5) < 0.1\n",
    "assert abs(counts['11']/100-.5) < 0.1\n",
    "assert sum(counts.values()) == 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we only observe 00 and 11 as outcomes, even though we made measurements on two spatially separated qubits. If one measurement gives a value, the other one always give the same. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mixed states\n",
    "\n",
    "**Exercise 6** (1 point). The density matrix formalism is critical in understanding noise models and decoherence, so it is indispensible to start working with current and near-future quantum computers. Many simulator backends provide noise models, but it is out of scope for this course to develop a deep understanding of it.\n",
    "\n",
    "Instead, let's use the wavefunction simulator to create the (maximally) entangled state: $$|\\phi^+\\rangle$$ The object should be called circuit and do not include measurements. Your circuit should be in an object called `circuit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:48:31.519211Z",
     "start_time": "2018-11-19T19:48:31.509701Z"
    }
   },
   "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",
       "q52_0: ┤ H ├──■──\n",
       "       └───┘┌─┴─┐\n",
       "q52_1: ─────┤ X ├\n",
       "            └───┘</pre>"
      ],
      "text/plain": [
       "       ┌───┐     \n",
       "q52_0: ┤ H ├──■──\n",
       "       └───┘┌─┴─┐\n",
       "q52_1: ─────┤ X ├\n",
       "            └───┘"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "circuit = QuantumCircuit()\n",
    "\n",
    "qr = QuantumRegister(2)\n",
    "circuit.add_register(qr)\n",
    "\n",
    "\n",
    "circuit.h(qr[0])\n",
    "circuit.cx(qr[0], qr[1])\n",
    "#circuit.measure_all()\n",
    "\n",
    "circuit.draw()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "exercise6",
     "locked": true,
     "points": "1",
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "amplitudes = get_amplitudes(circuit)\n",
    "assert np.allclose(np.array([np.sqrt(2)/2, 0, 0, np.sqrt(2)/2]), amplitudes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 7** (1 point). Create the density matrix called `dm` of the probability amplitudes contained in the `amplitudes` array. Recall that you need a ket and a bra in this order to produce it, but the shape of the `amplitudes` array is incorrect for transposition. Reshape it first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. +0.j, 0.5+0.j],\n",
       "       [0. +0.j, 0. +0.j]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###\n",
    "### YOUR CODE HERE\n",
    "###\n",
    "amplitudes = amplitudes.reshape(2,2)\n",
    "\n",
    "dm = np.outer(amplitudes[0], amplitudes[1])\n",
    "dm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-19T19:48:31.537553Z",
     "start_time": "2018-11-19T19:48:31.521246Z"
    },
    "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": [
    "Taking the partial trace of a density matrix is the equivalent of taking the marginal of a joint probability distribution along one random variable. If we take the partial trace of this density matrix in any of the qubit subsystems, we are going to get the maximally mixed state, that is, the uniform distribution over the remaining system. This reflects the strong correlation between the two subsystems: if we marginalize over one, we have no predictive power over the other one. We exploit this property when we create protocols for preparing thermal states."
   ]
  }
 ],
 "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
}