textbook/notebooks/quantum-hardware/measuring-quantum-volume.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "source": [
    "# Measuring Quantum Volume\n",
    "\n",
    "![hero:quantum volume](images/quantum_volume.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "gloss": {
     "quantumadvantage": {
      "text": "Quantum advantage is a term used to refer to the ability for a quantum computer to perform computations beyond that which a classical computer can perform.",
      "title": "quantum advantage"
     },
     "transpiler": {
      "text": "A transpiler converts a quantum circuit to fit the physical layout of a particular quantum device.",
      "title": "transpiler"
     }
    }
   },
   "source": [
    "## Why quantum volume?\n",
    "\n",
    "Comparing different quantum computers is not an easy task. There are many different factors that affect the performance of a quantum computer and it’s not always clear which factors will have the biggest effect when doing useful quantum computations.\n",
    "\n",
    "Say you were designing your quantum computer: Would you trade higher fidelity gates (with less errors) for reduced qubit connectivity (requiring longer circuits)? Maybe you have a great [transpiler](gloss:transpiler) that can organise the swaps so reduced connectivity isn’t as much of an issue, or maybe the readout errors are so high that any improvement in gate fidelity is negligible anyway? We can add each of these statistics to our quantum computer scorecard, but the exact importance of each element is up for debate. Additionally, even if we scored highly at each individual metric, there could still be other unforeseen problems that arise when running quantum circuits.\n",
    "\n",
    "One thing is certain, we need many qubits and the ability to manipulate them precisely in order to achieve a [quantum advantage](gloss:quantumadvantage). If we do not have enough qubits, we cannot do any useful computations, and if these qubits are not precise or reliable enough, then our measurements will be meaningless.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "goals": [
     {
      "click": "true",
      "id": "tabclicked",
      "selector": ".tabset .titles > h3:nth-child(2)"
     }
    ]
   },
   "source": [
    "<div class=\"tabset\">\n",
    "\n",
    "## What affects computing power?\n",
    "\n",
    "\n",
    "<!-- ::: tab -->\n",
    "\n",
    "### Qubit count\n",
    "\n",
    "**Number of qubits (more is better)**\n",
    "\n",
    "The number of qubits in our quantum computer sets an upper limit on the power of the computations it can do. To gain advantage over classical computers, we want to be able to entangle as many qubits as possible.\n",
    "\n",
    "<img src=\"images/qubit_count.png\" width=\"195\"/>\n",
    "\n",
    "<!-- ::: tab -->\n",
    "\n",
    "### Readout errors\n",
    "\n",
    "**Gate and readout errors (less is better)**\n",
    "\n",
    "As mentioned above, the errors in our quantum computer also set an upper limit on the power of our quantum computer. If we can’t reliably manipulate our quantum states, then we’re not going to get meaningful results from our quantum computer.\n",
    "\n",
    "    figure: x-img(src=\"images/readout_errors.png\" width=194 height=197)\n",
    "\n",
    "<!-- ::: tab -->\n",
    "\n",
    "### Connectivity\n",
    "\n",
    "**Qubit-Qubit connectivity (more is better)**\n",
    "\n",
    "If two qubits cannot communicate directly, we need to add extra ‘swap’ gates to move them to the right place, increasing the length of our computation. Quantum volume circuits assume full connectivity, so if you need to insert extra swap gates, that’s on you!\n",
    "\n",
    "    figure: x-img(src=\"images/connectivity.png\" width=199 height=189)\n",
    "\n",
    "<!-- ::: tab -->\n",
    "\n",
    "### Gate set\n",
    "\n",
    "**Gate set (larger / more powerful is better)**\n",
    "\n",
    "Quantum volume asks for random two-qubit gates, but working out how to implement them is also on you. If your hardware supports more gates, you’re more likely to get decent results.\n",
    "\n",
    "    figure: x-img(src=\"images/gate_set.png\" width=302 height=140)\n",
    "\n",
    "<!-- ::: tab -->\n",
    "\n",
    "### Software stack\n",
    "\n",
    "**Compilers and software stack (more intelligent is better)**\n",
    "\n",
    "Some of the other problems (inserting extra swap gates, creating the specified gates from your available gate set, and dealing with noise) can be mitigated using intelligent classical software such as the transpiler.\n",
    "\n",
    "    figure: x-img(src=\"images/software_stack.png\" width=308 height=150)\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is where quantum volume comes in. Quantum volume is a holistic benchmark, instead of looking at the details, we simply measure how good the quantum computer is at doing the thing we want it to do: Executing quantum circuits. The quantum volume test creates randomized circuits to a specification, and the ‘score’ of the quantum computer increases with the size of the circuit it can reliably execute.\n",
    "\n",
    "In this chapter, we will learn:\n",
    "\n",
    "1.\tWhat quantum volume is.\n",
    "2.\tHow to create a random square circuit.\n",
    "3.\tHow to see if a device can achieve a certain quantum volume.\n",
    "4.\tHow to use Qiskit’s tools to make this easier for us.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Quantum Volume?\n",
    "\n",
    "Quantum volume (QV) is a single-number metric used to measure the power of a quantum computer. It’s used for near-term devices with a modest number of qubits, and measures the largest random circuit of equal depth and width that can be reliably executed.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "goals": [
     {
      "id": "quantumvolumescore",
      "selector": ".dot-selector__dot-item__input[value='5']",
      "value": "checked"
     },
     {
      "click": true,
      "id": "quantumvolumescore",
      "selector": ".dot-selector__arrow.dot-selector__arrow--forward"
     }
    ]
   },
   "source": [
    "<!-- ::: .demopanel -->\n",
    "\n",
    "## Visual demo\n",
    "\n",
    "<!-- ::: .demobody -->\n",
    "\n",
    "![vue:what-is-quantum-volume](images/quantum_volume_2.png)\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "<!-- ::: -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Quantum Volume Protocol\n",
    "\n",
    "### Overview\n",
    "\n",
    "To perform the quantum volume benchmark, we first create a bunch of circuits of size d. We then simulate the circuits and record the most likely outputs for each. We run these same circuits on the device we’re testing and see how regularly the outputs match those we simulated. If the device produces good enough results, we increase d and start over. The quantum volume of the device is 2 to the power of the largest circuit size our device can produce acceptable results for.\n",
    "\n",
    "\n",
    "<div class=\"qv-overview\">\n",
    "\n",
    "<!-- ::: column(width=25) -->\n",
    "\n",
    "## 1.\n",
    "\n",
    "<!-- ::: column(width=100) -->\n",
    "\n",
    "![test](images/overview-1.png)\n",
    "\n",
    "<!-- ::: column.grow -->\n",
    "\n",
    "Create a set of random circuits of width and depth d.\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "\n",
    "<!-- ::: column(width=25) -->\n",
    "\n",
    "## 2.\n",
    "\n",
    "<!-- ::: column(width=100) -->\n",
    "\n",
    "![test](images/overview-2.png)\n",
    "\n",
    "<!-- ::: column.grow -->\n",
    "\n",
    "Simulate the circuits and record which outputs are most likely.\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "\n",
    "<!-- ::: column(width=25) -->\n",
    "\n",
    "## 3.\n",
    "\n",
    "<!-- ::: column(width=100) -->\n",
    "\n",
    "![test](images/overview-3.png)\n",
    "\n",
    "<!-- ::: column.grow -->\n",
    "\n",
    "Execute the circuits on the device we’re testing and record the results.\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "\n",
    "<!-- ::: column(width=25) -->\n",
    "\n",
    "## 4.\n",
    "\n",
    "<!-- ::: column(width=100) -->\n",
    "\n",
    "![test](images/overview-4.png)\n",
    "\n",
    "<!-- ::: column.grow -->\n",
    "\n",
    "If the device results are statically close enough to the simulation results, increase d and go to step one. Repeat until failure.\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "\n",
    "<!-- ::: column(width=25) -->\n",
    "\n",
    "## 5.\n",
    "\n",
    "<!-- ::: column(width=100) -->\n",
    "\n",
    "![test](images/overview-5.png)\n",
    "\n",
    "<!-- ::: column.grow -->\n",
    "\n",
    "The quantum volume is 2**dmax, where dmax is the width and depth of the largest circuit our device can successfully execute.\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "gloss": {
     "unitarygates": {
      "text": "A unitary gate is a reversible, quantum operation.",
      "title": "unitary gates"
     }
    }
   },
   "source": [
    "## Square circuits\n",
    "\n",
    "A square circuit is a circuit of equal width and depth. This roughly approximates the kind of circuits we will want to run on a general-purpose quantum computer, and since the depth and width are equal, they can be defined by a single number.\n",
    "\n",
    "We know we can build our quantum algorithms with quantum circuits using a polynomial number of two-qubit [unitary gates](gloss:unitarygates). The model we choose has layers of random permutations of the qubit labels, followed by randomly specified two-qubits gates. When we have an odd number of qubits, one of the qubits is idle in each layer.\n",
    "\n",
    "These random circuits more closely approximate the circuits found in near term quantum algorithms than the circuits found in some of the more traditional algorithms.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- ::: .demopanel -->\n",
    "\n",
    "## Square circuit demo\n",
    "\n",
    "<!-- ::: .demobody -->\n",
    "\n",
    "### Layers and Unitaries\n",
    "\n",
    "Click on any of the layers to see examples of gates inside of each layer. Each layer affects each qubit exactly once, and all the unitary gates in a layer can be executed in parallel (assuming the device has full qubit connectivity).\n",
    "\n",
    "    div(data-vue-mount)\n",
    "        layers-circuit\n",
    "    \n",
    "<!--\n",
    "    div(data-vue-mount)\n",
    "        layers-circuit(layers=3 lines=3 :gates-inspection=\"[[{ q1: 0, q2: 1 }, { q1: 1, q2: 2 }],[{ q1: 0, q2: 1 }, { q1: 0, q2: 1 }],[{ q1: 1, q2: 2 }, { q1: 0, q2: 1 }]]\")\n",
    "-->\n",
    "\n",
    "<!-- ![vue:layers-circuit](images/layers_unitary.png) -->\n",
    "\n",
    "<!-- ::: -->\n",
    "\n",
    "<!-- ::: -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a square circuit\n",
    "\n",
    "To start, let’s have a go at creating our own random, square circuit. The first thing we need to do is decide which qubits our circuit is going to act on. When measuring quantum volume, we can choose whichever qubits on our device we think will give us the best results. Here I’m choosing the first five qubits of an imaginary device. This means our circuit’s depth and width will both be five.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "qubit_list = [0,1,2,3,4]\n",
    "size = len(qubit_list)  # size == width == depth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need a way to create our random 2-qubit gates. Qiskit provides a tool, <code>random_unitary</code> that creates a random nxn unitary operator for us. This function could generate any unitary, two-qubit operation possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Operator([[-0.36858382-0.65597438j, -0.04131923+0.43570119j,\n",
       "           -0.45819161-0.04420006j,  0.17435486+0.00281941j],\n",
       "          [-0.3338904 +0.13342044j, -0.22408296-0.43645123j,\n",
       "           -0.13446159-0.10664243j,  0.44301429+0.63584523j],\n",
       "          [ 0.44709934+0.23712703j,  0.22318688+0.40743813j,\n",
       "           -0.35780924+0.36281023j,  0.01533944+0.51784238j],\n",
       "          [-0.21910977+0.02058212j, -0.21074615+0.55454684j,\n",
       "            0.70634859+0.00819945j,  0.03172802+0.3156405j ]],\n",
       "         input_dims=(2, 2), output_dims=(2, 2))"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.quantum_info import random_unitary\n",
    "random_unitary(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this to create a single layer of our random, square circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "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",
       "q_0: ────────────┤0         ├\n",
       "     ┌──────────┐│          │\n",
       "q_1: ┤0         ├┤          ├\n",
       "     │  unitary ││          │\n",
       "q_2: ┤1         ├┤  unitary ├\n",
       "     └──────────┘│          │\n",
       "q_3: ────────────┤          ├\n",
       "                 │          │\n",
       "q_4: ────────────┤1         ├\n",
       "                 └──────────┘</pre>"
      ],
      "text/plain": [
       "                 ┌──────────┐\n",
       "q_0: ────────────┤0         ├\n",
       "     ┌──────────┐│          │\n",
       "q_1: ┤0         ├┤          ├\n",
       "     │  unitary ││          │\n",
       "q_2: ┤1         ├┤  unitary ├\n",
       "     └──────────┘│          │\n",
       "q_3: ────────────┤          ├\n",
       "                 │          │\n",
       "q_4: ────────────┤1         ├\n",
       "                 └──────────┘"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "qv_layer = QuantumCircuit(size)\n",
    "for pair in range(size//2):  # number of pairs is size/2\n",
    "    qubit_indices = qubit_list[pair*2:pair*2+2]\n",
    "    gate = random_unitary(4)\n",
    "    qv_layer.append(gate, qubit_indices)\n",
    "\n",
    "qv_layer.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create a layer from a list of qubits, all we need to do is randomly change the order of the qubits and repeat. Python has a built-in function to shuffle lists (note that this works ‘in place’, so the data qubit_lists refers to will change)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 3, 0, 2]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import shuffle\n",
    "shuffle(qubit_list)\n",
    "qubit_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"demopanel exercise\">\n",
    "\n",
    "## Exercise\n",
    "\n",
    "<div class=\"demobody\">\n",
    "    \n",
    "Create a function, <code>random_square_circuit(n)</code> that takes an integer <code>n</code>, and returns a random <code>QuantumCircuit</code> with width and depth <code>n</code>, that could be used in a quantum volume experiment. You may use the code shown above in your solution.\n",
    "\n",
    "[Try in IBM Quantum Lab](https://quantum-computing.ibm.com/jupyter)\n",
    "\n",
    "</div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qiskit also provides a function, <code>qv_circuits</code>, to create these circuits for us. We pass some lists of qubit indices, and an integer which tells qv_circuits how many random, square circuits we’d like to generate for each list of qubits. Here we’re going to give five different combinations of qubits, which will allow us to test up to a quantum volume of 64.\n",
    "\n",
    "The function qv_circuits returns two lists of quantum circuits, both identical except the first set of circuits all have measurements at the end, whereas the second set do not. The set including measurements is to be executed on hardware, while the other is for use with simulators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.ignis.verification.quantum_volume import qv_circuits\n",
    "qubit_lists = [[0,1],          # Qubits used to test QV 4\n",
    "               [0,1,2],        # QV 8\n",
    "               [0,1,2,3],      # QV 16\n",
    "               [0,1,2,3,4],    # QV 32\n",
    "               [0,1,2,3,4,5]]  # QV 64\n",
    "ntrials = 100  # number of circuits to generate for each qubit list\n",
    "qv_qc_list, qv_qc_list_nomeas = qv_circuits(qubit_lists, ntrials)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a circuit created by <code>qv_circuits</code>. Note the circuits are organised by trial, then by qubit lists, so here we are seeing the 0th circuit generated for the 2nd entry in <code>qubit_lists</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "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",
       "q_0: ┤1         ├────────────┤1        ├┤0         ├────────────┤0         ├\n",
       "     │  su4_753 │┌──────────┐│         ││          │┌──────────┐│  su4_421 │\n",
       "q_1: ┤0         ├┤0         ├┤  su4_45 ├┤  su4_739 ├┤1         ├┤1         ├\n",
       "     ├─────────┬┘│          ││         ││          ││          │├──────────┤\n",
       "q_2: ┤0        ├─┤  su4_111 ├┤0        ├┤1         ├┤  su4_436 ├┤1         ├\n",
       "     │  su4_33 │ │          │└─────────┘└──────────┘│          ││  su4_466 │\n",
       "q_3: ┤1        ├─┤1         ├───────────────────────┤0         ├┤0         ├\n",
       "     └─────────┘ └──────────┘                       └──────────┘└──────────┘</pre>"
      ],
      "text/plain": [
       "     ┌──────────┐            ┌─────────┐┌──────────┐            ┌──────────┐\n",
       "q_0: ┤1         ├────────────┤1        ├┤0         ├────────────┤0         ├\n",
       "     │  su4_753 │┌──────────┐│         ││          │┌──────────┐│  su4_421 │\n",
       "q_1: ┤0         ├┤0         ├┤  su4_45 ├┤  su4_739 ├┤1         ├┤1         ├\n",
       "     ├─────────┬┘│          ││         ││          ││          │├──────────┤\n",
       "q_2: ┤0        ├─┤  su4_111 ├┤0        ├┤1         ├┤  su4_436 ├┤1         ├\n",
       "     │  su4_33 │ │          │└─────────┘└──────────┘│          ││  su4_466 │\n",
       "q_3: ┤1        ├─┤1         ├───────────────────────┤0         ├┤0         ├\n",
       "     └─────────┘ └──────────┘                       └──────────┘└──────────┘"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qv_qc_list_nomeas[0][2].decompose().draw()  # .decompose() unrolls the circuit one level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the circuit\n",
    "\n",
    "So how do we know if the quantum circuit is being executed correctly? The quantum volume protocol is run on a perfect simulator as well as the quantum device we’re testing. We can then compare the simulated results (what the quantum computer _should_ do) to the experimental results (what the quantum computer _actually does_).\n",
    "\n",
    "![qv circuit](images/Qv2-just-circuit-1.png)\n",
    "\n",
    "<div>\n",
    "    <img src=\"images/med_06-1.png\" />\n",
    "    <img src=\"images/med_05_2-1.png\" />\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What would an ideal quantum computer do?\n",
    "\n",
    "Each circuit has an ideal output distribution. The ideal output distribution is the results we’d see if we ran the circuit on a perfect quantum computer as the number of shots approaches infinity. We calculated this for each circuit using the statevector simulator above. Let’s look at the ideal output distribution for the first five-qubit circuit:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import Aer, execute\n",
    "from qiskit.visualization import plot_histogram\n",
    "sv_simulator = Aer.get_backend('statevector_simulator')\n",
    "\n",
    "trial = 0\n",
    "qubit_list_idx = 3\n",
    "qc = qv_qc_list_nomeas[trial][qubit_list_idx]\n",
    "counts = execute(qc, sv_simulator).result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The _heavy outputs_ of a circuit are defined as outputs with probability of occurring greater than the median probability. For any circuit, half the possible outputs are heavy outputs.\n",
    "\n",
    "![computational basis state](images/HOP-copy-1.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a function, <code>get_heavy_outputs</code>, that extracts the heavy outputs from an experiment’s counts:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_heavy_outputs(counts):\n",
    "    \"\"\"Extract heavy outputs from counts dict.\n",
    "    Args:\n",
    "        counts (dict): Output of `.get_counts()`\n",
    "    Returns:\n",
    "        list:\n",
    "            All states with measurement probability greater than the mean.\n",
    "    \"\"\"\n",
    "    # sort the keys of `counts` by value of counts.get(key)\n",
    "    sorted_counts = sorted(counts.keys(), key=counts.get)\n",
    "    # discard results with probability < median\n",
    "    heavy_outputs = sorted_counts[len(sorted_counts)//2:]\n",
    "    return heavy_outputs\n",
    "\n",
    "print(get_heavy_outputs(counts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "formulas": {
     "qv_ncns": {
      "meaning": "Number of unique circuits multiplied by the number of shots for each circuit.",
      "say": "N C N S",
      "type": "Locally defined variable"
     },
     "qv_nh": {
      "meaning": "The total number of heavy output measured.",
      "say": "N H",
      "type": "Locally defined variable"
     },
     "qv_nhnc": {
      "meaning": "The number of heavy outputs measured divided by the number of unique circuits.",
      "say": "NH over NC",
      "type": "Locally defined variable"
     },
     "qv_ns": {
      "meaning": "The number of times we run each circuit.",
      "say": "N S",
      "type": "Locally defined variable"
     },
     "qv_z": {
      "meaning": "Sets the threshold",
      "say": "Z test",
      "type": "Universally used notation"
     }
    }
   },
   "source": [
    "We run each circuit on our device and record the number of outputs that are heavy outputs. \n",
    "To pass the heavy output test, we want the probability of measuring a heavy output to be greater than two-thirds. I.e. over a large enough number of circuits we have:\n",
    "\n",
    "$$\\frac{\\cssId{qv_nh}{n_h}}{\\cssId{qv_ncns}{n_cn_s}}\\gt{\\frac{2}{3}}$$\n",
    "<!-- $$\\left|+\\right\\rangle=\\frac{1}{\\sqrt{2}}\\left(\\left|0\\right\\rangle+\\left|1\\right\\rangle\\right)\\rightarrow \\frac{1}{\\sqrt{2}}\\left(\\left|000\\right\\rangle+\\left|111\\right\\rangle\\right)$$ -->\n",
    "\n",
    "Where nh is the number of heavy outputs measured, nc is the number of circuits we created, and ns is the number of times we run each circuit. But how do we decide what a “large enough” number of experiments is? Firstly, quantum volume requires at least 100 circuits are run, otherwise the test is invalid. Secondly, an adjusted threshold is used to ensure approximately 97% confidence:\n",
    "\n",
    "$$\\frac{n_h -\\cssId{qv_z}{z}\\sqrt{n_h(\\cssId{qv_ns}{n_s}-\\cssId{qv_nhnc}{\\frac{n_h}{n_c}})}}{n_cn_s}\\gt\\frac{2}{3}$$\n",
    "\n",
    "Adding the new term (enclosed in the square root) requires a greater heavy output probability to satisfy the inequality, or a greater number of runs. Since the new term grows more slowly than the other terms, for a large number of runs this inequality resembles the simpler one shown above. If a quantum volume test satisfies the above inequality, there is at least a 97% chance the heavy output probability is greater than 2/3.\n",
    "\n",
    "Below is a function (<code>check_threshold</code>) that evaluates this inequality:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_threshold(nheavies, ncircuits, nshots):\n",
    "    \"\"\"Evaluate adjusted threshold inequality for quantum volume.\n",
    "    Args:\n",
    "        nheavies (int): Total number of heavy outputs measured from device\n",
    "        ncircuits (int): Number of different square circuits run on device\n",
    "        nshots (int): Number of shots per circuit\n",
    "    Returns:\n",
    "        Bool:\n",
    "            True if heavy output probability is > 2/3 with 97% certainty, otherwise False\n",
    "    \"\"\"\n",
    "    from numpy import sqrt\n",
    "    numerator = nheavies - 2*sqrt(nheavies*(nshots-(nheavies/ncircuits)))\n",
    "    if numerator/(ncircuits*nshots) > 2/3:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"demopanel exercise\">\n",
    "\n",
    "## Exercise\n",
    "\n",
    "<div class=\"demobody\">\n",
    "    \n",
    "We now have everything we need to check if a quantum device can achieve a specific quantum volume. Below are the steps of an algorithm that checks if a device can achieve a specific quantum volume, try to order them correctly.\n",
    "\n",
    "Algorithm to test if algorithm passes a quantum volume test.\n",
    "Inputs: d, nc > 100, ns\n",
    "\n",
    "\n",
    "    div(data-vue-mount)\n",
    "        drag-and-drop-code\n",
    "            .line fibonacci (n)\n",
    "                .line(group=1) let a = 0\n",
    "                .line(group=1) let b = 1\n",
    "                .line(group=1) let c = 1\n",
    "                .line for each i from 0 to n\n",
    "                    .line a = b + c\n",
    "                    .line c = b\n",
    "                    .line b = a\n",
    "                    .line.md $(\\left|00\\right\\rangle+\\left|11\\right\\rangle)/\\sqrt{2}$\n",
    "                .line return a\n",
    "            .line end\n",
    "            .result-info.md Return evaluation of $(\\left|00\\right\\rangle+\\left|11\\right\\rangle)/\\sqrt{2}$\n",
    "\n",
    "</div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}