multiple-qubits-entangled-states.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "source": [
    "# Multiple Qubits & Entangled States"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single qubits are interesting, but individually they offer no computational advantage. We will now look at how we represent multiple qubits, and how these qubits can interact with each other. We have seen how we can represent the state of a qubit using a 2D-vector, now we will see how we can represent the state of multiple qubits.\n",
    "\n",
    "Unfortunately, this notebook is a bit mathematically intense, but that is the current nature of quantum computing. We are at the dawn of quantum computing similar to the first days of the classical computing where algorithms where implemented by wired circuit boards (okay, we are a bit more advanced here). Matter of fact, you can think of Qiskit as an assembly language (for those of you who remember writing assembler programs). Eventually, mankind will develop higher level languages (Microsoft is already building Q#) that will take advantage of quantum effects, but for now we just simply have to do the math."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "1. [Representing Multi-Qubit States](#represent)    \n",
    "2. [Single Qubit Gates on Multi-Qubit Statevectors](#single-qubit-gates)    \n",
    "3. [Multi-Qubit Gates](#multi-qubit-gates)    \n",
    "    3.1 [The CNOT-gate](#cnot)  \n",
    "    3.2 [Entangled States](#entangled)    \n",
    "\n",
    "\n",
    "## 1. Representing Multi-Qubit States <a id=\"represent\"></a>\n",
    "\n",
    "We saw that a single bit has two possible states, and a qubit state has two complex amplitudes. Similarly, two bits have four possible states:\n",
    "\n",
    "`00` `01` `10` `11`\n",
    "\n",
    "And to describe the state of two qubits requires four complex amplitudes. We store these amplitudes in a 4D-vector like so:\n",
    "\n",
    "$$ |a\\rangle = a_{00}|00\\rangle + a_{01}|01\\rangle + a_{10}|10\\rangle + a_{11}|11\\rangle = \\begin{bmatrix} a_{00} \\\\ a_{01} \\\\ a_{10} \\\\ a_{11} \\end{bmatrix} $$\n",
    "\n",
    "The rules of measurement still work in the same way:\n",
    "\n",
    "$$ p(|00\\rangle) = |\\langle 00 | a \\rangle |^2 = |a_{00}|^2$$\n",
    "\n",
    "And the same implications hold, such as the normalisation condition:\n",
    "\n",
    "$$ |a_{00}|^2 + |a_{01}|^2 + |a_{10}|^2 + |a_{11}|^2 = 1$$\n",
    "\n",
    "If we have two separated qubits, we can describe their collective state using the tensor product:\n",
    "\n",
    "$$ |a\\rangle = \\begin{bmatrix} a_0 \\\\ a_1 \\end{bmatrix}, \\quad |b\\rangle = \\begin{bmatrix} b_0 \\\\ b_1 \\end{bmatrix} $$\n",
    "\n",
    "$$ \n",
    "|ba\\rangle = |b\\rangle \\otimes |a\\rangle = \\begin{bmatrix} b_0 \\times \\begin{bmatrix} a_0 \\\\ a_1 \\end{bmatrix} \\\\ b_1 \\times \\begin{bmatrix} a_0 \\\\ a_1 \\end{bmatrix} \\end{bmatrix} = \\begin{bmatrix} b_0 a_0 \\\\ b_0 a_1 \\\\ b_1 a_0 \\\\ b_1 a_1 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "And following the same rules, we can use the tensor product to describe the collective state of any number of qubits. Here is an example with three qubits:\n",
    "\n",
    "$$ \n",
    "|cba\\rangle = \\begin{bmatrix} c_0 b_0 a_0 \\\\ c_0 b_0 a_1 \\\\ c_0 b_1 a_0 \\\\ c_0 b_1 a_1 \\\\\n",
    "                              c_1 b_0 a_0 \\\\ c_1 b_0 a_1 \\\\ c_1 b_1 a_0 \\\\ c_1 b_1 a_1 \\\\\n",
    "              \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "If we have $n$ qubits, we will need to keep track of $2^n$ complex amplitudes. As we can see, these vectors grow exponentially with the number of qubits. This is the reason quantum computers with large numbers of qubits are so difficult to simulate. A modern laptop can easily simulate a general quantum state of around 20 qubits, but simulating 100 qubits is too difficult for the largest supercomputers.\n",
    "\n",
    "Let's look at an example circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "thebelab-init"
    ]
   },
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "from math import pi\n",
    "import numpy as np\n",
    "from qiskit.visualization import plot_bloch_multivector, plot_histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size: 20px;color:blue\">Excercise</span>\n",
    "\n",
    "<span style=\"font-size: 16px;color:blue\">As mentioned in the previous notebook, in Qiskit you need to create a quantum circuit which is done via\n",
    "```python\n",
    "    QuantumComputing(<number of qubits>)\n",
    "```\n",
    "<span style=\"font-size: 16px;color:blue\">In this notebook we will have a chance to work with multiple qubits<span>  \n",
    "    \n",
    "<span style=\"font-size: 16px;color:blue\">In the following cell implement a 3 qubit quantum circuit placing each of the qubits in a superposition state. Hint: If you get stuck, take a look at the previous notebook to see how we created the quantum circuit and applied an Hadamard (H) gate.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------\n",
    "#Implement your code here\n",
    "\n",
    "#-------------------------------------------------------------\n",
    "#The following line prints out the circuit which we have done for you.\n",
    "#Do not modify the following line\n",
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each qubit is in the state $|+\\rangle$, so we should see the vector:\n",
    "\n",
    "$$ \n",
    "|{+++}\\rangle = \\frac{1}{\\sqrt{8}}\\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\\\ 1 \\\\\n",
    "                              1 \\\\ 1 \\\\ 1 \\\\ 1 \\\\\n",
    "              \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an asside, in Jupyter Notebooks we can display this nicely using Latex. If not using Jupyter Notebooks you may need to remove the array_to_latex function and use print(final_state) instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "# Let's see the result\n",
    "backend = Aer.get_backend('statevector_simulator')\n",
    "final_state = execute(qc,backend).result().get_statevector()\n",
    "\n",
    "# In Jupyter Notebooks we can display this nicely using Latex.\n",
    "# If not using Jupyter Notebooks you may need to remove the \n",
    "# array_to_latex function and use print(final_state) instead.\n",
    "from qiskit_textbook.tools import array_to_latex\n",
    "array_to_latex(final_state, pretext=\"\\\\text{Statevector} = \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we have our expected result.\n",
    "\n",
    "\n",
    "## 2. Single Qubit Gates on Multi-Qubit Statevectors <a id=\"single-qubit-gates\"></a>\n",
    "\n",
    "We have seen that an X-gate is represented by the matrix:\n",
    "\n",
    "$$\n",
    "X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "And that it acts on the state $|0\\rangle$ as so:\n",
    "\n",
    "$$\n",
    "X|0\\rangle = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 1\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "but it may not be clear how an X-gate would act on a qubit in a multi-qubit vector. Fortunately, the rule is quite simple; just as we used the tensor product to calculate multi-qubit statevectors, we use the tensor product to calculate matrices that act on these statevectors. Did you get all of that? Don't worry if you didn't, we will simply \"play\" with it and see what happens."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-size: 20px;color:blue\">Excercise</span>\n",
    "\n",
    "<span style=\"font-size: 16px;color:blue\">In the following cell, create a two qubit quantum circuit, put the first qubit in a superposition state and the second qubit in the |0> state. Remember, all qubits are initialized to the |0> state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------\n",
    "#Implement your code here\n",
    "\n",
    "#-------------------------------------------------------------\n",
    "#The following line prints out the circuit which we have done for you.\n",
    "#Do not modify the following line\n",
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can represent the simultaneous operations (H & X) using their tensor product (isn't this quite wonderful?):\n",
    "\n",
    "$$\n",
    "X|q_1\\rangle \\otimes H|q_0\\rangle = (X\\otimes H)|q_1 q_0\\rangle\n",
    "$$\n",
    "\n",
    "The operation looks like this:\n",
    "\n",
    "$$\n",
    "X\\otimes H = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} \\otimes \\tfrac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix} = \\frac{1}{\\sqrt{2}}\n",
    "\\begin{bmatrix} 0 \\times \\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}\n",
    "              & 1 \\times \\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}\n",
    "                \\\\ \n",
    "                1 \\times \\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}\n",
    "              & 0 \\times \\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}\n",
    "\\end{bmatrix} = \\frac{1}{\\sqrt{2}}\n",
    "\\begin{bmatrix} 0 & 0 & 1 & 1 \\\\\n",
    "                0 & 0 & 1 & -1 \\\\\n",
    "                1 & 1 & 0 & 0 \\\\\n",
    "                1 & -1 & 0 & 0 \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Which we can then apply to our 4D statevector $|q_1 q_0\\rangle$. This can become quite messy, you will often see the clearer notation:\n",
    "\n",
    "$$\n",
    "X\\otimes H = \n",
    "\\begin{bmatrix} 0 & H \\\\\n",
    "               H & 0\\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Instead of calculating this by hand, we can use Qiskit’s `unitary_simulator` to calculate this for us. The unitary simulator multiplies all the gates in our circuit together to compile a single unitary matrix that performs the whole quantum circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "backend = Aer.get_backend('unitary_simulator')\n",
    "unitary = execute(qc,backend).result().get_unitary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and view the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "# In Jupyter Notebooks we can display this nicely using Latex.\n",
    "# If not using Jupyter Notebooks you may need to remove the \n",
    "# array_to_latex function and use print(unitary) instead.\n",
    "from qiskit_textbook.tools import array_to_latex\n",
    "array_to_latex(unitary, pretext=\"\\\\text{Circuit = }\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to apply a gate to only one qubit at a time (such as in the circuit below), we do the tensor product with the identity matrix, e.g.:\n",
    "\n",
    "$$ X \\otimes I $$\n",
    "\n",
    "<span style=\"color:green\">Remember when we looked a the Identity gate in the last notebook, and you may have wondered why we need something that just gives you the same thing back? There was a method to our madness...muhahaha...</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "#Let's look but don't touch\n",
    "qc = QuantumCircuit(2)\n",
    "qc.x(1)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "# Simulate the unitary\n",
    "backend = Aer.get_backend('unitary_simulator')\n",
    "unitary = execute(qc,backend).result().get_unitary()\n",
    "# Display the results:\n",
    "array_to_latex(unitary, pretext=\"\\\\text{Circuit = } \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see Qiskit has performed the tensor product:\n",
    "$$\n",
    "X \\otimes I =\n",
    "\\begin{bmatrix} 0 & I \\\\\n",
    "               I & 0\\\\\n",
    "\\end{bmatrix} = \n",
    "\\begin{bmatrix} 0 & 0 & 1 & 0 \\\\\n",
    "                0 & 0 & 0 & 1 \\\\\n",
    "                1 & 0 & 0 & 0 \\\\\n",
    "                0 & 1 & 0 & 0 \\\\\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Now if we apply this to the qubit states, we get\n",
    "$$\n",
    "\\begin{bmatrix} 0 & 0 & 1 & 0 \\\\\n",
    "                0 & 0 & 0 & 1 \\\\\n",
    "                1 & 0 & 0 & 0 \\\\\n",
    "                0 & 1 & 0 & 0 \\\\\n",
    "\\end{bmatrix}\\begin{bmatrix} 00 \\\\ 01 \\\\ 10 \\\\ 11\\end{bmatrix}\n",
    " = \\begin{bmatrix} 10 \\\\ 11 \\\\ 00 \\\\ 01\\end{bmatrix}$$\n",
    " \n",
    " So, for example, if the qubits were in the state |11>, the X-gate acts on the first qubit flipping it to a 0 and leaves the second qubit alone (the Identity operation). Thus, |11> $\\rightarrow$ |01> (the last row).\n",
    "\n",
    "<span style=\"color:red\">**Note:** Different books, softwares and websites order their qubits differently. This means the tensor product of the same circuit can look very different. Try to bear this in mind when consulting other sources.</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:green;font-size:18px\">So we have been pulling a bit of a \"slight of hand\" here. In the presentation we mentioned that once you observe or measure a quantum state, you collapse that state to a given value. For example, if you apply a Hadamard gate, which puts the qubit in a superposition state, and then measure, you will end up in a state of |0> or |1> each with a 50-50 probability. However, once you perform the measurement, measuring again will give you the same value. In other words, the qubit is no longer in a superposition state it is in exactly one of the states |0> or |1>. So far we have been implicitly performing a measurement when we display the state vector on the Bloch sphere.\n",
    "    \n",
    "<p style=\"color:green;font-size:18px\">So here is the kicker! You can't observe, i.e. perform a measurement, the system inbetween gates (for you programmers, you can toss a \"print\" statement between steps) as that will destroy the state. This is the reason you have to run your algorithms hundreds, or thousands, of times and the expectation (average). We will see this in action in just a bit.\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Multi-Qubit Gates <a id=\"multi-qubit-gates\"></a>\n",
    "\n",
    "Now we know how to represent the state of multiple qubits, we are now ready to learn how qubits interact with each other. An important two-qubit gate is the CNOT-gate.\n",
    "\n",
    "### 3.1 The CNOT-Gate <a id=\"cnot\"></a>\n",
    "\n",
    "This gate is a conditional gate that performs an X-gate on the second qubit (target), if the state of the first qubit (control) is $|1\\rangle$. The gate is drawn on a circuit like this, with `q0` as the control and `q1` as the target:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "qc = QuantumCircuit(2)\n",
    "# Apply CNOT\n",
    "qc.cx(0,1)\n",
    "# See the circuit:\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When our qubits are not in superposition of $|0\\rangle$ or $|1\\rangle$ (behaving as classical bits), this gate is very simple and intuitive to understand. We can use the classical truth table:\n",
    "\n",
    "| Input (t,c) | Output (t,c) |\n",
    "|:-----------:|:------------:|\n",
    "| 00          | 00           |\n",
    "| 01          | 11           |\n",
    "| 10          | 10           |\n",
    "| 11          | 01           |\n",
    "\n",
    "And acting on our 4D-statevector, it has one of the two matrices:\n",
    "\n",
    "$$\n",
    "\\text{CNOT} = \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "                              0 & 0 & 0 & 1 \\\\\n",
    "                              0 & 0 & 1 & 0 \\\\\n",
    "                              0 & 1 & 0 & 0 \\\\\n",
    "              \\end{bmatrix}, \\quad\n",
    "\\text{CNOT} = \\begin{bmatrix} 1 & 0 & 0 & 0 \\\\\n",
    "                              0 & 1 & 0 & 0 \\\\\n",
    "                              0 & 0 & 0 & 1 \\\\\n",
    "                              0 & 0 & 1 & 0 \\\\\n",
    "              \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "depending on which qubit is the control and which is the target. Different books, simulators and papers order their qubits differently. In our case, the left matrix corresponds to the CNOT in the circuit above. This matrix swaps the amplitudes of $|01\\rangle$ and $|11\\rangle$ in our statevector:\n",
    "\n",
    "$$ \n",
    "|a\\rangle = \\begin{bmatrix} a_{00} \\\\ a_{01} \\\\ a_{10} \\\\ a_{11} \\end{bmatrix}, \\quad \\text{CNOT}|a\\rangle = \\begin{bmatrix} a_{00} \\\\ a_{11} \\\\ a_{10} \\\\ a_{01} \\end{bmatrix} \\begin{matrix} \\\\ \\leftarrow \\\\ \\\\ \\leftarrow \\end{matrix}\n",
    "$$\n",
    "\n",
    "We have seen how this acts on classical states, but let’s now see how it acts on a qubit in superposition. We will put one qubit in the state $|+\\rangle$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "qc = QuantumCircuit(2)\n",
    "# Apply H-gate to the first:\n",
    "qc.h(0)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "# Let's see the result:\n",
    "backend = Aer.get_backend('statevector_simulator')\n",
    "final_state = execute(qc,backend).result().get_statevector()\n",
    "# Print the statevector neatly:\n",
    "array_to_latex(final_state, pretext=\"\\\\text{Statevector = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, this produces the state $|0\\rangle \\otimes |{+}\\rangle = |0{+}\\rangle$:\n",
    "\n",
    "$$\n",
    "|0{+}\\rangle = \\tfrac{1}{\\sqrt{2}}(|00\\rangle + |01\\rangle)\n",
    "$$\n",
    "\n",
    "And let’s see what happens when we apply the CNOT gate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "qc = QuantumCircuit(2)\n",
    "# Apply H-gate to the first:\n",
    "qc.h(0)\n",
    "# Apply a CNOT:\n",
    "qc.cx(0,1)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "# Let's see the result:\n",
    "backend = Aer.get_backend('statevector_simulator')\n",
    "final_state = execute(qc,backend).result().get_statevector()\n",
    "# Print the statevector neatly:\n",
    "array_to_latex(final_state, pretext=\"\\\\text{Statevector = }\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see we have the state:\n",
    "\n",
    "$$\n",
    "\\text{CNOT}|0{+}\\rangle = \\tfrac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)\n",
    "$$ \n",
    "\n",
    "This state is very interesting to us, because it is <span style=\"color:red;font-weight:bold\"> entangled</span>. This leads us neatly on to the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Entangled States <a id=\"entangled\"></a>\n",
    "\n",
    "We saw in the previous section we could create the state:\n",
    "\n",
    "$$\n",
    "\\tfrac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)\n",
    "$$ \n",
    "\n",
    "This is known as a _Bell_ state. We can see that this state has 50% probability of being measured in the state $|00\\rangle$, and 50% chance of being measured in the state $|11\\rangle$. Most interestingly, it has a **0%** chance of being measured in the states $|01\\rangle$ or $|10\\rangle$. We can see this in Qiskit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do not modify this cell\n",
    "results = execute(qc,backend).result().get_counts()\n",
    "plot_histogram(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This combined state cannot be written as two separate qubit states, which has interesting implications. Although our qubits are in superposition, measuring one will tell us the state of the other and collapse its superposition. For example, if we measured the top qubit and got the state $|1\\rangle$, the collective state of our qubits changes like so:\n",
    "\n",
    "$$\n",
    "\\tfrac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle) \\quad \\xrightarrow[]{\\text{measure}} \\quad |11\\rangle\n",
    "$$\n",
    "\n",
    "Even if we separated these qubits light-years away, measuring one qubit collapses the superposition and appears to have an immediate effect on the other. This is the [‘spooky action at a distance’](https://en.wikipedia.org/wiki/Quantum_nonlocality) that upset so many physicists in the early 20th century.\n",
    "\n",
    "It’s important to note that the measurement result is random, and the measurement statistics of one qubit are **not** affected by any operation on the other qubit. Because of this, there is **no way** to use shared quantum states to communicate. This is known as the no-communication theorem.[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. References\n",
    "\n",
    "[1] Asher Peres, Daniel R. Terno, _Quantum Information and Relativity Theory,_ 2004, https://arxiv.org/abs/quant-ph/0212023"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}