ex2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "06c84e36",
   "metadata": {},
   "source": [
    "# Exercise 2 - Shor's algorithm\n",
    "## Historical background\n",
    "\n",
    "In computing, we often measure the performance of an algorithm by how it grows with the size of the input problem. For example, addition has an algorithm that grows linearly with the size of the numbers we're adding. There are some computing problems for which the best algorithms we have grow _exponentially_ with the size of the input, and this means inputs with a relatively modest size are too big to solve using any computer on earth. We're so sure of this, much of the internet's security depends on certain problems being unsolvable.\n",
    "\n",
    "In 1994, Peter Shor showed that it’s possible to factor a number into its primes efficiently on a quantum computer.[1] This is big news, as the best classical algorithm we know of is one of these algorithms that grows exponentially. And in fact, [RSA encryption](https://en.wikipedia.org/wiki/RSA_(cryptosystem)) relies on factoring large enough numbers being infeasible. To factor integers that are too big for our current classical computers will require millions of qubits and gates, and these circuits are far too big to run on today’s quantum computers successfully.\n",
    "\n",
    "So how did Lieven M.K. Vandersypen, Matthias Steffen, Gregory Breyta, Costantino S. Yannoni, Mark H. Sherwood and Isaac L. Chuang manage to factor 15 on a quantum computer, all the way back in 2001?![2]\n",
    "\n",
    "The difficulty in creating circuits for Shor’s algorithm is creating the circuit that computes a controlled $ay \\bmod N$. While we know how to create these circuits using a polynomial number of gates, these are still too large for today’s computers. Fortunately, if we know some information about the problem a priori, then we can sometimes ‘cheat’ and create more efficient circuits.\n",
    "\n",
    "To run this circuit on the hardware available to them, the authors of the above paper found a very simple circuit that performed $7y \\bmod 15$. This made the circuit small enough to run on their hardware. By the end of this exercise, you will have created a circuit for $35y \\bmod N$ that can be used in Shor’s algorithm and can run on `ibmq_santiago`.\n",
    "\n",
    "If you want to understand what's going on in this exercise, you should check out the [Qiskit Textbook page on Shor's algorithm](https://qiskit.org/textbook/ch-algorithms/shor.html), but if this is too involved for you, you can complete the exercise without this.\n",
    "\n",
    "### References\n",
    "1. Shor, Peter W. \"Algorithms for quantum computation: discrete logarithms and factoring.\" Proceedings 35th annual symposium on foundations of computer science. Ieee, 1994.\n",
    "1. Vandersypen, Lieven MK, et al. \"Experimental realization of Shor's quantum factoring algorithm using nuclear magnetic resonance.\" Nature 414.6866 (2001): 883-887."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6421ee81",
   "metadata": {},
   "source": [
    "## tl;dr: Shor’s algorithm\n",
    "\n",
    "There is an algorithm called [_quantum phase estimation_](https://qiskit.org/textbook/ch-algorithms/quantum-phase-estimation.html) that tells us the phase a gate introduces to a certain type of state. For example, inputs to phase estimation algorithm could be the state $|1\\rangle$ and the gate $Z$. If the $Z$-gate acts on the state $|1\\rangle$, we get back the same state with an added global phase of $\\pi$:\n",
    "\n",
    "$$\n",
    "Z|1\\rangle = -|1\\rangle = e^{i\\pi} |1\\rangle\n",
    "$$\n",
    "\n",
    "And the quantum phase estimation algorithm could work this out for us. You can see another example [here](https://qiskit.org/textbook/ch-algorithms/quantum-phase-estimation.html#2.-Example:-T-gate-).\n",
    "\n",
    "Shor showed that if we do phase estimation on a gate, $U$, that has the behavior $U|y\\rangle = |a y\\bmod N\\rangle$, we can quickly get some information about $N$’s factors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d7e556b",
   "metadata": {},
   "source": [
    "## The problem\n",
    "\n",
    "In this exercise, we will factor 35 by doing phase estimation on a circuit that implements $13y \\bmod 35$. The exercise is to create a circuit that does this, and is also small enough to run on `ibmq_santiago`! This is not an easy task, so the first thing we’re going to do is cheat.\n",
    "\n",
    "A detail of Shor’s algorithm is that our circuit only needs to work on states we can reach through applying $U$ to the starting state $|1\\rangle$. I.e. we can use _any_ circuit that has the behavior: \n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|1\\rangle &= |13\\rangle \\\\\n",
    "UU|1\\rangle &= |29\\rangle \\\\\n",
    "UUU|1\\rangle &= |27\\rangle \\\\\n",
    "UUUU|1\\rangle &= |1\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "So how can we make this easier for us? Since we only need to correctly transform 4 different states, we can encode these onto two qubits. For this exercise, we will choose to map the 2-qubit computational basis states to the numbers like so:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "|1\\rangle &\\rightarrow |00\\rangle \\\\\n",
    "|13\\rangle &\\rightarrow |01\\rangle \\\\\n",
    "|29\\rangle &\\rightarrow |10\\rangle \\\\\n",
    "|27\\rangle &\\rightarrow |11\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Why is this “cheating”? Well, to take advantage of this optimization, we need to know all the states $U$ is going to affect, which means we have to compute $ay \\bmod N$ until we get back to 1 again, and that means we know the period of $a^x \\bmod N$ and can therefore get the factors of $N$. Any optimization like this, in which we use information that would tell us the value $r$, is obviously not going to scale to problems that classical computers can’t solve. \n",
    "\n",
    "But the purpose of this exercise is just to verify that Shor’s algorithm does in fact work as intended, and we’re not going to worry about the fact that we cheated to get a circuit for $U$.\n",
    "\n",
    "<div id='u-definition'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Exercise 2a:** Create a circuit ($U$) that performs the transformation:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|00\\rangle &= |01\\rangle \\\\\n",
    "U|01\\rangle &= |10\\rangle \\\\\n",
    "U|10\\rangle &= |11\\rangle \\\\\n",
    "U|11\\rangle &= |00\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "and is controlled by another qubit. The circuit will act on a 2-qubit target register named 'target', and be controlled by another single-qubit register named 'control'. You should assign your finished circuit to the variable '`cu`'.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "6f005257",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 807.927x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from qiskit import QuantumRegister, QuantumCircuit\n",
    "import numpy as np\n",
    "c = QuantumRegister(1, 'control')\n",
    "t = QuantumRegister(2, 'target')\n",
    "cu = QuantumCircuit(c, t, name=\"Controlled 13^x mod 35\")\n",
    "\n",
    "# WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "qc1 = QuantumCircuit(2)\n",
    "qc1.cx(0,1)\n",
    "qc1.x(0)\n",
    "circ = qc1.to_gate().control(1)\n",
    "cu.append(circ, [0,1,2])\n",
    "cu = cu.decompose()\n",
    "cu = transpile(cu, basis_gates = ['cx', 'u3'])\n",
    "# a = np.array([[0,0,0,1],[1,0,0,0],[0,1,0,0],[0,0,1,0]])\n",
    "# qc1.unitary(a,[0,1])\n",
    "# tm = qc1.to_gate().control(1)\n",
    "# cu.append(tm, [0,1,2])\n",
    "# WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "\n",
    "cu.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c70e696",
   "metadata": {},
   "source": [
    "And run the cell below to check your answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "a398b6fe",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading your answer for ex2/part1. Please wait...\n",
      "\n",
      "Congratulations 🎉! Your answer is correct.\n"
     ]
    }
   ],
   "source": [
    "# Check your answer using following code\n",
    "from qc_grader import grade_ex2a\n",
    "grade_ex2a(cu)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db5f68e3",
   "metadata": {},
   "source": [
    "Congratulations! You’ve completed the hard part. \n",
    "\n",
    "We read the output of the phase estimation algorithm by measuring qubits, so we will need to make sure our 'counting' register contains enough qubits to read off $r$. In our case, $r = 4$, which means we only need $\\log_2(4) = 2$ qubits (cheating again because we know $r$ beforehand), but since Santiago has 5 qubits, and we've only used 2 for the 'target' register, we'll use all remaining 3 qubits as our counting register.\n",
    "\n",
    "To do phase estimation on $U$, we need to create circuits that perform $U^{2^x}$ ($U$ repeated $2^x$ times) for each qubit (with index $x$) in our register of $n$ counting qubits. In our case this means we need three circuits that implement:\n",
    "\n",
    "$$ U, \\; U^2, \\; \\text{and} \\; U^4 $$\n",
    "\n",
    "So the next step is to create a circuit that performs $U^2$ (i.e. a circuit equivalent to applying $U$ twice).\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Exercise 2b:** Create a circuit ($U^2$) that performs the transformation:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|00\\rangle &= |10\\rangle \\\\\n",
    "U|01\\rangle &= |11\\rangle \\\\\n",
    "U|10\\rangle &= |00\\rangle \\\\\n",
    "U|11\\rangle &= |01\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "and is controlled by another qubit. The circuit will act on a 2-qubit target register named 'target', and be controlled by another single-qubit register named 'control'. You should assign your finished circuit to the variable '`cu2`'.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "7bd0dc3a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 205.927x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import *\n",
    "from qiskit import Aer\n",
    "backend = Aer.get_backend('unitary_simulator')\n",
    "c = QuantumRegister(1, 'control')\n",
    "t = QuantumRegister(2, 'target')\n",
    "cu2 = QuantumCircuit(c, t)\n",
    "\n",
    "# WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "# qc1 = QuantumCircuit(2)\n",
    "# # a = np.array([[0,0,1,0],[0,0,0,1],[1,0,0,0],[0,1,0,0]])\n",
    "# # qc1.unitary(a,[0,1])\n",
    "# qc1.cx(0,1)\n",
    "\n",
    "# circ = qc1.to_gate().control(1)\n",
    "# cu2.append(circ, [0,1,2])\n",
    "cu2.cx(0,2)\n",
    "cu2 = transpile(cu2, basis_gates = ['cx', 'u3'])\n",
    "# # WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "cu2.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2802237f",
   "metadata": {},
   "source": [
    "And you can check your answer below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "5a17bea6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading your answer for ex2/part2. Please wait...\n",
      "\n",
      "Congratulations 🎉! Your answer is correct.\n"
     ]
    }
   ],
   "source": [
    "# Check your answer using following code\n",
    "from qc_grader import grade_ex2b\n",
    "grade_ex2b(cu2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "293c5b88",
   "metadata": {},
   "source": [
    "Finally, we also need a circuit that is equivalent to applying $U$ four times (i.e. we need the circuit $U^4$).  \n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    \n",
    "**Exercise 2c:** Create a circuit ($U^4$) that performs the transformation:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "U|00\\rangle &= |00\\rangle \\\\\n",
    "U|01\\rangle &= |01\\rangle \\\\\n",
    "U|10\\rangle &= |10\\rangle \\\\\n",
    "U|11\\rangle &= |11\\rangle \\\\\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "and is controlled by another qubit. The circuit will act on a 2-qubit target register named 'target', and be controlled by another single-qubit register named 'control'. You should assign your finished circuit to the variable '`cu4`'. _Hint: The best solution is very simple._\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "4e499136",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 175.827x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = QuantumRegister(1, 'control')\n",
    "t = QuantumRegister(2, 'target')\n",
    "cu4 = QuantumCircuit(c, t)\n",
    "\n",
    "# WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "qc1 = QuantumCircuit(2)\n",
    "# a = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]])\n",
    "# qc1.i([0,1])\n",
    "# # circ = qc1.to_gate().control(1)\n",
    "# cu4.append(circ, [0,1,2])\n",
    "cu4 = transpile(cu4, basis_gates = ['cx', 'u3'])\n",
    "# # WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "cu4.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e542f116",
   "metadata": {},
   "source": [
    "You can check your answer using the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "c84033b2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading your answer for ex2/part3. Please wait...\n",
      "\n",
      "Congratulations 🎉! Your answer is correct.\n"
     ]
    }
   ],
   "source": [
    "# Check your answer using following code\n",
    "from qc_grader import grade_ex2c\n",
    "grade_ex2c(cu4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac70d8cf",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**Exercise 2 final:** Now we have controlled $U$, $U^2$ and $U^4$, we can combine this into a circuit that carries out the quantum part of Shor’s algorithm.\n",
    "\n",
    "The initialization part is easy: we need to put the counting register into the state $|{+}{+}{+}\\rangle$ (which we can do with three H-gates) and we need the target register to be in the state $|1\\rangle$ (which we mapped to the computational basis state $|00\\rangle$, so we don’t need to do anything here). We'll do all this for you.\n",
    "\n",
    "_Your_ task is to create a circuit that carries out the controlled-$U$s, that will be used in-between the initialization and the inverse quantum Fourier transform. More formally, we want a circuit:\n",
    "\n",
    "\n",
    "$$\n",
    "CU_{c_0 t}CU^2_{c_1 t}CU^4_{c_2 t}\n",
    "$$\n",
    "\n",
    "Where $c_0$, $c_1$ and $c_2$ are the three qubits in the ‘counting’ register, $t$ is the ‘target’ register, and $U$ is as <a href=\"#u-definition\">defined in the first part of this exercise</a>. In this notation, $CU_{a b}$ means $CU$ is controlled by $a$ and acts on $b$. An easy solution to this is to simply combine the circuits `cu`, `cu2` and `cu4` that you created above, but you will most likely find a more efficient circuit that has the same behavior!\n",
    "    \n",
    "</div>\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    \n",
    "Your circuit can only contain [CNOTs](https://qiskit.org/documentation/stubs/qiskit.circuit.library.CXGate.html) and single qubit [U-gates](https://qiskit.org/documentation/stubs/qiskit.circuit.library.UGate.html). Your score will be the number of CNOTs you use (less is better), as multi-qubit gates are usually much more difficult to carry out on hardware than single-qubit gates. If you're struggling with this requirement, we've included a line of code next to the submission that will convert your circuit to this form, although you're likely to do better by hand.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "729b83dc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 868.418x325.08 with 1 Axes>"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Code to combine your previous solutions into your final submission\n",
    "cqr = QuantumRegister(3, 'control')\n",
    "tqr = QuantumRegister(2, 'target')\n",
    "cux = QuantumCircuit(cqr, tqr)\n",
    "solutions = [cu, cu2, cu4]\n",
    "for i in range(3):\n",
    "    cux = cux.compose(solutions[i], [cqr[i], tqr[0], tqr[1]])\n",
    "cux.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "b9bd5ab2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading your answer for ex2/part4. Please wait...\n",
      "\n",
      "Congratulations 🎉! Your answer is correct.\n",
      "Your cost is 6.\n",
      "Feel free to submit your answer.\r\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check your answer using following code\n",
    "from qc_grader import grade_ex2_final\n",
    "# Uncomment the two lines below if you need to convert your circuit to CNOTs and single-qubit gates\n",
    "from qiskit import transpile\n",
    "cux = transpile(cux, basis_gates=['cx','u'])\n",
    "grade_ex2_final(cux)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee5916ff",
   "metadata": {},
   "source": [
    "Once you're happy with the circuit, you can submit it below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "682e6bcd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer for ex2/part4. Please wait...\n",
      "Success 🎉! Your answer has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# Submit your answer. You can re-submit at any time.\n",
    "from qc_grader import submit_ex2_final\n",
    "submit_ex2_final(cux)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37eaf13d",
   "metadata": {},
   "source": [
    "Congratulations! You've finished the exercise. Read on to see your circuit used to factor 35, and see how it performs .\n",
    "\n",
    "## Using your circuit to factorize 35\n",
    "\n",
    "The code cell below takes your submission for the exercise and uses it to create a circuit that will give us $\\tfrac{s}{r}$, where $s$ is a random integer between $0$ and $r-1$, and $r$ is the period of the function $f(x) = 13^x \\bmod 35$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "a35f3bc4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1109.22x385.28 with 1 Axes>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit.library import QFT\n",
    "from qiskit import ClassicalRegister\n",
    "# Create the circuit object\n",
    "cr = ClassicalRegister(3)\n",
    "shor_circuit = QuantumCircuit(cqr, tqr, cr)\n",
    "\n",
    "# Initialise the qubits\n",
    "shor_circuit.h(cqr)\n",
    "\n",
    "# Add your circuit\n",
    "shor_circuit = shor_circuit.compose(cux)\n",
    "\n",
    "# Perform the inverse QFT and extract the output\n",
    "shor_circuit.append(QFT(3, inverse=True), cqr)\n",
    "shor_circuit.measure(cqr, cr)\n",
    "shor_circuit.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41164358",
   "metadata": {},
   "source": [
    "Let's transpile this circuit and see how large it is, and how many CNOTs it uses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "2035ee4b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "circuit depth: 27\n",
      "circuit contains 15 CNOTs\n"
     ]
    }
   ],
   "source": [
    "from qiskit import Aer, transpile\n",
    "from qiskit.visualization import plot_histogram\n",
    "qasm_sim = Aer.get_backend('aer_simulator')\n",
    "tqc = transpile(shor_circuit, basis_gates=['u', 'cx'], optimization_level=3)\n",
    "print(f\"circuit depth: {tqc.depth()}\")\n",
    "print(f\"circuit contains {tqc.count_ops()['cx']} CNOTs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b6c5c6",
   "metadata": {},
   "source": [
    "And let's see what we get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "2dd3190a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts = qasm_sim.run(tqc).result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bbec212",
   "metadata": {},
   "source": [
    "Assuming everything has worked correctly, we should see equal probability of measuring the numbers $0$, $2$, $4$ and $8$. This is because phase estimation gives us $2^n \\cdot \\tfrac{s}{r}$, where $n$ is the number of qubits in our counting register (here $n = 3$, $s$ is a random integer between $0$ and $r-1$, and $r$ is the number we're trying to calculate). Let's convert these to fractions that tell us $s/r$ (this is something we can easily calculate classically):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "1236a1ce",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/4\n",
      "3/4\n",
      "0\n",
      "1/2\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "n = 3  # n is number of qubits in our 'counting' register\n",
    "# Cycle through each measurement string\n",
    "for measurement in counts.keys():\n",
    "    # Convert the binary string to an 'int', and divide by 2^n\n",
    "    decimal = int(measurement, 2)/2**n\n",
    "    # Use the continued fractions algorithm to convert to form a/b\n",
    "    print(Fraction(decimal).limit_denominator())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "542aa75d",
   "metadata": {},
   "source": [
    "We can see the denominator of some of the results will tell us the correct answer $r = 4$. We can verify $r=4$ quickly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "b8d257e1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13**4 % 35"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17566649",
   "metadata": {},
   "source": [
    "So how do we get the factors from this? There is then a high probability that the greatest common divisor of $N$ and either $a^{r/2}-1$ or $a^{r/2}+1$ is a factor of $N$, and the greatest common divisor is also something we can easily calculate classically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "6f6dd439",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guessed factor: 7\n",
      "Guessed factor: 5\n"
     ]
    }
   ],
   "source": [
    "from math import gcd # Greatest common divisor\n",
    "for x in [-1, 1]:\n",
    "    print(f\"Guessed factor: {gcd(13**(4//2)+x, 35)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "549c0951",
   "metadata": {},
   "source": [
    "We only need to find one factor, and can use it to divide $N$ to find the other factor. But in this case, _both_ $a^{r/2}-1$ or $a^{r/2}+1$ give us $35$'s factors. We can again verify this is correct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "aabb760e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7*5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d00b08ca",
   "metadata": {},
   "source": [
    "## Running on `ibmq_santiago`\n",
    "\n",
    "We promised this would run on Santiago, so here we will show you how to do that. In this example we will use a simulated Santiago device for convenience, but you can switch this out for the real device if you want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "269f52bc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFDCAYAAABY/1W1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0OElEQVR4nO3deXxV1bn/8c8DkQACLaCAJFDEAEoQJIYLtMigVQr2pmJt1dpai3WqQ60/rfbq5bZWWtt6nWrVXrSlaiuodcBaqUMFRBEMCAhUQQmURAYZZKgYJDy/P9ZOeghJ2IHkDOH7fr3yeuWsvc7Os885Oc9ea6+9lrk7IiIisn/NUh2AiIhIplDSFBERiUlJU0REJCYlTRERkZiUNEVERGJS0hQREYkpK9UBpNIRRxzhPXr0SHUYIiKSRubPn7/R3Y+sadshnTR79OhBcXFxqsMQEZE0Ymara9um7lkREZGYlDRFRERiUtIUERGJKelJ08y+Z2YlZvaJmc03s5PqqDvCzF43s01mttPM3jGza6vVucjMXjWzLWb2kZm9YmbDGv9IRETkUJPUpGlmZwN3AT8DBgKvA8+bWfdanrIDuBsYDvQFbgF+YmbfS6gzEpgKnAwMBt4F/mZmvRrjGERE5NBlyVzlxMzmAovd/aKEshXAE+7+o5j7eBIod/dza9luwFpgorv/uq59FRYWukbPiohIIjOb7+6FNW1LWkvTzFoAJwIvVNv0AvD5mPsYGNWdWUe1FkBLYMsBhCkiIlKrZHbPHgE0B9ZXK18PdKnriWZWamblQDFwr7vfX0f1WwjdutMOIlYREZF9ZMrkBicBbYAhwC/MrMTdH65eycy+D1wCfNHdt9W0IzO7GLgYoGvXrsyYMQOAnj170rZtWxYtWgRAx44dyc/PZ9asWQBkZWUxbNgwFixYwLZtYdeFhYWsX7+eNWvWANCrVy+ys7NZsmQJAJ06daJ3797Mnj0bgOzsbIYOHUpxcTE7duwAYPDgwZSWllJWVgZAnz59aN68OcuWLQOgS5cuHH300cyZMweAVq1aMXjwYObOncvOnTsBGDp0KCUlJaxbtw6Avn37UlFRwbvvvgtATk4Oubm5zJ07F4A2bdpQWFjInDlzKC8vB2DYsGEsX76cDRs2ANCvXz/Ky8tZsWIFAN26daNz585Vk0G0a9eOgoICZs+eze7duwEYPnw4S5cuZdOmTQAMGDCA7du3s3LlSiBMJtGhQwcWLFgAQPv27RkwYAAzZ87E3TEzRowYwaJFi9iyJXQUFBQUsHnzZlatWqX3Se+T3ie9T0l5n+qStGuaUffsx8C57v54QvlvgH7uPiLmfm4CvuPux1Qrvxr4KTDG3WfH2ZeuaYqISHVpcU3T3XcB84FTq206lTCKNq5mQHZigZldQ0iYp8dNmCIiIvWV7O7Z24GHzWwe8BpwKdAVuB/AzB4CcPfzo8dXAiWE20gg3HpyLXBv5Q7N7DpgIvBNYLmZVV4f3enuWxv7gERE5NCR1KTp7lPNrCNwE3AUsAQY6+6Vk+NWv1+zOfALoAewG3gfuIEoyUYuBw4j3KuZ6A/ABQ0YvoiIHOKSep9mutE1TRERqS4trmmKiIhkOiVNERGRmJQ0RUREYlLSFBERiUlJU0REJCYlTRERkZiUNEVERGJS0hQREYlJSVNE6mX69On06dOHvLw8br311n2233777fTt25f+/ftzyimnsHp1mPDrlVde4YQTTqj6admyJU8//TQA7s6NN95I7969Oe6447j77ruTeUgisWXK0mAikgYqKiq4/PLLefHFF8nNzWXQoEEUFRXRt2/fqjoDBw6kuLiY1q1bc9999/HDH/6QqVOnMmrUKBYuXAjA5s2bycvL47TTTgNg8uTJrFmzhnfeeYdmzZpVLdUkkm7U0hSR2ObNm0deXh49e/akRYsWnHPOOTzzzDN71Rk1ahStW7cGYMiQIZSWlu6znyeeeIIxY8ZU1bvvvvuYMGECzZqFr6ROnTo18pGIHBglTRGJraysjG7dulU9zs3NrVpIuCYPPvggY8aM2ad8ypQpnHvuuVWP33//faZOnUphYSFjxoypWqxZJN2oe1ZEGsUjjzxCcXExM2fO3Kt87dq1vP3224wePbqqrLy8nJYtW1JcXMyTTz7J+PHjefXVV5Mdssh+qaUpIrHl5OSwZs2aqselpaXk5OTsU++ll15i4sSJTJs2jezsvdaM57HHHmPcuHEcdthhVWW5ubmceeaZAIwbN47Fixc30hGIHBwlTRGJbdCgQaxYsYKSkhJ27drFlClTKCoq2qvOW2+9xSWXXMK0adNqvDb56KOP7tU1C3DGGWfwyiuvADBz5kx69+7deAchchDUPSsisWVlZXHPPfcwevRoKioqGD9+PPn5+UyYMIHCwkKKioq47rrr2LFjB1/72tcA6N69O9OmTQNg1apVrFmzhhEjRuy13xtuuIHzzjuPO+64gzZt2vDAAw8k/dhE4tAi1FqEWkREEmgRahERkQagpCkiIhKTkqaIiEhMSpoiIiIxKWmKiIjEpKQpIiISk5KmiIhITEqaIiIiMSlpioiIxKSkeZAOdBV7gObNm1etYp84f6dWsRcRSU+ae/YgHMwq9gCtWrWqWsk+kVaxFxFJT2ppHoSGWsW+Oq1iLyKSntTSPAg1rWI/d+7cWutXX8X+k08+obCwkKysLG644QbOOOMM4N+r2D/11FMceeSR3H333fTq1avRjkOkvi66s3H3P+nqxt2/yIFS0kySmlaxX716NTk5OaxcuZKTTz6Z448/nmOOOUar2IuIpCl1zx6Eg13FvrJuz549GTlyJG+99RagVexFRNKVkuZBOJhV7Lds2UJ5eTkAGzdu5LXXXqsaQKRV7EVE0pO6Zw/Cwaxi/49//INLLrmEZs2asWfPHm644YaqpKlV7EVE0pO5e6pjSJnCwkIvLi5OdRgiGUcDgaQpM7P57l5Y0zZ1z4qIiMSkpCkiIhKTkqaIiEhMSpoiIiIxKWmKiIjEpKQpIiISk5KmiIhITEqaIiIiMSlpioiIxKSkKSIiEpOSpoiISEyasL0BaB5OEZFDg1qaIiIiMSlpioiIxKSkKSIiEpOSpohIhpg+fTp9+vQhLy+PW2+9dZ/tt99+O3379qV///6ccsoprF69GoCFCxcydOhQ8vPz6d+/P1OnTq16zssvv0xBQQEnnHACw4YN47333kva8WQiJU0RkQxQUVHB5ZdfzvPPP8+yZct49NFHWbZs2V51Bg4cSHFxMYsXL+ass87ihz/8IQCtW7fmoYceYunSpUyfPp2rr76ajz76CIDLLruMP/7xjyxcuJBvfOMb3HLLLck+tIyipCkikgHmzZtHXl4ePXv2pEWLFpxzzjk888wze9UZNWoUrVu3BmDIkCGUlpYC0Lt3b3r16gVA165d6dSpEx9++CEAZsa2bdsA2Lp1K127dk3WIWUk3XIiIpIBysrK6NatW9Xj3Nxc5s6dW2v9Bx98kDFjxuxTPm/ePHbt2sUxxxwDwAMPPMDYsWNp1aoV7dq144033mj44JsQtTRFRJqYRx55hOLiYq677rq9yteuXcu3vvUtfv/739OsWfj6v+OOO/jrX/9KaWkp3/nOd7jmmmtSEXLGSHrSNLPvmVmJmX1iZvPN7KQ66p5pZi+Y2Ydmtt3M5ppZUR31zzUzN7O/NE70IiKpkZOTw5o1a6oel5aWkpOTs0+9l156iYkTJzJt2jSys7Oryrdt28bpp5/OxIkTGTJkCAAffvghixYtYvDgwQCcffbZvP766418JJktqUnTzM4G7gJ+BgwEXgeeN7PutTxlBPB34PSo/l+Bp2pKtGbWE/gV8GojhC4iklKDBg1ixYoVlJSUsGvXLqZMmUJR0d5tiLfeeotLLrmEadOm0alTp6ryXbt2MW7cOM4//3zOOuusqvL27duzdetWli9fDsCLL77Icccdl5wDylDJvqZ5DTDZ3SdFj680sy8BlwE/ql7Z3b9fregnZnY6cAYJydHMDgMeBW4ERgFHNHzoIiKpk5WVxT333MPo0aOpqKhg/Pjx5OfnM2HCBAoLCykqKuK6665jx44dfO1rXwOge/fuTJs2jccee4xZs2axadMmJk+eDMDkyZM54YQTmDRpEl/96ldp1qwZ7du353e/+10KjzL9mbsn5w+ZtQA+Bs5198cTyn8D9HP3ETH38w/gj+5+S0LZL4HPufvZZjYZOMLdv7y/fRUWFnpxcXE9j2RfmntWDjX6zEtTZmbz3b2wpm3JbGkeATQH1lcrXw98Mc4OzOxyIBd4OKHsNODrwAkx93ExcDGEodczZswAoGfPnrRt25ZFixYB0LFjR/Lz85k1axYQzvKGDRvGggULqoZnFxYWsn79euCYOH/6gJWXlzNnzhwAWrVqxeDBg5k7dy47d+4EYOjQoZSUlLBu3ToA+vbtS0VFBe+++y4QroUkjrRr06YNhYWFzJkzh/LycgCGDRvG8uXL2bBhAwD9+vWjvLycFStWANCtWzc6d+5M5UlGu3btKCgoYPbs2ezevRuA4cOHs3TpUjZt2gTAgAED2L59OytXrgSgR48edOjQgQULFgCha2jAgAHMnDkTd8fMGDFiBIsWLWLLli0AFBQUsHnzZlatWgUc3PtUeT2oV69eZGdns2TJEgA6depE7969mT17NgDZ2dkMHTqU4uJiduzYAcDgwYMpLS2lrKwMgD59+tC8efOq++S6dOnC0Ucffci8T+HKSeOZMWOG3if9P6XsfapLMluaXYEyYIS7z0oonwCc5+599vP8rxKS5dnu/mxUdiSwiNB6nRmVTUYtTZFGpc+8NGXp0tLcCFQAnauVdwbW1fVEMzsLeAg4vzJhRvKBo4CXw9kvEA1uMrPdQL67v3vwoYuIiCRx9Ky77wLmA6dW23QqYRRtjczs64QW5gXu/kS1zW8CxxO6Zit/phEGCZ0AlBx04CIiIpFkj569HXjYzOYBrwGXAl2B+wHM7CEAdz8/enwOIWFeC8wysy7Rfna5+2Z3/xewJPEPmNlHQJa771UuIiJysJKaNN19qpl1BG4idKsuAca6++qoSvX7NS8lxHhn9FNpJjCyMWMVERGpLulzz7r7vcC9tWwbWdfjmPu/4EDiEhER2R/NPSsiIhKTkqaIiEhMSpoiIiIxKWmKiIjEpEWoRUQyiGZjSi21NEVERGJS0hQREYlJSVNERCQmJU0REZGYlDRFRERiUtIUERGJSUlTMtb06dPp06cPeXl53HrrrftsnzVrFgUFBWRlZfHEE3uvKnf99dfTr18/+vXrx9SpU6vK3Z0bb7yR3r17c9xxx3H33Xc3+nGISObQfZqSkSoqKrj88st58cUXyc3NZdCgQRQVFdG3b9+qOt27d2fy5Mncdtttez33ueeeY8GCBSxcuJDy8nJGjhzJmDFjaNeuHZMnT2bNmjW88847NGvWjA0bNiT70EQkjamlKRlp3rx55OXl0bNnT1q0aME555zDM888s1edHj160L9/f5o12/tjvmzZMoYPH05WVhaHH344/fv3Z/r06QDcd999TJgwoeo5nTp1Ss4BiUhGqFfSNLNmZtYs4XEXM/uumX2h4UMTqV1ZWRndunWrepybm0tZWVms5w4YMIDp06fz8ccfs3HjRl555RXWrFkDwPvvv8/UqVMpLCxkzJgxrFixolHiF5HMVN/u2eeA6cBdZtYGKAYOB9qY2YXu/lBDByjS0E477TTefPNNPv/5z3PkkUcydOhQmjdvDkB5eTktW7akuLiYJ598kvHjx/Pqq6+mOGIRSRf17Z4tBP4e/X4msA3oBFwEXNuAcYnUKScnp6p1CFBaWkpOTk7s5994440sXLiQF198EXend+/eQGixnnnmmQCMGzeOxYsXN2zgIpLR6ps02wAfRb+fBjzl7p8SEukxDRiXSJ0GDRrEihUrKCkpYdeuXUyZMoWioqJYz62oqGDTpk0ALF68mMWLF3PaaacBcMYZZ/DKK68AMHPmzKpkKiIC9e+e/SfwBTN7FhgNfC0q7wB83JCBidQlKyuLe+65h9GjR1NRUcH48ePJz89nwoQJFBYWUlRUxJtvvsm4cePYsmULzz77LP/zP//D0qVL+fTTTznppJMAaNeuHY888ghZWeFf4YYbbuC8887jjjvuoE2bNjzwwAOpPEwRSTP1TZq3Aw8DO4DVwKyofDjwdgPGJbJfY8eOZezYsXuV3XzzzVW/Dxo0iNLS0n2e17JlS5YtW1bjPj/72c/y3HPPNWygItJk1CtpuvtvzWw+0A140d33RJveB/67oYMTERFJJ/We3MDdiwmjZhPLdGouIiJNXr0nNzCz75nZUjP72Mx6RmXXm9nXGz48ERGR9FHfyQ2uBm4C/g+whE0fAFc0XFgiIiLpp74tzUuBi9z9LmB3QvkCIL/BohIREUlD9U2anwOW1FD+KdDq4MMRERFJX/VNmiuBghrKxwI1j+EXERFpIuo7evY24B4za024pjnUzL4F/BAY39DBiYiIpJP63qf5ezPLAn4GtCZMdPABcJW7T63zySIiIhnuQO7TnARMMrMjgGburlV6JWUuurPx9j3p6sbbt4hkpnonzUruvrEhAxEREUl3+02aZrYYGOHuW8zsbcBrq+vu/RsyOBERkXQSp6X5Z6A84fdak6aIiEhTtt+k6e4/Sfj9x40ajYiISBqr7zR6fzezz9ZQ3s7M/t5gUYmIiKSh+k5uMBJoUUN5S+Ckg45GREQkjcUaPWtmibMA9TezzQmPmwOjgbKGDExERCTdxL3lpJgwAMiBF2rYvhO4sqGCEhERSUdxk+bRhGnzVgL/AXyYsG0XsMHdKxo4NhERkbQSK2m6++ro13ovWi0iItJUxJnc4EzgWXf/NPq9Vu7+ZINFJiIikmbitDSfALoAG6Lfa+OEQUEiIiJNUpzJDZrV9LuIiMihRklQREQkprjXNGPRNU0REWnK4l7TjEPXNEVEpEmr1zVNERGRQ5kSooiISEy6T1NERCQm3acpIiISk+7TFBERiUlJUEREJKZ6J00zKzCzh8ysOPp5uNp6myIiIk1SvZKmmZ0HvAkcBfw1+ukMzDOzbzZ8eCIiIumjvi3NicB/u/up7j4h+jkN+G/gljg7MLPvmVmJmX1iZvPN7KQ66h5lZn8ys3fMrMLMJtdSr52Z3W1mH5hZuZm9Z2Zfr+exiYiI1Km+SfNI4LEayh8HOu3vyWZ2NnAX8DNgIPA68LyZda/lKdnARuBWYG4t+zwMeBHoBXwd6ANcAJTsLx4REZH6iLUIdYJXgJHAe9XKRwIzYzz/GmCyu0+KHl9pZl8CLgN+VL2yu68CrgIws7Nq2ed3CMn8JHffFZWtihGLiIhIvdR3wvbngZ+bWSHwRlQ2BDgT+PF+9tMCOBG4rdqmF4DPx4y3JmcArwG/NrOvAJsJreGJ7v7pQexXRERkLwc6YfvF0U+iXwP31rGfIwiTH6yvVr4e+GKMOGrTEzgZ+BNwOtAD+A3QBrj2IPYrIiKyl6YwYXszwmxFF7l7BTDfzDoCd5jZde7uiZXNrCrhd+3alRkzZgDQs2dP2rZty6JFiwDo2LEj+fn5zJo1C4CsrCyGDRvGggUL2LZtGwCFhYWsX78eOKZRD7C8vJw5c+YA0KpVKwYPHszcuXPZuXMnAEOHDqWkpIR169YB0LdvXyoqKnj33XcByMnJITc3l7lzw2XhNm3aUFhYyJw5cygvLwdg2LBhLF++nA0bNgDQr18/ysvLWbFiBQDdunWjc+fOFBcXA9CuXTsKCgqYPXs2u3fvBmD48OEsXbqUTZs2ATBgwAC2b9/OypUrAejRowcdOnRgwYIFALRv354BAwYwc+ZM3B0zY8SIESxatIgtW7YAUFBQwObNm1m1ahWw7/sUrgw0juLiYnbs2AHA4MGDKS0tpaysDIA+ffrQvHlzli1bBkCXLl04+uijD5n3CUY0+OudaMaMGfTq1Yvs7GyWLFkCQKdOnejduzezZ88GIDs7m6FDhx5y7xPUNgSkYezZsyfW996aNWsAmuT7VBerllMaTdQ9+zFwrrs/nlD+G6Cfu9f5X2hmfwE2uvsF1cpnAp+6+xcTyk4CZgGd3P3D2vZZWFjolR/ag3HRnQe9izpNurpx95/JGvO11+teO33mU0evfeMzs/nuXljTtvoOBMLM2gNjCKc7LRK3ufvNtT3P3XeZ2XzgVMJo20qnAn+ubxwJXgO+YWbN3H1PVNabkKA3HsR+RURE9lKvpGlmQ4DngHLCiNUywkQH5YQRq7UmzcjtwMNmNo+Q7C4FugL3R/t/CMDdz0/4mydEv7YD9kSPd7n7sqj8PuAK4C4zu4dwTfMnwL3Vu2ZFREQORn1bmr8C/gh8H9hGGIDzL+BR4MH9Pdndp0bXG28iJNslwFh3Xx1Vqamz/q1qj/8TWE1Ijrj7GjM7jZCQFwLrgN8Rc7IFERGRuOqbNPsDF7q7m1kFkO3uK83sesLo1T/ubwfufi+1jLJ195E1lFmMfb7Bwd22IiIisl/1HRm7K+H39cDnot93ELpZRUREmqz6tjQXAIOA5cAM4BYz6wx8E1jcsKGJiIikl/q2NG8EPoh+vwn4kDCpQXv2nexARESkSalXS9PdixN+/5Bw64mIiMghod73aQKY2THAcdHDZe6+suFCEhERSU/1vU+zI+HWkiJgz7+L7S/AeHff1MDxiYiIpI36XtN8AMgDTgJaRj/DgaOBSXU8T0REJOPVt3t2NHCKu89JKHvNzC4BXmq4sERERNJPfVuaHxJmAKruY0BdsyIi0qTVN2neDNxpZjmVBdHv/8v+550VERHJaPvtnjWzt4HEic+PBlaZWVn0OAf4BOhEuOYpIiLSJMW5pvlEo0chIiKSAfabNN39J8kIREREJN0d6OQGJwN9Cd22S919RkMGJSIiko7qO7lBDvAUcCL/noO2q5kVA+Pc/YNanywiIpLh6jt69m6gAshz927u3g3oFZXd3dDBiYiIpJP6ds+eCox095LKgmgR6quAlxs0MhERkTRT35Ym7H37SV1lIiIiTUp9k+bLwK/NrFtlgZl1B+5ELU0REWni6ps0rwIOB1aa2WozWw28H5Vd1dDBiYiIpJP6XtPcBPwHMBI4Nir7h7trsnYREWnyYidNM2sObAUGuPuLwIuNFpWIiEgait096+4VwGqgReOFIyIikr7qe03zp8CtZnZEYwQjIiKSzup7TfNawionZWZWSrW1Nd29f0MFJiIikm7qmzSfINyTaY0Qi4iISFqLlTTNrDXwK+AM4DDCPZlXuvvGxgtNREQkvcS9pvkT4ALgOeBR4IvAfY0Uk4iISFqK2z17JnChu08BMLM/Aq+ZWfNoVK2IiEiTF7el2Q14tfKBu88DdgNdGyMoERGRdBQ3aTYHdlUr280BLmItIiKSieImPQMeMbPyhLKWwCQz+7iywN2LGjI4ERGRdBI3af6hhrJHGjIQERGRdBcrabr7dxo7EBERkXR3IItQi4iIHJKUNEVERGJS0hQREYlJSVNERCQmJU0REZGYlDRFRERiUtIUERGJSUlTREQkJiVNERGRmJQ0RUREYlLSFBERiUlJU0REJCYlTRERkZiUNEVERGJS0hQREYlJSVNERCQmJU0REZGYlDRFRERiUtIUERGJSUlTREQkJiVNERGRmJKeNM3se2ZWYmafmNl8MztpP/VHRPU+MbOVZnZpte3NzeynCfssMbNbzCyrcY9EREQONUlNmmZ2NnAX8DNgIPA68LyZda+l/tHAX6N6A4GfA782s68mVLseuBy4CjgW+H70+EeNdBgiInKISnZr7BpgsrtPih5faWZfAi6j5iR3KfCBu18ZPf6HmQ0GrgX+HJV9HnjW3Z+NHq8ys2nA4EY5AhEROWQlraVpZi2AE4EXqm16gZD4ajK0hvp/AwrN7LDo8WxglJkdG/2dvsDJhBaqiIhIg0lmS/MIoDmwvlr5euCLtTynC/BSDfWzov2tBX4BtAWWmVlFtG2iu99b0w7N7GLgYoCuXbsyY8YMAHr27Enbtm1ZtGgRAB07diQ/P59Zs2YBkJWVxbBhw1iwYAHbtm0DoLCwkPXr1wPHxDn+A1ZeXs6cOXMAaNWqFYMHD2bu3Lns3LkTgKFDh1JSUsK6desA6Nu3LxUVFbz77rsA5OTkkJuby9y5cwFo06YNhYWFzJkzh/LycgCGDRvG8uXL2bBhAwD9+vWjvLycFStWANCtWzc6d+5McXExAO3ataOgoIDZs2eze/duAIYPH87SpUvZtGkTAAMGDGD79u2sXLkSgB49etChQwcWLFgAQPv27RkwYAAzZ87E3TEzRowYwaJFi9iyZQsABQUFbN68mVWrVgH7vk8wsmFf7ATFxcXs2LEDgMGDB1NaWkpZWRkAffr0oXnz5ixbtgyALl26cPTRRx8y7xOMaPDXO9GMGTPo1asX2dnZLFmyBIBOnTrRu3dvZs+eDUB2djZDhw495N4nqPFqVoPZs2dPrO+9NWvWADTJ96ku5u4H/urWg5l1BcqAEe4+K6F8AnCeu/ep4TnLgUfc/eaEsuHATKCru681s3OAXwHXAUuBEwjXTa9z9wfriqmwsNArP7QH46I7D3oXdZp0dePuP5M15muv1712+synjl77xmdm8929sKZtyWxpbgQqgM7VyjsD62p5zrpa6u+O9gchYd7m7lOix2+b2ecI10jrTJoiIiL1kbRrmu6+C5gPnFpt06mE0bE1mVNL/WJ3/zR63JqQjBNVoHtQRUSkgSV79OztwMNmNg94jTA6titwP4CZPQTg7udH9e8HrjCzO4HfAl8ALgDOTdjns8ANZlZC6J4dSBil+1AjH4uIiBxikpo03X2qmXUEbgKOApYAY919dVSle7X6JWY2FriDcFvKB8BV7v7nhGpXAj8F7gU6EQYHTQJuRkREpAElfdacaFRrjSNb3X1kDWUzgYI69rcduDr6ERERaTS67iciIhKTkqaIiEhMSpoiIiIxKWmKiIjEpKQpIiISk5KmiIhITEqaIiIiMSlpioiIxKSkKSIiEpOSpoiISExKmiIiIjEpaYqIiMSkpCkiIhKTkqaIiEhMSpoiIiIxKWmKiIjEpKQpIiISk5KmiIhITEqaIiIiMSlpioiIxKSkKSIiEpOSpoiISExKmiIiIjEpaYqIiMSkpCkiIhKTkqaIiEhMSpoiIiIxKWmKiIjEpKQpIiISk5KmiIhITEqaIiIiMSlpioiIxKSkKSIiEpOSpoiISExKmiIiIjEpaYqIiMSkpCkiIhKTkqaIiEhMSpqHuOnTp9OnTx/y8vK49dZb99leXl7O2WefTV5eHoMHD2bVqlUAbNq0iVGjRtGmTRuuuOKKvZ7zpS99iQEDBpCfn8+ll15KRUVFMg5FRKTRKWkewioqKrj88st5/vnnWbZsGY8++ijLli3bq86DDz5I+/btee+99/jBD37A9ddfD0DLli356U9/ym233bbPfh977DEWLVrEkiVL+PDDD3n88ceTcjwicTT0ieLHH3/M6aefzrHHHkt+fj433HBDsg5FUkBJ8xA2b9488vLy6NmzJy1atOCcc87hmWee2avOM888w7e//W0AzjrrLF5++WXcncMPP5xhw4bRsmXLffbbrl07AHbv3s2uXbsws8Y/GJEYGutE8dprr+Wdd97hrbfe4rXXXuP5559PyvFI8ilpHsLKysro1q1b1ePc3FzKyspqrZOVlcVnPvMZNm3atN99jx49mk6dOtG2bVvOOuushg28CWiMbvH58+dz/PHHk5eXx1VXXYW7J+NQMkpjnCi2bt2aUaNGAdCiRQsKCgooLS1NzgFlmKbwuVfSlEbxt7/9jbVr11JeXs7f//73VIeTVhqrtXPZZZcxadIkVqxYwYoVK5g+fXpSjieTNOaJIsBHH33Es88+yymnnNJwQTcRTeVzr6R5CMvJyWHNmjVVj0tLS8nJyam1zu7du9m6dSsdO3aMtf+WLVvyla98ZZ8z+UNdY7R21q5dy7Zt2xgyZAhmxvnnn8/TTz+drEMSwv/Hueeey1VXXUXPnj1THU7aaSqfeyXNQ9igQYNYsWIFJSUl7Nq1iylTplBUVLRXnaKiIv7whz8A8MQTT3DyySfXeY1yx44drF27FghfIs899xzHHnts4x1EBmqM1k5ZWRm5ubl17lMa90Tx4osvplevXlx99dUNGnNT0VQ+91mNundJa1lZWdxzzz2MHj2aiooKxo8fT35+PhMmTKCwsJCioiIuvPBCvvWtb5GXl0eHDh2YMmVK1fN79OjBtm3b2LVrF08//TQvvPACHTt2pKioiPLycvbs2cOoUaO49NJLU3iUIv+WeKKYk5PDlClT+NOf/rRXncoTxaFDh8Y6UQS46aab2Lp1Kw888EBjhi9pQEnzEDd27FjGjh27V9nNN99c9XvLli1rvWWk8iJ9dW+++WaDxdcU1ae1k5ubG6u1k5OTs9fgk5r2KY1zotiuXTsmTpzIscceS0FBAQBXXHEF3/3ud1N1mGmpqXzulTRFkqwxWjtHHXUU7dq144033mDw4ME89NBDXHnllY19KBmpMU4UNVJ5/5rK515JUyTJGqO107dvX+69914uuOACdu7cyZgxYxgzZkwKj1Jkb03lc2+H8hlSYWGhFxcXH/R+Lrrz4GOpy6SrG2/fmRw7NG78jR17JtPnpnaZHDvocw9gZvPdvbCmbRo9KyIiEpO6Z0VSRC0GOdQ0hc+8WpoiIiIxKWmKiIjElPSkaWbfM7MSM/vEzOab2Un7qT8iqveJma00s33ulK/vPkVERA5EUpOmmZ0N3AX8DBgIvA48b2bda6l/NPDXqN5A4OfAr83sqwe6TxERkQOV7JbmNcBkd5/k7v9w9yuBtcBltdS/FPjA3a+M6k8C/gBcexD7FBEROSBJS5pm1gI4EXih2qYXgM/X8rShNdT/G1BoZocd4D5FREQOSDJbmkcAzYH11crXA11qeU6XWupnRfs7kH2KiIgckKTNCGRmXYEyYIS7z0oonwCc5+59anjOcuARd785oWw4MBPoCtgB7PNi4OLoYR/g3QY4vPo6AtiYgr/bEBR76mRy/JkcO2R2/Iq9/j7n7kfWtCGZkxtsBCqAztXKOwPrannOulrq7472Z/Xdp7v/H/B/saNuBGZWXNsUTelOsadOJsefybFDZsev2BtW0rpn3X0XMB84tdqmUwkjXmsyp5b6xe7+6QHuU0RE5IAkexq924GHzWwe8BphdGxX4H4AM3sIwN3Pj+rfD1xhZncCvwW+AFwAnBt3nyIiIg0lqUnT3aeaWUfgJuAoYAkw1t1XR1W6V6tfYmZjgTsIt5B8AFzl7n+uxz7TUUq7hw+SYk+dTI4/k2OHzI5fsTegQ3ppMBERkfrQ3LMiIiIxKWmKiIjEpKSZAmZmqY5BRETqT0kzBVwXklNCJysicrA0EChJzCwb6A+MA7YCS4H3gDXu/i8zMyXT5NBrnXxm1szd96Q6jkNR4muvz/7BU9JMEjO7GziTsAJLe6AH4Raap4E73X1lyoKLycyaExrKGfXlZ2ZtgOHAOcAWYAWwHFji7h+kMra4zCwL2JNpr72kBzNr6+7bUx1HU6CkmQRm1hd4AzgLmO/um8zsSOBC4BLC5PLfByal41mgmZ3o7vOrlTUnfImnXbzVmdkfCElzBeGEpRsheS4kvOZ/T110dTOzYe4+u1pZxiRQM+sGjAcGAe8T5npeCix29y3p2vJJjCuTXu9EZnYcYenEgYRerX8Ci4BZ7r4mqpOWr386U9JMAjP7L+BL7j48epzl7rsTtv+M0Ao9Od1aPmbWi/BFt4yw5NrD7v5WwnYjTJIxEFgYTW2YNqITlrmEqRXfdPcKM/sM8HXgu0AhcDNwC2l2EmBmxxJe938BzwG/dvfXErYbcBgwGpjn7tVX+0mpaBH5PwOtgDeBfoR5oTcBrwK3u/v7qYuwdtFJ7XHVFoIwwqpKFen0OamJmR0D/JWw4tNrwLGEk/NsQgJ9wN2rL6mYFsysM+H/9a/uvrmOeoe5+6fJiyzQQKDk+AdwlJnlAbj7bjPLMrOW0fZJwMeElmi6OZfQQngRGAL8xczeMLMfmlm36MujE6El3SmFcdbmNGCRu78RJcwW7r41WrR8MHA5IXkek4ZfhGcSWgY/A3KAmWa2zsxuM7PKeD8LPAO0SF2YtbqesArRKHc/390LCGvk/hH4MvCGmX0llQHW4cfAjOj1/o2Z9fVgt7u7mTUzs+5m9rWo1yXdXEu4BHG6u//I3ccBZwB3E5LnU2Z2YQrjq8tNwEPAe2b2uJmNjcaEVDGz7sD3q5cng5JmcswirMzyFzP7upllR/98n0CYLpBwBlueyiBr0YdwxvoL4CLgvwhTFX4TmGNmzxLmBf6Hu5emLMraLQI+Z2anQFg4IDphaRVtfxxYzd7zGaeLHEIr4bfAV4CTgd8BpwMrzGwxMIXw2q9JWZS1ywdmuvu6aNH4LHf/p7v/wt0/B7wEXBoloHQb2TyIMH/1fcAwYImZvWdm/2VmHaKu2m8Dv3D3ilQGWovPAQvcfbuZNTez5u6+3t0nRz1e9wMXmVnrFMdZk0LC983/I1xOeQooMbNfm1lBVOci4FJ3T/53prvrJwk/hEnkp/Lvbs5bCF+CvYG7gA+Bw1MdZ7WYs4BvAD+qVt6B0GK4AngM2ANcmOp4azmGloRW8lrCZP6taqizELg81bFWi6k5MBb4XrXyFoQ5mr9M6KHYA3wn1fHWcgw/jl7btgllh1W+B4Rk9D4wJNWxVov7c8DfCItDNCOcvIwGfkO4LriHcDKzGfhBquOt5Ri+H8V6bLXPTovo975ACaEXIOXxJsTYlXAie3H0OIvQtXx99FmqAN4mXLL4fipi1DXNJIomlv8yob++J6EV156wqPZv3X1KCsPbr5quIZjZmcATQBt3/zg1kdUtalVOJHR/7yR0JT8D7AC+Q/jy7pOu8UPNt2yY2WjgedL0tTezE4FnCWvb/tjdp1Xbfizhi7BDOsVvZu0It4atcveZCeWtCF/qJwLfI3xu2rr7zpQEWofoevKThO77n7r776pt7wcsAD6bZq/94YTGxAZ3n1ttW2vCdfFrCZcuUvLaK2k2MjPLBfKih/8itDR3EpJmG8K1zI1exwXvVKnt3rpoNGGFu7uZ3QYUuvvIpAcYQ9QtVRHddjIMOIlwbbaA0Jp7iTCC9vkUhrmPqLvSanr9E+r8GBjq7qOTFlhMlaMyo+v4vyS85pUDgJ4ntHTOAkrc/eupi7RulYN/PGHgXlT+RyAnXT/3EG4zAX4OnEdo4b9A+Lz3I/wvLPR/L8OYlmoa3WtmkwljEE5KSUxKmo3HzC4jDLcfQEiOK4FS4BXgCU/P61BVEhK+Ebqk3nX3dQnbjXCtrczd30xNlPVjZi2AIwknLi2Bre7+r9RGdWDMbCTwobsvTXEodYoGvH2R0MPyH4RrnZsJ3cuPeHov4wfsPXKWMBp4FvBzT1imMF1EsTaLThZbAscTbrk6mXCyWAI8AjyZ+P+cDsysGeFe8BoTU9Tafwa4z92fSmpwlTEoaTaOqCv2PeB/CYMJjiR8cYwknGVXrg26LB3vlaqW8P9FOJZSQtfm0+7+bgrD2y8za5XYdbO/f8Z0Uj32TBO91l8hfOZbEa5bvuruW6MvcSd0rW1MYZg1qhZ7a8Lo35nuviGhTjbwRXd/LjVR1p8l3FdtZp9x962pjulAmNlhhJ6tOSmLIQO+QzKSmV0JfNPDbQ3Vtw0jdJvkAP+Rbl8e+0n4xxGS5w+ihN/c02z0oJm1J4yafY5wRv16ZbJMTJ4Wbv4u9TSaKWU/sSfecH8csNbdP0pVrDWJugQfBEYReifKCD0VHxO6Bh9x9xVR3bSaWq+G2EsJCf4TwriDh939ndRFWLcooRwNrPYaRpWm48l5pf3Fnk50y0nj2QW0jS64Y2bZUdcgHmZ4OY/wz3ha6kKs1TeA5e5+i7tvcvd33P0edz+LMINRa8LtM0ekW8KMfJNwE/2JhG6098zsZjPr4+6VZ9vdgD8RTgjSSV2xVybMytg7pC7MWl1FGOA21t07Ez5L/wssJgyCu93CxAGkU8KMVI/9POBOwmjN04BfVsaepi4H3gLuN7P/NLMuifeQRp/7dmY2JkpS6aTO2CEM0DKz0yu/R1NFLc1GErXWZhK6M39Q2ZqxvSdPfp3Q1fnL1EW6LzO7hDBk/evuviTqjnKPZvuxcGPxdOAWd/9TCkOtkZlNIlx7mkC4kftcwqCTnoSZaX4HdARudPc2qYqzJpkcO4CZvQo85e63VytvDnyB0JJ7392/lIr46pLJsQOY2RzCiXgW8HnCLSdPEUbRvh11j18KXODuQ1IX6b4yKXa1NBtBdCF+M2Fmi1OBD8zswWgIPhZmEvkm4QL9Y6mLtFZPELqnrrYw0XO5h0kBmgG4+z+Bj4DcFMZYoyjBLyOsHrPB3Re7+48IN0yPjrb9mHALyi9SFmgNMjl2qBpVvQT4amWLzMKN9c3cvcLDlHSXArlmNiCVsVaXybFD1bR/nxJGgp9EuNf0QULrfhbwdzO7HriaMK1k2si42D0Nbmhtqj+Ee6T6E/7Z/ka4L3AH4Xrh+4R711IeZ7WYLfo5gzBTznbCB/hEwklWd0IX4nagR6rjreUYsoEu0e/NCSMJE7ePJJwU5KY61qYUexTfkOiz/Qugcw3bu0X/AzmpjrWJxX4U8ANgdA3bBhImZtgUfXbSKv5Mi13dsw3MzDoB3yJMAbWRcGvDR8BsQlftYYTbOKa7+/IUhblfZvZZQoL8POFG7y9Em9YRkurD7v7jlARXh4T7A3sC//KEScwTtk0gdPP0TF2k+8rk2KFqkFUzwoQRPyN0tf2ZMBPWPwknkF8G+rr7oFTFWZNMjr1SdDuGu/snUW8X8O9F781sIuF67cBUxVibTIpdSbOBWbjxNp8wE8pmwmCN4wnT5W0AbvJqM12ki0xP+AnxX0N4rXcTps97nHBP2r+if8iLgA/c/S8pC7aaTI69JtFJ1wWEgUAnEHomPiFcl/15uv4PQMbHXuMIWQuz6SwAfu/uade1D5kTu5JmA4q+1LYTzohmJZR1BwYTVtPoSRhgsyBlgdYikxM+1Br/QMLclaXArzx9l0OaTIbGDlVTz21P/NKLWm8tCTNf9SO0ntPu85PJsUPN8ddQpyVwNvCop9HyfZkYu5JmAzKzfMKqExe5+xs1bM8mTPT8oocBHmmjCST82uLPJVyruogwwODcdIs/k2OvZGa/BeZFP6vdfVsNddp7Gi48ncmxQ+z4P+tpdk8vZGjsqb6o2pR+CLOfvAzMAXpRbRBHVOdKwpyPKY+3Wlz5hPvRalxxgjBApZjQPZXyeA8g/hbpGn8mxx7Fdy5hkMZHhKkif0uYUDuPf69o0gZ4Gjg+1fE2ldjriH8ccExC/JVTz/VLdbxNIXa1NBuYmQ0hrFW3k/AheBnY4u47or75h4BP3P2bKQxzH9GF+L8QJi44n3A/WvVVNa4kLAF2QvIjrFsmx5/JscNe95b+kpBwvk344nuXsBbry4RJA+5y97RaLDuTY4fMjj9TY1fSbAQWZgH6b6CIMG/rHMJ6mV8kDO74rru/nboIa5apCb9SJsefqbFH9zf+EGjn7jcklOcTupXPIlwb/CzwB3e/MBVx1iSTY4fMjj+jY1fSbDzRiMjTCfc8fkK4efpxT+/5KzMy4VfK5PgzNXYL8+V2dvd3LExx9qknfLGY2dnAo0CBuy9MUZg1yuTYIbPjz9TYlTSTxNJscur9ycSEnyiT48/k2CtFo0/Nw/JUFxG62FqnOq44Mjl2yOz4MyF2JU3Zr0xL+NVlcvyZHHslM7uGsJDzr1IdS31lcuyQ2fGna+xKmiLSqCysqFGRick/k2OHzI4/XWNX0hQREYlJq5yIiIjEpKQpIiISk5KmiIhITEqaIiIiMSlpioiIxKSkKSIiEtP/B5anyr1eOY6kAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.test.mock import FakeSantiago\n",
    "from qiskit import assemble\n",
    "from qiskit.visualization import plot_histogram\n",
    "santiago = FakeSantiago()\n",
    "real_device = False\n",
    "\n",
    "## Uncomment this code block to run on the real device\n",
    "#from qiskit import IBMQ\n",
    "#IBMQ.load_account()\n",
    "#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n",
    "#santiago = provider.get_backend('ibmq_santiago')\n",
    "#real_device = True\n",
    "\n",
    "# We need to transpile for Santiago\n",
    "tqc = transpile(shor_circuit, santiago, optimization_level=3)\n",
    "\n",
    "if not real_device:\n",
    "    tqc = assemble(tqc)\n",
    "\n",
    "# Run the circuit and print the counts\n",
    "counts = santiago.run(tqc).result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77d953d3",
   "metadata": {},
   "source": [
    "If your score was low enough, you should see we have a high probability of measuring $0$, $2$, $4$ or $8$ as we saw with the perfect simulation. You will see some extra results due to inaccuracies in the processor and unwanted things interacting with our qubits. This 'noise' gets worse the longer our circuit is, as longer computation time means more time for unwanted interactions, and more gates means more potential errors. This is why we needed to cheat to create the smallest circuit possible.\n",
    "\n",
    "In the near future, our quantum systems will improve enough that we can start using more advanced error mitigation techniques to overcome these problems, which will mean we can run large enough circuits that we can [perform Shor's algorithm without cheating](https://arxiv.org/pdf/quant-ph/0205095.pdf)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bddc9b0",
   "metadata": {},
   "source": [
    "## Additional information\n",
    "\n",
    "**Created by:** Frank Harkins\n",
    "\n",
    "**Version:** 1.0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "377e07e0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  },
  "nbdime-conflicts": {
   "local_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "key": 0,
         "length": 1,
         "op": "removerange"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ],
   "remote_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "diff": [
          {
           "key": 4,
           "op": "addrange",
           "valuelist": "8"
          },
          {
           "key": 4,
           "length": 1,
           "op": "removerange"
          }
         ],
         "key": 0,
         "op": "patch"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ]
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}