diff --git a/IBM Quantum Summer School 2023/lab1-solution.ipynb b/IBM Quantum Summer School 2023/lab1-solution.ipynb new file mode 100644 index 0000000..c48f59f --- /dev/null +++ b/IBM Quantum Summer School 2023/lab1-solution.ipynb @@ -0,0 +1,1238 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d9bef481", + "metadata": {}, + "source": [ + "# Qiskit Global Summer School 2023 - Lab 1\n", + "\n", + "This lab shows you how to use Qiskit to implement some of the key concepts you learned in the first 3 lectures of the Qiskit Global Summer School 2023." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4749ad4", + "metadata": {}, + "outputs": [], + "source": [ + "# required imports:\n", + "from qiskit.visualization import array_to_latex\n", + "from qiskit.quantum_info import Statevector, random_statevector\n", + "from qiskit.quantum_info.operators import Operator, Pauli\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.circuit.library import HGate, CXGate\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "742da035", + "metadata": {}, + "source": [ + "## Vectors and Dirac Notation" + ] + }, + { + "cell_type": "markdown", + "id": "808ec86f", + "metadata": {}, + "source": [ + "In the lectures you learned different ways of representing quantum states, including how to use bra-ket (Dirac) notation.\n", + "\n", + "Although bra-ket notation cannot be represented exactly in code, we can represent their vector and matrix equivalent with python.\n", + "\n", + "E.g. we can represent $|0\\rangle$ using a python list:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b93989c8", + "metadata": {}, + "outputs": [], + "source": [ + "ket0 = [[1],[0]]" + ] + }, + { + "cell_type": "markdown", + "id": "34428069", + "metadata": {}, + "source": [ + "And we can use one of Qiskit's visualisation tools to make our vectors nicer to look at:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee9b7eb0", + "metadata": {}, + "outputs": [], + "source": [ + "array_to_latex(ket0)" + ] + }, + { + "cell_type": "markdown", + "id": "a61be47b", + "metadata": {}, + "source": [ + "We can do the same with $\\langle0|$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25f9ff7e", + "metadata": {}, + "outputs": [], + "source": [ + "bra0 = [1,0]\n", + "array_to_latex(bra0)" + ] + }, + { + "cell_type": "markdown", + "id": "2cc359db", + "metadata": {}, + "source": [ + "
Ex 1 - create $|1\\rangle$ and $\\langle1|$ with python lists
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59a7be22", + "metadata": {}, + "outputs": [], + "source": [ + "ket1 = [[0], [1]]\n", + "bra1 = [0, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dcc474ad", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex1 \n", + "\n", + "grade_lab1_ex1([ket1, bra1])" + ] + }, + { + "cell_type": "markdown", + "id": "21b44ec9", + "metadata": {}, + "source": [ + "## Qiskit `Statevector` Class\n", + "\n", + "In the lectures you learned about using state vectors to represent quantum states. You can represent quantum state vectors in code using Qiskit's [`Statevector` class](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.html).\n", + "\n", + "Qiskit's `Statevector` class can take different forms of input (e.g. python list, numpy array, another state vector) to construct a state vector.\n", + "\n", + "Let's take the `bra0` object we created earlier and convert it to a `Statevector` object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ac7420a", + "metadata": {}, + "outputs": [], + "source": [ + "sv_bra0 = Statevector(bra0)\n", + "\n", + "sv_bra0" + ] + }, + { + "cell_type": "markdown", + "id": "9d3015ec", + "metadata": {}, + "source": [ + "The `Statevector` class has its own `draw()` method:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7d0a57c", + "metadata": {}, + "outputs": [], + "source": [ + "sv_bra0.draw('latex')" + ] + }, + { + "cell_type": "markdown", + "id": "9a443d7b", + "metadata": {}, + "source": [ + "We can create more complex statevectors with multiple qubits like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dc70f9c7", + "metadata": {}, + "outputs": [], + "source": [ + "sv_eq = Statevector([1/2, 3/4, 4/5, 6/8])\n", + "\n", + "sv_eq.draw('latex')" + ] + }, + { + "cell_type": "markdown", + "id": "c7e00788", + "metadata": {}, + "source": [ + "Note that the vector above is not a valid state vector as it is not normalised. \n", + "We can check this with the `is_valid()` method:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8459bf73", + "metadata": {}, + "outputs": [], + "source": [ + "sv_eq.is_valid()" + ] + }, + { + "cell_type": "markdown", + "id": "a4b83945", + "metadata": {}, + "source": [ + "
Ex 2 - create your own valid statevector object using the `Statevector` class
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02cfaf2f", + "metadata": {}, + "outputs": [], + "source": [ + "sv_valid = Statevector([1/2, 1/2, 1/2, 1/2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed497a1a", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex2 \n", + "\n", + "grade_lab1_ex2(sv_valid)" + ] + }, + { + "cell_type": "markdown", + "id": "3faad35b", + "metadata": {}, + "source": [ + "## Qiskit `Operator` Class\n", + "\n", + "The [`Operator` class](https://qiskit.org/documentation/stubs/qiskit.quantum_info.Operator.html#qiskit.quantum_info.Operator) is used in Qiskit to represent matrix operators acting on a quantum system. It has several methods to build composite operators using tensor products of smaller operators, and to compose operators.\n", + "\n", + "One way we can initialise a Qiskit `Operator` is by using a python list, like the one we created earlier:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "180a544f", + "metadata": {}, + "outputs": [], + "source": [ + "op_bra0 = Operator(bra0)\n", + "\n", + "op_bra0" + ] + }, + { + "cell_type": "markdown", + "id": "dc578df9", + "metadata": {}, + "source": [ + "The Operator class comes with some handy methods for working with operators, for example we can find the tensor product of 2 operators by using the `tensor()` method:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7aed9441", + "metadata": {}, + "outputs": [], + "source": [ + "op_ket0 = Operator(ket0)\n", + "op_bra0.tensor(op_ket0)" + ] + }, + { + "cell_type": "markdown", + "id": "e244f5a0", + "metadata": {}, + "source": [ + "We'll use the `Operator` and `Statevector` classes more in the following exercises." + ] + }, + { + "cell_type": "markdown", + "id": "208cf2b6", + "metadata": {}, + "source": [ + "## Inner & Outer Product\n", + "\n", + "In the lectures you covered the concepts of the inner and outer product. We can explore these concepts in code using numpy methods `.dot()` (the inner product is a generalised form of the dot product) and `.outer()`.\n", + "\n", + "For example, we can find the inner product $\\langle0|0\\rangle$ like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf3cb816", + "metadata": {}, + "outputs": [], + "source": [ + "braket = np.dot(op_bra0,op_ket0)\n", + "array_to_latex(braket)" + ] + }, + { + "cell_type": "markdown", + "id": "e5d604d7", + "metadata": {}, + "source": [ + "and the outer product $|0\\rangle\\langle0|$ like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73232e3d", + "metadata": {}, + "outputs": [], + "source": [ + "ketbra = np.outer(ket0,bra0)\n", + "array_to_latex(ketbra)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98e2ba66", + "metadata": {}, + "outputs": [], + "source": [ + "braket = np.dot(op_bra0,op_ket0)\n", + "array_to_latex(braket)" + ] + }, + { + "cell_type": "markdown", + "id": "cdca2a30", + "metadata": {}, + "source": [ + "Note: the numpy methods we used above work with Qiskit Operators as well as regular python lists." + ] + }, + { + "cell_type": "markdown", + "id": "2dc9ed02", + "metadata": {}, + "source": [ + "
Ex 3 - use numpy to find the result of the following inner and outer products: $\\langle1|0\\rangle, \\langle0|1\\rangle, \\langle1|1\\rangle, |1\\rangle\\langle0|, |0\\rangle\\langle1|$ and $|1\\rangle\\langle1| $
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72e1bb34", + "metadata": {}, + "outputs": [], + "source": [ + "bra1ket0 = [0]\n", + "\n", + "bra0ket1 = [0]\n", + "\n", + "bra1ket1 = [1]\n", + "\n", + "ket1bra0 = [[0, 0], [1, 0]]\n", + "\n", + "ket0bra1 = [[0, 1], [0, 0]]\n", + "\n", + "ket1bra1 = [[0, 0], [0, 1]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37b9cf70", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex3 \n", + "\n", + "grade_lab1_ex3([bra1ket0, bra0ket1, bra1ket1, ket1bra0, ket0bra1, ket1bra1])" + ] + }, + { + "cell_type": "markdown", + "id": "7c03e06d", + "metadata": {}, + "source": [ + "
\n", + "

Ex 4 - when the inner product of 2 quantum states is equal to 0, those states are orthogonal. Which of the following states are orthogonal?

\n", + "

a) $\\vert 0\\rangle$ and $\\vert 1\\rangle$

\n", + "

b) $\\vert 0\\rangle$ and $\\vert 0\\rangle$

\n", + "

c) $\\vert 1\\rangle$ and $\\vert 1\\rangle$

\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e061263", + "metadata": {}, + "outputs": [], + "source": [ + "answer = ['a']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf314ab5", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex4 \n", + "\n", + "grade_lab1_ex4(answer)" + ] + }, + { + "cell_type": "markdown", + "id": "e695b37a", + "metadata": {}, + "source": [ + "## Deterministic operations\n", + "\n", + "As mentioned in the lectures, there are 4 single bit deterministic operations: \n", + "f1 = constant-0 \n", + "f2 = identity \n", + "f3 = bit flip / not \n", + "f4 = constant-1\n", + "\n", + "$$\n", + "\\begin{array}{c|c}\n", + " a & f_1(a)\\\\\n", + " \\hline\n", + " 0 & 0\\\\\n", + " 1 & 0\n", + "\\end{array}\n", + "\\qquad\n", + "\\begin{array}{c|c}\n", + " a & f_2(a)\\\\\n", + " \\hline\n", + " 0 & 0\\\\\n", + " 1 & 1\n", + "\\end{array}\n", + "\\qquad\n", + "\\begin{array}{c|c}\n", + " a & f_3(a)\\\\\n", + " \\hline\n", + " 0 & 1\\\\\n", + " 1 & 0\n", + "\\end{array}\n", + "\\qquad\n", + "\\begin{array}{c|c}\n", + " a & f_4(a)\\\\\n", + " \\hline\n", + " 0 & 1\\\\\n", + " 1 & 1\n", + "\\end{array}\n", + "$$\n", + "\n", + "We can create Qiskit Operators for these 4 operations, by passing their matrix representations as arguments to the `Operator` class.\n", + "\n", + "E.g. for constant-0 we can create the corresponding matrix m1 like so:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8edc4262", + "metadata": {}, + "outputs": [], + "source": [ + "m1 = Operator([[1,1],[0,0]])\n", + "array_to_latex(m1)" + ] + }, + { + "cell_type": "markdown", + "id": "2792a781", + "metadata": {}, + "source": [ + "and similarly for m3:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9cc2ff6c", + "metadata": {}, + "outputs": [], + "source": [ + "m3 = Operator([[0,1],[1,0]])\n", + "array_to_latex(m3)" + ] + }, + { + "cell_type": "markdown", + "id": "765e8f0e", + "metadata": {}, + "source": [ + "We can also use builtin python mutliplication operations (e.g. `@`, `.dot`, or `.matmul`) to check the following equation: $ M|a\\rangle = f|a\\rangle $\n", + "\n", + "e.g. $ M1|0\\rangle = f1|0\\rangle $ = 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a283a8bd", + "metadata": {}, + "outputs": [], + "source": [ + "array_to_latex(m1@ket0)" + ] + }, + { + "cell_type": "markdown", + "id": "f044b3f6", + "metadata": {}, + "source": [ + "
Ex 5 - create Qiskit Operators for m2 and m4 (hint: check out the lectures to find the appropriate matrices)
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31927dfa", + "metadata": {}, + "outputs": [], + "source": [ + "m2 = Operator([[1, 0], [0, 1]])\n", + "m4 = Operator([[0, 0], [1, 1]])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62081ac6", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex5\n", + "\n", + "grade_lab1_ex5([m2, m4])" + ] + }, + { + "cell_type": "markdown", + "id": "d611468d", + "metadata": {}, + "source": [ + "## Probabilistic operations\n", + "\n", + "A Controlled-NOT (or CNOT) operation is a probabilistic operation you can apply on 2 qubits.\n", + "\n", + "Applying a CNOT on a state (X,Y) involves performing a NOT operation on Y when X is 1, otherwise do nothing.\n", + "X is the control bit, Y is the target bit.\n", + "\n", + "We can implement a CNOT gate (and many other quantum gates) using a class from [Qiskit's circuit library](https://qiskit.org/documentation/apidoc/circuit_library.html):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6aec987", + "metadata": {}, + "outputs": [], + "source": [ + "cnot = CXGate()\n", + "\n", + "array_to_latex(cnot)" + ] + }, + { + "cell_type": "markdown", + "id": "49ee11bb", + "metadata": {}, + "source": [ + "Note: this matrix is different from the one that appeared in the lesson because `CXGate()` takes the right qubit to be the control rather than the left qubit." + ] + }, + { + "cell_type": "markdown", + "id": "bd0665bc", + "metadata": {}, + "source": [ + "## Unitary Operations\n", + "\n", + "An operator is unitary if: $ UU^{\\dagger} = \\mathbb{1} = U^{\\dagger} U$\n", + "\n", + "We can check if an operator is Unitary using Qiskit with the `is_unitary()` method:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83e80fd5", + "metadata": {}, + "outputs": [], + "source": [ + "m3.is_unitary()" + ] + }, + { + "cell_type": "markdown", + "id": "ef61f742", + "metadata": {}, + "source": [ + "With small operators like m3 we could probably figure this out easily by ourselves, but with more complex operators it becomes more convenient to use the Qiskit function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90fa7840", + "metadata": {}, + "outputs": [], + "source": [ + "random = Operator(np.array([[ 0.50778085-0.44607116j, -0.1523741 +0.14128434j, 0.44607116+0.50778085j,\n", + " -0.14128434-0.1523741j ],\n", + " [ 0.16855994+0.12151822j, 0.55868196+0.38038841j, -0.12151822+0.16855994j,\n", + " -0.38038841+0.55868196j],\n", + " [ 0.50778085-0.44607116j, -0.1523741 +0.14128434j, -0.44607116-0.50778085j,\n", + " 0.14128434+0.1523741j ],\n", + " [ 0.16855994+0.12151822j, 0.55868196+0.38038841j, 0.12151822-0.16855994j,\n", + " 0.38038841-0.55868196j]]))\n", + "\n", + "random.is_unitary()" + ] + }, + { + "cell_type": "markdown", + "id": "e6778ed6", + "metadata": {}, + "source": [ + "
Ex 6 - create an operator using the `Operator` class that is not unitary
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c43f5bbf", + "metadata": {}, + "outputs": [], + "source": [ + "non_unitary_op = Operator(np.array([0,1,2,3]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c159e466", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex6\n", + "\n", + "grade_lab1_ex6(non_unitary_op)" + ] + }, + { + "cell_type": "markdown", + "id": "220179f8", + "metadata": {}, + "source": [ + "### Qubit Unitary Operations - Pauli Operations\n", + "\n", + "Some of the most common unitary operations in quantum computing are the Pauli operations. Qiskit's `Pauli` classes make it easy to interact with Pauli operators in code:" + ] + }, + { + "cell_type": "markdown", + "id": "26c5fec2", + "metadata": {}, + "source": [ + "E.g. Pauli X ($\\sigma_x$), the bit flip:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "290462f3", + "metadata": {}, + "outputs": [], + "source": [ + "pauli_x = Pauli('X')\n", + "\n", + "array_to_latex(pauli_x)" + ] + }, + { + "cell_type": "markdown", + "id": "ff2d5d30", + "metadata": {}, + "source": [ + "Pauli Y ($\\sigma_y$):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21b32f55", + "metadata": {}, + "outputs": [], + "source": [ + "pauli_y = Pauli('Y')\n", + "\n", + "array_to_latex(pauli_y)" + ] + }, + { + "cell_type": "markdown", + "id": "c9850043", + "metadata": {}, + "source": [ + "Pauli Z ($\\sigma_z$), the phase flip:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9df1dff2", + "metadata": {}, + "outputs": [], + "source": [ + "pauli_z = Pauli('Z')\n", + "\n", + "array_to_latex(pauli_z)" + ] + }, + { + "cell_type": "markdown", + "id": "bdfa41f0", + "metadata": {}, + "source": [ + "We can use the `Operator` class with the `Pauli` class:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71eb657f", + "metadata": {}, + "outputs": [], + "source": [ + "op_x = Operator(pauli_x)\n", + "\n", + "op_x" + ] + }, + { + "cell_type": "markdown", + "id": "22a1dc55", + "metadata": {}, + "source": [ + "Let's use the `Operator` class and numpy to find the outcome of $\\sigma_x|0\\rangle$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3b46f65", + "metadata": {}, + "outputs": [], + "source": [ + "op_new = np.dot(op_x,ket0)\n", + "\n", + "array_to_latex(op_new)" + ] + }, + { + "cell_type": "markdown", + "id": "0434735a", + "metadata": {}, + "source": [ + "
Ex 7 - Apply the Pauli-Z operator on $|1\\rangle$
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11ea5267", + "metadata": {}, + "outputs": [], + "source": [ + "result = [[0.+0.j], [-1.+0.j]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "694825bd", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex7\n", + "\n", + "grade_lab1_ex7(result)" + ] + }, + { + "cell_type": "markdown", + "id": "677ab1ec", + "metadata": {}, + "source": [ + "### Qubit Unitary Operations - Hadamard\n" + ] + }, + { + "cell_type": "markdown", + "id": "1fa9f846", + "metadata": {}, + "source": [ + "The Hadamard gate is one of the most important unitary operations in quantum computing. We can implement a Hadamard gate (and many other quantum gates) using a class from [Qiskit's circuit library](https://qiskit.org/documentation/apidoc/circuit_library.html):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74251a81", + "metadata": {}, + "outputs": [], + "source": [ + "hadamard = HGate()\n", + "\n", + "array_to_latex(hadamard)" + ] + }, + { + "cell_type": "markdown", + "id": "08b41da3", + "metadata": {}, + "source": [ + "You can convert many Qiskit classes to operators to make use of functions specific to the `Operator` class, such as `is_unitary`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebc2f8df", + "metadata": {}, + "outputs": [], + "source": [ + "hop = Operator(hadamard)\n", + "hop.is_unitary()" + ] + }, + { + "cell_type": "markdown", + "id": "aa5207cc", + "metadata": {}, + "source": [ + "## Quantum Circuits\n", + "\n", + "In the lectures you learned how to create a Quantum Circuit using a CNOT and a Hadamard gate. This circuit creates the Bell State $|\\phi^+\\rangle$. We can implement this using Qiskit's `QuantumCircuit` class:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1b3e5a9", + "metadata": {}, + "outputs": [], + "source": [ + "bell = QuantumCircuit(2)\n", + "\n", + "bell.h(0) # apply an H gate to the circuit\n", + "bell.cx(0,1) # apply a CNOT gate to the circuit\n", + "\n", + "bell.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "1b2a93c8", + "metadata": {}, + "source": [ + "If we want to check what the matrix representation is of this quantum state we can convert the circuit directly to an operator:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac8dab7c", + "metadata": {}, + "outputs": [], + "source": [ + "bell_op = Operator(bell)\n", + "\n", + "array_to_latex(bell_op)" + ] + }, + { + "cell_type": "markdown", + "id": "b2487769", + "metadata": {}, + "source": [ + "
Ex 8 - the GHZ state is similar to the Bell State but applied to 3 qubits. Create a quantum circuit outputting the GHZ state
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7469f9f", + "metadata": {}, + "outputs": [], + "source": [ + "ghz = QuantumCircuit(3)\n", + "\n", + "##############################\n", + "# add gates to your circuit here\n", + "\n", + "ghz.h(0)\n", + "ghz.cx(0, 1)\n", + "ghz.cx(1, 2)\n", + "\n", + "##############################\n", + "\n", + "ghz.draw(output='mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ffb9113c", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex8\n", + "\n", + "grade_lab1_ex8(ghz)" + ] + }, + { + "cell_type": "markdown", + "id": "dec5eb53", + "metadata": {}, + "source": [ + "## Measuring Quantum states" + ] + }, + { + "cell_type": "markdown", + "id": "9d05a3cb", + "metadata": {}, + "source": [ + "As explained in the lectures you can find the probability of measurement outcomes by taking the absolute value squared of the entries of a quantum state vector.\n", + "\n", + "For example, when measuring the + state: \n", + "\n", + "$ |+\\rangle = \\frac{1}{\\sqrt2}|0\\rangle + \\frac{1}{\\sqrt2}|1\\rangle $\n", + "\n", + "The probability of measuring 0 or 1 is given by the following:\n", + "\n", + "$ Pr(0) = |\\frac{1}{\\sqrt2}|^2 = \\frac{1}{2}$ \n", + "$ Pr(1) = |\\frac{1}{\\sqrt2}|^2 = \\frac{1}{2}$" + ] + }, + { + "cell_type": "markdown", + "id": "09b17e63", + "metadata": {}, + "source": [ + "Let's create a $|+\\rangle$ using the `Statevector` class:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "819fdc56", + "metadata": {}, + "outputs": [], + "source": [ + "plus_state = Statevector.from_label(\"+\")\n", + "\n", + "plus_state.draw('latex')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c7849e7", + "metadata": {}, + "outputs": [], + "source": [ + "plus_state" + ] + }, + { + "cell_type": "markdown", + "id": "e9367460", + "metadata": {}, + "source": [ + "Now we can get the probability of measuring 0 or 1:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b954ae3", + "metadata": {}, + "outputs": [], + "source": [ + "plus_state.probabilities_dict()" + ] + }, + { + "cell_type": "markdown", + "id": "62b9c13c", + "metadata": {}, + "source": [ + "The dictionary object above shows you all the possible measurement outcomes and what the probability is of getting them. The actual act of measuring forces the state to collapse into either the 0 or 1 state:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "546166ed", + "metadata": {}, + "outputs": [], + "source": [ + "# run this cell multiple times to show collapsing into one state or the other\n", + "res = plus_state.measure()\n", + "\n", + "res" + ] + }, + { + "cell_type": "markdown", + "id": "cbf9efbb", + "metadata": {}, + "source": [ + "We can implement the same $|+\\rangle$ state with measurement using a quantum circuit:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6af8a51d", + "metadata": {}, + "outputs": [], + "source": [ + "qc = QuantumCircuit(1,1)\n", + "qc.h(0)\n", + "qc.measure(0, 0)\n", + "\n", + "qc.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "84e3a739", + "metadata": {}, + "source": [ + "If we ran this circuit using a simulator we would get the same results as we did with the statevector class." + ] + }, + { + "cell_type": "markdown", + "id": "f3abea6e", + "metadata": {}, + "source": [ + "In the next example, let's use the `Statevector` class to find the measurement outcomes for a dependent, probabilistic state. We'll find the measurement probilities for the 2-qubit Bell State $|\\phi^+\\rangle$ :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0c6e31d", + "metadata": {}, + "outputs": [], + "source": [ + "sv_bell = Statevector([np.sqrt(1/2), 0, 0, np.sqrt(1/2)])\n", + "\n", + "sv_bell.draw('latex')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60aca301", + "metadata": {}, + "outputs": [], + "source": [ + "sv_bell.probabilities_dict()" + ] + }, + { + "cell_type": "markdown", + "id": "734489ba", + "metadata": {}, + "source": [ + "
Ex 9 - Using the Statevector class find the probabilities for the other 3 states in the Bell Basis: $|\\psi^+\\rangle$, $|\\psi^-\\rangle$, $|\\phi^-\\rangle$. Hint: check out lesson 2 to refresh your memory on the equations of the Bell states
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "119714dd", + "metadata": {}, + "outputs": [], + "source": [ + "sv_psi_plus = Statevector([0, np.sqrt(1/2), np.sqrt(1/2), 0])\n", + "prob_psi_plus = {'01': 0.5000000000000001, '10': 0.5000000000000001}\n", + "\n", + "sv_psi_minus = Statevector([0, np.sqrt(1/2), -np.sqrt(1/2), 0])\n", + "prob_psi_minus = {'01': 0.5000000000000001, '10': 0.5000000000000001}\n", + "\n", + "sv_phi_minus = Statevector([np.sqrt(1/2), 0, 0, -np.sqrt(1/2)])\n", + "prob_phi_minus = {'00': 0.5000000000000001, '11': 0.5000000000000001}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72585681", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex9\n", + "\n", + "grade_lab1_ex9([prob_psi_plus, prob_psi_minus, prob_phi_minus])" + ] + }, + { + "cell_type": "markdown", + "id": "0faf6184", + "metadata": {}, + "source": [ + "# Final Challenge - generate a QFT circuit\n", + "\n", + "[The Fourier transform](https://en.wikipedia.org/wiki/Fourier_transform) occurs in many different formats throughout classical computing, in areas ranging from signal processing to data compression to complexity theory. The quantum Fourier transform (QFT) is the quantum implementation of the discrete Fourier transform over the amplitudes of a wavefunction. It is part of many quantum algorithms, most notably Shor's factoring algorithm and quantum phase estimation. You'll learn more about this important implementation later on during the Summer School, but for this final challenge of Lab 1 we would like you to use Qiskit to create the following QFT circuit on 2 qubits:\n", + "\n", + "![](resources/qft.png)" + ] + }, + { + "cell_type": "markdown", + "id": "a06d2b68", + "metadata": {}, + "source": [ + "
Ex 10 - create a 2 qubit QFT circuit using qiskit
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e51049ac", + "metadata": {}, + "outputs": [], + "source": [ + "qft = QuantumCircuit(2)\n", + "\n", + "##############################\n", + "# add gates to your circuit here\n", + "\n", + "qft.h(1)\n", + "qft.cp(np.pi/2, 0, 1)\n", + "qft.h(0)\n", + "qft.swap(0, 1)\n", + "\n", + "##############################\n", + "\n", + "qft.draw(output='mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ad87edc", + "metadata": {}, + "outputs": [], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab1_ex10\n", + "\n", + "grade_lab1_ex10(qft)" + ] + }, + { + "cell_type": "markdown", + "id": "94b90a28", + "metadata": {}, + "source": [ + "To see the matrix that describes the action of this circuit, we can plug the circuit into the `Operator` function like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d83e5f5b", + "metadata": {}, + "outputs": [], + "source": [ + "U = Operator(qft)\n", + "\n", + "array_to_latex(U)" + ] + }, + { + "cell_type": "markdown", + "id": "9c1ec931", + "metadata": {}, + "source": [ + "Congratulations! You finished Lab 1 of the Qiskit Global Summer School 2023! 🎉 🎉 🎉" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/IBM Quantum Summer School 2023/lab2-solution.ipynb b/IBM Quantum Summer School 2023/lab2-solution.ipynb new file mode 100644 index 0000000..861ae55 --- /dev/null +++ b/IBM Quantum Summer School 2023/lab2-solution.ipynb @@ -0,0 +1,1080 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab 2 - Creating Entanglement with Qiskit\n", + "\n", + "This lab demonstrates interesting properties of *entangled* qubits. In particular, we will consider two experiments:\n", + "- **CHSH Inequality Violation** - this shows that quantum mechanics *cannot* be explained by a local hidden variable theory\n", + "- **Teleportation** - teleport an arbitrary quantum state using an entangled qubit pair as a resource\n", + "\n", + "In particular, this lab demonstrates how to use new features from IBM Quantum \n", + "- **Primitives** - abstract measurement and error mitigation for scalable quantum computing\n", + "- **Dynamic Circuits** - mid-circuit measurement and feed-forward within the qubits' coherence time" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Getting Started\n", + "\n", + "Start by importing some libraries we need, including the `Sampler` and `Estimator` primitives from Qiskit. While the primitives from `qiskit.providers` use a local statevector simulator by default, the syntax within this lab is easily generalizable to running experiments on real systems.\n", + "\n", + "To run on real hearware requires a Qiskit Runtime service instance. If you haven't done so already, follow the instructions in the Qiskit [Getting started guide](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/getting_started.html) to set one up. TODO: include video links and such. After setup, import the `Sampler` and `Estimator` primitives from `qiskit_ibm_runtime` instead. Additionally we will need `QiskitRuntimeService` and `Session`, which form the interface between Qiskit and Qiskit IBM Runtime. Then the below exercises can be run on real systems by instantiating the primitives in this way (as opposed to from `qiskit.primitives`):\n", + "\n", + "```\n", + "from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Estimator\n", + "\n", + "service = QiskitRuntimeService()\n", + "backend = service.get_backend('...')\n", + "session = Session(service=service, backend=backend)\n", + "sampler = Sampler(session=session)\n", + "estimator = Estimator(session=session)\n", + "```\n", + "where additional options can be specified in the `Sampler` and `Estimator` with the `Options` class. See this [how-to](https://qiskit.org/ecosystem/ibm-runtime/how_to/run_session.html) for using Primitives with Runtime Sessions.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: QC_GRADE_ONLY=true\n" + ] + } + ], + "source": [ + "%set_env QC_GRADE_ONLY=true\n", + "\n", + "from qiskit.circuit import QuantumCircuit\n", + "from qiskit.primitives import Estimator, Sampler\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit.visualization import plot_histogram\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use('dark_background') # optional" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CHSH Inequality Violation\n", + "\n", + "### Warm Up\n", + "\n", + "Create circuits that put the qubit in the excited $|1\\rangle$ and superposition $|+\\rangle$ states, respectivly, and measure them in different bases. This is done first with the `Sampler` primitive (which is most similar to the `backend.run()` used in the previous lab), and then with the `Estimator` primitive to show how measurement is abstracted in that we do not need to worry about rotating the qubit into the appropriate measurement basis. The primitives will be executed withing the `Session` context which allows efficiency to optimize workloads." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAADjUlEQVR4nO3cQUhbdxzA8e//vQSlxMMkB0G2DlGEhiaggzEGVbcdvIyWjlhkC+IEU5fd1na9C6FYux56KoPOjVIHWrtDiT308LLbQGwjMlgOBkQQetgoBoTFvNdD0SLbIJaU//O33wdyeYF/fvDl//LyAs8EQRCgRHBsD6CaR2MKojEF0ZiCaExBNKYgGlMQjSmIxhREYwqiMQXRmIJoTEE0piAaUxCNKYjGFERjCqIxBdGYgmhMQTSmIBpTEI0piMYURGMKojEFidgewJZv/vid0s6Olc9OtbVxo/dU09f938Ys7ezw619/2h6jqfQ0K4jGFERjCqIxBdGYgmhMQTSmIBpTkNDF9H2f2dlZenp6aG1tJZVKUSwW6e3tZXJy0tpcQa1G7eLX1G9/f+h4/cEv1L4YI6hWLU32SuhiTkxMMD09TTabZXl5mZGREUZHR9nY2KC/v9/aXCYaJXL1Mv7DAv6TpwAElQr+nR9xr1zCxGLWZtsXqtt58/PzzM3N4XkeAwMDAAwNDbG6usrS0hJ9fX1W5zPvnsT5coz67E3MrZvsXbuOc/ZTnORpq3PtC9XOzOfzDA8PH4Tc193dTTQaJZlMWprsFefcWcw7b7OXzYHr4oxlbI90IDQxt7a2WF9fJ51O/+O9zc1NEokELS0tFiY7zBiDSZ6G589xPv4IE43aHulAqGICdHR0HDq+u7tLsVhs+BRrjGno5Xnea80ZVCr4937GuZDGv3uP4NmzI6/heV7Dcx5FaGLG43EAyuXyoeMzMzNsb29bvfjZF/xde/k9ef4c7sQ45sMPqF//jsD3bY8GhOgCqKuri2QyST6fp729nc7OThYXFykUCgANx2z0uY6frPx25P8z/Ts/YCIRnMznALhfXWQvm8O//wA3/VnD6wwODvL4DTx/MjQ703EcFhYWSCQSTE1NMT4+TjweJ5fL4bqu9Ysf/8lT/MIj3KtXMJGXe8CcOIH77SX8n+4SVCpW5wMwYX9EaSaToVQqsba21tR1X2dnNsuZt9p5/N77TV83NDvzv6ysrITi+/I4CHXMarVKuVy2frPguAjNBdC/icVi1Ot122McG6HemepoNKYgGlMQjSmIxhREYwqiMQUJ9e/MNynV1ibus0N/b1Y1Tk+zgmhMQTSmIBpTEI0piMYURGMKojEF0ZiCaExBNKYgGlMQjSmIxhREYwqiMQXRmIJoTEFeALS14W1518x6AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create excited |1> state\n", + "qc_1 = QuantumCircuit(1)\n", + "qc_1.x(0)\n", + "qc_1.draw('mpl')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAACzklEQVR4nO3csWtaURzF8aOpmCFLghTB0sEapFgMaMlqhLaYqaWdMmQIASGEFuKaulkHces/kC1DHo92celQ35Ih2EDESegSEoQ6ZBFSKNFObZG28ATLvZ6ez3gj1x98c1/ME15gNBqNIBSCpgeQ6VFMIopJRDGJKCYRxSSimEQUk4hiElFMIopJRDGJKCYRxSSimEQUk4hiElFMIopJRDGJKCYRxSSimEQUk4hiElFMIopJ5JbpAUxxW8DllZn3ji0Czx9Of9//NublFfD5i+kppkuXWSKKSUQxiSgmEcUkophEFJOIYhKxLuZwOES9Xsfy8jLm5+exsrICz/OQTCZRLBaNzeVU1nDyruJ73QTr7gBtb2/DdV2Uy2Vks1kcHx9jY2MD/X4fpVLJ9HhWsyrm4eEhDg4O0Gw2kcvlAAD5fB6np6dwXReZTMbwhHaz6jJbrVZRKBR+hvwhkUggFAohnU4bmmw2WHMyLy4u0Ol0sLe399vPzs/PkUqlEA6HDUz2y8n7N/jUqI+tffs6wN0HjwxNNM6qmAAQjUbH1q+vr+F5HtbX133tEwgEfL3uxf5H3Lm/NtGMq0/3sfrs9diaU5lsDwDwvCZePcn7eu0kT8Oz5jIbiUQAAN1ud2y9Vquh1+shm82aGGumWHMy4/E40uk0qtUqlpaWEIvF4DgOGo0GAPiO6fc3+e0Hc99n5nJrcCrTf/6kNSczGAzi6OgIqVQKOzs72NraQiQSwe7uLubm5vThx4eA7Y8o3dzcxNnZGdrt9lT3NXky790GXj6e/r7WnMy/abVa+nvpk9UxB4MBut2ubhb4ZM0HoD9ZWFjAzc2N6TFmhtUnUyajmEQUk4hiElFMIopJRDGJWP1/5r8UW+R7b+vvzYp/uswSUUwiiklEMYkoJhHFJKKYRBSTiGISUUwiiklEMYkoJhHFJKKYRBSTiGISUUwi3wHdC54Fc5QnQAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create superposition |+> state\n", + "qc_plus = QuantumCircuit(1)\n", + "qc_plus.h(0)\n", + "qc_plus.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sampler Primitive\n", + "\n", + "First use the `Sampler` to measure qubits in the $Z$-basis (the physical basis in which qubits are measured). The `Sampler` will count the number of outcomes of the $|0\\rangle$ state and $|1\\rangle$ state, normalized by the number of shots (experiments performed). The `Sampler` also offers the ability to easily perform error mitigation (which is covered in Lab 5), which modifies this calculation, and hence the outcomes are refered to as *quasi-probabilities*.\n", + "\n", + "Measurments must be present in the circuit when using the `Sampler` primitive. Then the `Session` context is opened, the `Sampler` is instantiated, and `sampler.run()` is used to send the circuits to the backend, similar to the `backend.run()` syntax you may already be familiar with." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "qc_1.measure_all()\n", + "qc_plus.measure_all()\n", + "\n", + "sampler = Sampler()\n", + "job_1 = sampler.run(qc_1)\n", + "job_plus = sampler.run(qc_plus)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{1: 1.0}]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "job_1.result().quasi_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{0: 0.4999999999999999, 1: 0.4999999999999999}]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "job_plus.result().quasi_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAEyCAYAAAD3BqoNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtLklEQVR4nO3deVRV9f7/8ReCSk5lmoCzhTnkdbhpDt9UGijR64B9Qyln04TrFGWaOZf4LU3lmty+aqKSkZqXaw4k6hWjED3401qOiYqmDIrSdQBUcP/+8Nu5EYgH5HBw+3ys9VmL89mfvc/7eBabl/t8zv44STIEAABgIuUcXQAAAEBJI+AAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTcXF0AY50/vx5nT592tFlAADKkAYNGqhWrVrWx9WrV9f48ePVsGFDOTk5ObAy/MYwDCUlJWnhwoXKyMi487gHtVksFofXQKPRaLSy1f74t2HmzJlGz549DWdnZ4fXRrvdnJ2djV69ehkzZ8684xg+ogIAoBANGzbUli1blJub6+hS8H9yc3O1efNmNWzY8I5jCDgAyqxjx44pNzdXWVlZdxyzf/9+Xb9+XZmZmfL39y/F6vCgcHJyItyUQbm5uYV+ZEjAAVBmLVq0SAMGDLjj9qlTp6pOnTqqWLGiRo8erSVLlpRidQDKMgIOgDLr008/1ZkzZ+64vX///vrqq68kScuXL1eFChXUsmXL0ioPKNN27typ4cOHO7oMh3mgv0UF4P5Wo0YNHTlyxPr46tWratmypX766ScHVoUHQeKT0+16fM+fZ9o07tSpU3Jzc1Nubq6uXbumqKgojR49WteuXbNLXQ8//LDmz5+v7t27q3LlykpJSdHy5cv10UcfSZIMw5Cnp6dOnDhh0/F27typL774Qp9//nmJ18oVHAAA7mM9e/ZU1apV9ec//1lt27bVlClT7PZcCxYsUJUqVdSsWTM9/PDD6tWrlxITE+32fPeCgAPgvnXx4kU1a9bM+rhKlSpcvcEDKzk5WVFRUWrRokW+bdOnT1d4eLj1cYMGDWQYhpydnSVJgwcP1okTJ3T58mWdPHlSr732WoHP0a5dO3355Zf69ddfZRiGjh07pvXr10uSdu3aJUn68ccfdeXKFfn5+emRRx7Rxo0bdf78eV26dEkbN25UnTp1JEkffvihOnfurE8//VRXrlzRokWLJElNmjRRdHS0Ll68qKNHj+rVV18t1r8HAQfAfWvt2rXq37+/JGnYsGG6ceMGAQcPrLp166p79+7av39/kfarVKmS/va3v8nHx0fVqlVTp06ddODAgQLHxsfHa/bs2RoyZIg8PT3zbOvataskqVWrVqpatarWrl2rcuXKKSwsTA0aNFD9+vWVlZWlTz/9VJI0ZcoUxcbGavTo0apatarGjBmjSpUqadu2bfryyy9Vq1Yt9e/fX6GhoXn+I2MrAg6AMispKUm7du1SxYoVdfPmTS1fvlxffPGFvvjiC0nSzJkzlZqaqhs3bmjx4sUKCAhwcMVA6fvnP/+pjIwMff/999q1a5eCg4OLfIxbt26pRYsWcnV1VWpqqg4fPlzguDFjxmj16tUaPXq0Dh8+rOPHj6tbt253PO6lS5f0j3/8Q1lZWbp69apmz55tDUIF+ctf/qKkpCStWLFCubm5OnDggNavX1+sqzhMMgZQZhV2E6/f8K0pPOj69OmjHTt2FHv/zMxM9evXT++8844+//xz/fDDD3r77bd17NixfGOzs7M1Z84czZkzR1WrVtWkSZO0bt061a9fv8AlEx566CEtWLBA3bp1U/Xq1SVJ1apVU7ly5XTr1q184xs0aKD27dvnOZaLi0uej9dsxRUcAABM7tq1a6pUqZL1sbu7e57t0dHReumll+Th4aGjR49q6dKldz3mlStXFBwcrCpVqqhRo0YFjnn77bfVpEkTtW/fXg8//LC6dOkiSdYb9BmGkWf8L7/8ol27dql69erWVrVqVQUGBhbp9UoEHAAATO/AgQPq0qWL6tWrp2rVqum9996zbqtVq5Z69eqlSpUq6fr167p69WqBV1ek2/Nm2rZtq/Lly6tixYoaN26cMjIyrFd7UlNT9fjjj1vHV61aVVlZWfr1119VvXp1TZ+e9+v1aWlpecZv2rRJTz75pAYMGCAXFxe5uLiobdu2atq0aZFfMwEHAACT2759u9asWaOffvpJ+/bt06ZNm6zbypUrp6CgICUnJ+vSpUvq2rXrHeezGYahsLAwpaenKzk5Wd7e3urRo4f1vjszZszQypUrlZGRoVdffVULFy7UQw89pPT0dMXHx+vbb7/Nc7yQkBD993//ty5duqSQkBBdvXpVL730kvr376/k5GSlpqbqo48+UsWKFYv1uh2+KqijGquJ02g0Gu2P7Y9/G1atWuXwmmgFt8LeG67gAAAA0yHgAAAA0yHgAAAA0yHgAAAA0ynVgNO5c2dt2LBBZ8+elWEYGjx48F33adGihWJiYpSZmamzZ89q6tSp+cb07dtXhw4dUnZ2tg4dOqQ+ffrYoXoAwIPo92s2oexwdnbOdx+d3yvVgFOlShUdPHhQ48aNU2Zm5l3HV61aVdu2bVNaWpratWuncePGacKECQoKCrKO6dChg9asWaPVq1erdevWWr16tdatW6dnnnnGni8FAPCASEpKUo8ePQg5ZYizs7N69OihpKSkO45x0u2vU5W6K1euaPTo0Vq5cuUdx4waNUofffSR3NzclJ2dLUl6//33FRAQoLp160qSvvrqKz366KN66aWXrPtt27ZNFy5cuONqqL+xWCxq165dCbwaAIBZ/PFvQ/Xq1TV+/Hg1bNjQegdeOJZhGEpKStLChQsLXCJCKuNrUXXs2FGxsbHWcCNJW7du1YcffqiGDRsqKSlJHTt2tC6x/vsxo0ePLu1yAQAmlJGRke8OvCj7yvQkY3d3d6WlpeXp++3xb+to3GnMH9fZAAAAD44yfQXHHkaMGKGRI0dKkho1aiSLxSJJWrRokY4cOaLQ0FBJUmxsrCZMmKD4+HhJtxcq8/LyUlhYmFq0aCFJ8vf3l4+PjwYNGiRJmjt3rlJSUjR//nxJtz8qmz17tmJiYiRJ6enp8vHxUUREhDw9PSVJvr6+8vf3l5+fnyRp1qxZys7Oti53v3HjRoWGhioqKkqSdPbsWfn6+ioyMtL6MZ2Pj48CAwPVs2dPSdLkyZPl6uqqadOmSZLWrl2riIgIRUZGSpISExPl7++vqKgo1axZU5Lk5eWl999/X97e3pKkoKAgeXh4aMKECZKkVatWKSoqShEREZKkgwcPaujQoYqJiVHlypUl3Z4PNXfuXHXu3FmSFBgYqGbNmmnMmDGSpCVLlmj37t0KCwuTdPsycGBgoOLj4+Xs7Kzc3Fx16NBBoaGh1svDQ4cOVceOHa3vGe+T/d6nCm3u/HEx7t3l3f34fbpPfp9gDmV6Ds7KlStVo0YN/eUvf7H2tW3bVhaLRY0aNVJSUpJOnz6tRYsWad68edYx77zzjkaPHq2GDRsWWgNzcID/eGOBQ04FD4xlbzF3437B3wZzKNMfUe3evVudO3fOs8iWt7e3zp07Z505vXv3bmv6/v2YuLi40iwVAACUIaUacCpXrqxWrVqpVatWKleunOrXr69WrVqpXr16kqTg4GBt377dOv7LL79UZmamVqxYoaeeekq+vr6aNGmS9VKodHsl0ueff14TJ05UkyZNNGnSJD333HNauHBhab40AABQhpRqwGnbtq0OHDigAwcOqFKlSpo1a5YOHDigWbNmSZI8PDz0xBNPWMdfvnxZ3t7eql27thISErR48WJ98skneQLO7t271b9/fw0ZMkQ//fSTBg0apH79+mnv3r2l+dIAAEAZ4rA5OGUBn7MC/8EcHPtiDs79g78N5lCm5+AAAAAUBwEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYDgEHAACYjs0Bp3fv3ipXjjwEAADKPpsTy+rVq3Xu3Dn9z//8jxo3bmzPmgAAAO6JzQHH3d1d06dPV9euXXXkyBHFxsZqyJAhqlSpkj3rAwAAKDKbA87Vq1e1ZMkSdezYUS1bttSePXs0Z84cpaSkaMmSJWrfvr096wQAALBZsSbVHD58WAsWLNCSJUtUoUIF9evXT7GxsYqPj9ef/vSnQvcNCAjQyZMnlZWVpYSEBD377LN3HBsWFibDMPK1q1evWsd07dq1wDFNmjQpzksDAAAmUKSA4+LioldffVVRUVE6deqUnn/+eY0aNUpubm5q0KCBjhw5ojVr1txxfz8/P4WEhCg4OFht2rRRXFycoqKiVK9evQLHjxs3Tu7u7nnaiRMntHbt2nxjmzdvnmfc8ePHi/LSAACAibjYOvBvf/ub/P39ZRiGwsPDFRQUpCNHjli3p6SkaNKkSUpOTr7jMYKCgrRixQotW7ZMkjR27Fh169ZNAQEBmjx5cr7xly9f1uXLl62PO3XqpCeeeEIDBw7MN/b8+fO6ePGirS8HAACYmM1XcJo3b67Ro0erTp06evvtt/OEm9+kp6frueeeK3D/8uXL6+mnn1Z0dHSe/ujoaHXq1MmmGkaMGKGDBw9q9+7d+bYlJCQoOTlZ27dvl5eXl03HAwAA5mTzFZyZM2cqLi5Oubm5efqdnZ3VqVMnxcbGKjc3V999912B+9esWVMuLi5KS0vL05+WlqYXX3zxrs9frVo1+fn56b333svTn5KSolGjRslisahChQoaOHCgduzYoa5du+r777/Pd5wRI0Zo5MiRkqRGjRrJYrFIkhYtWqQjR44oNDRUkhQbG6sJEyYoPj5eknTt2jV5eXkpLCxMLVq0kCT5+/vLx8dHgwYNkiTNnTtXKSkpmj9/viRp27Ztmj17tmJiYiTdDoA+Pj6KiIiQp6enJMnX11f+/v7y8/OTJM2aNUvZ2dkKDg6WJG3cuFGhoaGKioqSJJ09e1a+vr6KjIxU3bp1JUk+Pj4KDAxUz549JUmTJ0+Wq6urpk2bJklau3atIiIiFBkZKUlKTEyUv7+/oqKiVLNmTUmSl5eX3n//fXl7e0u6fbXNw8NDEyZMkCStWrVKUVFRioiIkCQdPHhQQ4cOVUxMjCpXrixJ6tChg+bOnavOnTtLkgIDA9WsWTONGTNGkrRkyRLt3r1bYWFhkiSLxaLAwEDFx8fL2dlZubm56tChg0JDQ9WuXTtJ0tChQ9WxY0fre8b7ZL/3Cfbl5+fH79N98vsEc3CSZNgyMCcnRx4eHrpw4UKe/kcffVTnz5+Xi0vhWcnDw0PJycnq0qWLYmNjrf1Tp07V66+/rqZNmxa6f2BgoD755BPVrl1bGRkZhY7dvHmzcnJy1Lt370LHWSwW6y8+8KB7Y4FNpwIU07K3nBxdAmzE3wZzsPkjKicnJxlG/hNgjRo1dO3atbvun56erpycHLm5ueXpd3NzU2pq6l33HzFihNavX3/XcCNJe/bs4WaEAAA8wO76EdWGDRskSYZh6IsvvtD169et25ydndWiRQvFxcXd9Ylu3rypffv2ydvbW19//bW139vbW+vXry9033bt2ql169YaP378XZ9Hklq3bq2UlBSbxgIAAPO5a8D57ZtJTk5OysjIUFZWlnXbjRs39P3332vp0qU2Pdn8+fMVHh6uvXv36ocfftCoUaNUu3ZtffbZZ5KklStXSpIGDx6cZ7+RI0fq559/1q5du/Idc9y4cUpKStKhQ4dUoUIFDRgwQL6+vurbt69NNQEAAPO5a8AZNmyYJCkpKUnz5s1TZmZmsZ9s7dq1qlGjhqZMmSIPDw8dPHhQ3bt315kzZyRJ9evXz7dPlSpV1L9/f82aNavAY1aoUEFz585V3bp1lZWVpUOHDql79+7WyWkAAODBY/MkYzNiIhnwH0wyti8mGd8/+NtgDoVewfnxxx/VtWtX/frrr/rpp58KnGT8m1atWpV4cQAAAMVRaMBZv369dVLx7ycGAwAAlGWFBpzfz3u50xwYAACAsqZYq4kDAACUZYVewbnbvJvfYw4OAAAoKwoNOMy7AQAA9yOb5+AAAADcL5iDAwAATIf74AAAANPhPjgAAMB0uA8OAAAwnbsutvlHjz/+uJo1ayZJOnLkiE6ePFniRQEAANwLmwPOo48+qs8//1y9evXSrVu3JElOTk7atGmThg0bpkuXLtmtSAAAgKKw+VtUy5Ytk6enpzp37ixXV1e5urqqS5cuatSokZYuXWrPGgEAAIrE5is4L7/8sl544QXFx8db++Li4vTmm29q+/btdikOAACgOGy+gnPhwgVdu3YtX39mZqYuXrxYokUBAADcC5sDzqxZs7Rw4ULVrl3b2le7dm198sknfMMKAACUKUVabLNRo0ZKSkrSuXPnJEl16tRRdna2atWqpc8//9y+lQIAANiIxTYBAIDpsNgmAAAwHRbbBAAApmNzwClfvrxmzJihY8eOKSsrSzk5OXkaAABAWWFzwPnggw80ePBgffLJJ7p165YmTJigxYsX6+LFiwoMDLRnjQAAAEVic8Dx8/PTqFGjtGTJEuXm5mrDhg0aN26cpk+fLm9vb3vWCAAAUCQ2Bxw3NzcdPnxYknT16lU98sgjkqRvv/1WL730kl2KAwAAKA6bA86ZM2esN/lLTEzUyy+/LEnq2LGjsrKy7FMdAABAMdgccCIjI/XCCy9IkkJCQjRz5kydPHlSK1as0LJly+xWIAAAQFHZvNjm5MmTrT+vX79enTt3VqdOnfTzzz9r8+bNdikOAACgOGwOOH+0Z88e7dmzpyRrAQAAKBFFutFfmzZttHLlSlksFlksFq1atUpt2rSxV20AAADFYnPAee2112SxWOTh4aEtW7Zoy5YtcnNz0969e/X666/bs0YAAIAisfkjqtmzZ2vq1KmaM2dOnv5Jkybpww8/1OrVq0u8OAAAgOKw+QrOY489prVr1+brX7dunWrVqlWiRQEAANwLmwPOzp075eXlla/fy8tLu3btKsmaAAAA7kmhH1H5+vpaf46KitKcOXPUtm1bxcfHS5I6dOigvn37asaMGXYtEgAAoCicJBl32pibm2vTQQzDkItLsb9x7jAWi0Xt2rVzdBlAmfDGgjueClAClr3l5OgSYCP+NphDoanE2dm5tOoAAAAoMUW6Dw4AAMD9oEgBp3v37tq1a5cuXLig8+fPKyYmRj4+PvaqDQAAoFhsDjjDhw9XZGSkTpw4oYkTJ2rSpEk6deqUIiMjNXToUHvWiGJ6+eWXdfToUR0/flwTJ07Mt33w4ME6f/689u/fr/3792v48OEOqBKAI3GegFnZPDN44sSJCgoK0uLFi619y5cv1759+zRp0iSFhYXZpUAUT7ly5bR48WJ5e3vr7Nmzslgs+uabb3TkyJE849asWaMxY8Y4qEoAjsR5AmZm8xWc+vXr69tvv83XHxUVpQYNGpRoUbh3zzzzjBITE3Xq1CndvHlTX331lXr37u3osgCUIZwnYGY2B5wzZ87I29s7X/9LL72k06dPl2hRuHd16tTRL7/8Yn189uxZ1alTJ9+4V155RT/++KPWrVununXrlmaJAByM8wTMzOaPqObNm6dFixbpz3/+s+Li4iRJ//Vf/6WBAwdy6fI+tXHjRkVEROjGjRsaOXKkVq5cqRdeeMHRZQEoQzhP4H5lc8BZsmSJzp8/r7ffflt9+/aVJB05ckR+fn765ptv7FYgiufcuXOqV6+e9XHdunV17ty5PGMuXbpk/XnZsmX6+OOPS60+AI7HeQJmZlPAcXFx0ezZs7V48WJ17tzZ3jWhBFgsFjVu3FgNGzbUuXPn1L9/f7322mt5xri7uys1NVWS1KtXr3wTCwGYG+cJmJlNAScnJ0eBgYEKDQ21dz0oIbm5uRo9erS2bt0qZ2dnLV++XIcPH9bMmTOVkJCgjRs3auzYserVq5dycnJ06dIlDRkyxNFlAyhFnCdgZoWuRfV7X3/9tTZv3myqr4Oz3gjwH6xFZV+sRXX/4G+DOdg8B2fHjh0KDg5Wy5YttW/fPl27di3P9sjIyBIvDgAAoDhsDjiffvqpJGns2LH5tt2vq4kDAABzsjmVsLI4AAC4X5T6auIBAQE6efKksrKylJCQoGefffaOY7t27SrDMPK1Jk2a5BnXt29fHTp0SNnZ2Tp06JD69Olj51cBAADKsiIFnN69e1tXE79w4YK+++67IoUJPz8/hYSEKDg4WG3atFFcXJyioqLy3IehIM2bN5e7u7u1HT9+3LqtQ4cOWrNmjVavXq3WrVtr9erVWrdunZ555pmivDQAAGAiNgecoKAgrVmzRseOHdO7776rd999V0ePHtWXX36pt99+2+ZjrFixQsuWLdPRo0c1duxYpaSkKCAgoND9zp8/r7S0NGu7deuWddv48eO1c+dOBQcH6+jRowoODlZMTIzGjx9v60sDAAAmY3PAeeeddzR69GiNHDlSYWFhCgsL08iRIzV27FibAk758uX19NNPKzo6Ok9/dHS0OnXqVOi+CQkJSk5O1vbt2+Xl5ZVnW8eOHfMdc+vWrXc9JgAAMC+bJxlXqVJFO3fuzNe/c+dOValS5a7716xZUy4uLkpLS8vTn5aWphdffLHAfVJSUjRq1ChZLBZVqFBBAwcO1I4dO9S1a1d9//33km7fZbOgY7q7uxd4zBEjRmjkyJGSpEaNGslisUiSFi1apCNHjlhvZhgbG6sJEyYoPj5eknTt2jV5eXkpLCxMLVq0kCT5+/vLx8dH47Y+etfXj3uTsfovku7tfRo0aJAkae7cuUpJSdH8+fMlSdu2bdPs2bMVExMjSUpPT5ePj48iIiLk6ekpSfL19ZW/v7/8/PwkSbNmzVJ2draCg4Ml3V6vJzQ0VFFRUZJuL1ro6+uryMhI6+KEPj4+CgwMVM+ePSVJkydPlqurq6ZNmyZJWrt2rSIiIqy3XEhMTJS/v7+ioqJUs2ZNSZKXl5fef/9968K3QUFB8vDw0IQJEyRJq1atUlRUlCIiIiRJBw8e1NChQxUTE6PKlStLuv2x7ty5c613JQ8MDFSzZs3u/U1CoRKfnO7oEkzvrSb/r0R+n2AONt/ob9WqVTp06JA++uijPP3vvvuuWrZsqQEDBhS6v4eHh5KTk9WlSxfFxsZa+6dOnarXX39dTZs2tangzZs3KycnR71795YkXb9+XW+88YbCw8OtYwYOHKilS5fK1dW10GOV1M2cOHHZn+fPMx1dgulxoz/7mvT3GY4uwfRK6jzBjf7MweYrOImJiZo0aZKee+457d69W9Lt/wl26NBB8+fP11tvvWUdu2DBgnz7p6enKycnR25ubnn63dzcrOuc2GLPnj3q37+/9XFqauo9HxMAAJiLzQFnyJAhysjI0JNPPqknn3zS2p+RkaGhQ4daHxuGUWDAuXnzpvbt2ydvb299/fXX1n5vb2+tX7/e5oJbt26tlJQU6+Pdu3fL29tb8+bNy3PMuLg4m48JAADMxeaA8/jjj9/zk82fP1/h4eHau3evfvjhB40aNUq1a9fWZ599JklauXKlJGnw4MGSpHHjxikpKUmHDh1ShQoVNGDAAPn6+qpv377WY4aEhOi7777TxIkT9c9//lO+vr567rnnCr2/DgAAMLdira/QqVMnJSQk6MaNG0Xab+3atapRo4amTJkiDw8PHTx4UN27d9eZM2ckSfXr188zvkKFCpo7d67q1q2rrKwsHTp0SN27d7dO5JRuX8Hp37+/PvzwQ82aNUsnTpxQv379tHfv3uK8NAAAYAI2TzL+vX//+99q3bq1Tp06ZYeSSg+TjO8fTDK2PyYZ2xeTjO2PScb4vWIt1eDk5FTSdQAAAJSYUl+LCgAAwN6KFXDefPPNfDfXAwAAKCuKNcn4t7ukAgAAlEWFBpwNGzZowIABunLlijZs2FDogX67szAAAICjFRpwLl68KMMwrD8DAADcDwoNOMOGDSvwZwAAgLKs2N+icnV11QsvvJDv5nwAAACOZnPACQsLU0BAgCSpfPny2rt3r6Kjo3Xs2DF169bNbgUCAAAUlc0B5+WXX1Z8fLwkqVevXqpatarc3d01Y8YMzZgxw171AQAAFJnNAad69eo6f/68JKlbt25av369Lly4oK+++krNmze3W4EAAABFZXPASU1NVYsWLVSuXDm9/PLL2r59uySpSpUqunnzpt0KBAAAKCqbb/S3fPlyrVmzRsnJycrNzdWOHTskSe3bt9fRo0ftViAAAEBR2RxwPvjgAx06dEj169fXunXrrFdtcnJy9NFHH9mtQAAAgKIq0lIN//jHP/L1rVq1qsSKAQAAKAlFCjjOzs565plnVL9+fVWoUCHPtvDw8BItDAAAoLhsDjhNmjTRxo0b1ahRIzk5OSk3N1cuLi66efOmrl+/TsABAABlhs3folq4cKH27dunhx9+WJmZmWrWrJnatm2rAwcO6JVXXrFnjQAAAEVi8xWcdu3aqWvXrsrMzNStW7fk4uKi/fv3691339WiRYvUqlUre9YJAABgM5uv4Dg5OSkzM1OSdOHCBdWpU0eSdPbsWXl6etqnOgAAgGKw+QrOwYMH1apVK506dUp79+7VxIkTlZubqxEjRigxMdGeNQIAABSJzQFn9uzZqly5siRpypQp2rx5s3bu3Kn09HT5+fnZrUAAAICisjngREdHW38+deqUmjdvrurVqysjI8MuhQEAABSXzXNwCkK4AQAAZZHNV3A2bNhQ6PbevXvfczEAAAAlweaAc/HixTyPy5cvr1atWqlevXoFLuEAAADgKDYHnGHDhhXYP2/ePF2+fLnECgIAALhX9zQHR5L+93//V3/9619LohYAAIAScc8Bp0mTJiVRBwAAQImx+SOqkJCQPI+dnJzk4eEhHx8fLV++vMQLAwAAKC6bA86f/vSnPI9v3bqlCxcu6K233iLgAACAMsXmgPP888+rWrVqaty4sW7cuKFTp07p6tWr9qwNAACgWGyag1OvXj198803unjxovbs2aP9+/crPT1dX375pR577DHruAoVKtitUAAAAFvd9QpO7dq1FR8fr1u3bmnatGk6fPiwJOmpp55SYGCg4uPj1aZNG3Xu3FlPPfWUPv74Y7sXDQAAUJi7Bpzp06fr1KlTevHFF5WdnW3t37BhgxYsWKDo6Gh98803euaZZzRw4EC7FgsAAGCLuwac7t276/XXX88Tbn6TlZWlKVOm6F//+pfGjBmj9evX26VIAACAorjrHJzHHntMJ06cuOP2xMRE5ebmKjQ0tEQLAwAAKK67Bpzz58/L09PzjtsbN26s1NTUEi0KAADgXtw14ERFRenDDz8s8BtSFStW1AcffKAtW7bYpTgAAIDiuOscnBkzZighIUGJiYn69NNPdfToUUlS8+bNFRgYKGdnZ/n5+dm9UAAAAFvdNeCkpKSoU6dOCg0NVXBwsJycnCRJhmHo22+/1V//+lelpKTYvVAAAABb2XQn49OnT6tHjx565JFH1LhxY0nS8ePH9euvv9qzNgAAgGKxeakGSfr1119lsVjsVQsAAECJsGmpBgAAgPsJAQcAAJgOAQcAAJgOAQcAAJgOAQcAAJgOAQcAAJgOAQcAAJgOAQcAAJhOqQecgIAAnTx5UllZWUpISNCzzz57x7G+vr7aunWrzp8/r8uXLys+Pl49e/bMM2bw4MEyDCNfq1ixor1fCgAAKKNKNeD4+fkpJCREwcHBatOmjeLi4hQVFaV69eoVOL5r167617/+pR49eqhNmzbasmWLIiMj84Wia9euyd3dPU+7fv16abwkAABQBhVpqYZ7FRQUpBUrVmjZsmWSpLFjx6pbt24KCAjQ5MmT840fP358nsezZs1Sjx491KdPH33//ffWfsMwlJaWZtfaAQDA/aPUruCUL19eTz/9tKKjo/P0R0dHq1OnTjYfp2rVqsrIyMjT99BDDykpKUm//PKLNm7cqNatW5dEyQAA4D5ValdwatasKRcXl3xXWtLS0vTiiy/adIzAwEDVrVtX4eHh1r5jx45p2LBh+vHHH1W1alWNGzdOP/zwg1q1aqXExMR8xxgxYoRGjhwpSWrUqJF18dBFixbpyJEjCg0NlSTFxsZqwoQJio+Pl3T7YzAvLy+FhYWpRYsWkiR/f3/5+PhIW4v4j4EiK4n3adCgQZKkuXPnKiUlRfPnz5ckbdu2TbNnz1ZMTIwkKT09XT4+PoqIiJCnp6ek2/PB/P395efnJ+n21cTs7GwFBwdLkjZu3KjQ0FBFRUVJks6ePStfX19FRkaqbt26kiQfHx8FBgZa55FNnjxZrq6umjZtmiRp7dq1ioiIUGRkpCQpMTFR/v7+ioqKUs2aNSVJXl5eev/99+Xt7S3p9lVRDw8PTZgwQZK0atUqRUVFKSIiQpJ08OBBDR06VDExMapcubIkqUOHDpo7d646d+4s6fbvVbNmze79TQIcrGfPniXy+wRzcJJklMYTeXh4KDk5WV26dFFsbKy1f+rUqXr99dfVtGnTQvfv27evwsPD1a9fP23atOmO48qVK6cDBw5o586dGjduXKHHtFgsateuXdFeSAESn5x+z8dA4Tx/nunoEkzvjQWlcip4YE36+wxHl2B6JXWeKKm/DXCsUvuIKj09XTk5OXJzc8vT7+bmptTU1EL3feWVVxQeHq5BgwYVGm4k6datW0pISFDjxo3vuWYAAHB/KrWAc/PmTe3bt896KfA33t7eiouLu+N+r776qsLDwzVkyBCtX7/epudq2bKlUlJS7qleAABw/yrVb1HNnz9f4eHh2rt3r3744QeNGjVKtWvX1meffSZJWrlypaTb97aRpH79+ik8PFzvvPOOvvvuO+vVnxs3blgnGk+bNk3x8fE6fvy4qlWrprFjx6ply5YKCAgozZcGAADKkFINOGvXrlWNGjU0ZcoUeXh46ODBg+revbvOnDkjSapfv36e8aNGjVL58uUVEhKikJAQa39MTIyee+45SdIjjzyiJUuWyN3dXf/+97+1f/9+denSxTopFQAAPHhKNeBI0t///nf9/e9/L3Dbb6HlTo8LEhQUpKCgoBKpDQAAmANrUQEAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMp9YATEBCgkydPKisrSwkJCXr22WcLHd+lSxclJCQoKytLJ06c0JtvvnnPxwQAAOZWqgHHz89PISEhCg4OVps2bRQXF6eoqCjVq1evwPENGzbUli1bFBcXpzZt2mjOnDlatGiR+vbtW+xjAgAA8yvVgBMUFKQVK1Zo2bJlOnr0qMaOHauUlBQFBAQUOH7UqFFKTk7W2LFjdfToUS1btkwrV67UO++8U+xjAgAA8yu1gFO+fHk9/fTTio6OztMfHR2tTp06FbhPx44d843funWr2rZtKxcXl2IdEwAAmF+pBZyaNWvKxcVFaWlpefrT0tLk7u5e4D7u7u4Fji9fvrxq1qxZrGMCAADzc3F0AaVtxIgRGjlypCSpSZMmslgs93xM55o1lZ6efs/HwZ1Z9BdHl/AASHB0Aabm3GcI5wk7K6nzRIMGDUrkOHCsUgs46enpysnJkZubW55+Nzc3paamFrhPampqgeNv3ryp9PR0OTk5FfmYS5cu1dKlS+/hleRnsVjUrl27Ej0mAHPhPAGUrlL7iOrmzZvat2+fvL298/R7e3srLi6uwH12795d4PiEhATl5OQU65gAAODBYJRW8/PzM65fv24MHz7caNq0qbFw4ULjypUrRv369Q1JxsqVK42VK1daxzds2NC4evWqsWDBAqNp06bG8OHDjevXrxt9+/a1+Zil0SwWS6k9F41Guz8b5wkardRb6T5hQECAcerUKSM7O9tISEgwOnfubN22c+dOY+fOnXnGd+nSxdi3b5+RnZ1tnDx50njzzTeLdMzSaCNGjHD0m0ij0cp44zxBo5Vuc/q/HwAAAEyDtagAAIDpEHAAAIDpEHAAAIDpEHCKydPTU7Vq1XJ0GQAAoAAP3J2M78Vjjz2mgQMH6q233tKFCxeUk5OjlJQUff3111q/fr0yMzMdXSIAAJDEt6iKICwsTM2bN9emTZt08eJF1ahRQ61bt1azZs109uxZffzxx9q+fbujywTgYFWrVtWVK1ccXQbwQCPgFMGVK1fUvXt3xcbGWvvq1q2rDh06aMSIEWrQoIH69eunH3/80YFVAnC0zz77THv37tXevXt1+vTpAsPOo48+qkuXLjmgOuDB4fCb8dwPrXnz5sZPP/1ktG/fvsDt5cuXNywWixEcHOzwWmk0muNa//79jdzcXCMjI8M4ceKE8dlnnxl9+vQxHn/8ccPV1dWQZLi6uhqRkZFGixYtHF4vjWbWxhUcG7m6umrTpk2qVKmSBg0apBMnTsgw8v7TjR49WsOHD1ebNm0cVCUAR1uyZIlyc3P18ccfq2/fvho8eLCeeOIJHTt2TFu2bNGOHTvUpEkThYSEqGLFio4uFzA1h6es+6W1b9/e2L9/vxEXF2cMHjzYqFu3rlG5cmVDkvHQQw8Z69atM8LDwx1eJ41Gc0xzdnY23nvvPWPOnDl5+ps3b24sWLDA+OWXX4wLFy4YN2/eNJYtW+bwemk0kzeHF3Bftaeeesr46quvjMzMTOPChQvGN998Y3z++efG6dOnjfj4eC4502gPeHvkkUeMJk2aGNLtj67/uN3Pz8/Izc01WrVq5fBaaTQzNz6iKqbHHntMPXr0UJ8+fZSdna2DBw9q3bp1OnbsmKNLA1DGODk5ycnJSbdu3dIbb7yhkJAQVa5c2dFlAaZGwCkBTk5O+ebjAEBB3nrrLTk7O2vevHmOLgUwNQIOAJQiFxcX5ebm8p8iwM4IOAAAwHRYiwoAAJgOAQcAAJgOAQcAAJgOAQcAAJgOAQcAAJgOAQcAAJjO/wef0px1Du4O1AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "legend = [\"Excited State\", \"Plus State\"] # TODO: Excited State does not appear\n", + "plot_histogram([job_1.result().quasi_dists[0], job_plus.result().quasi_dists[0]], legend=legend)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The result for the excited state is always $|1\\rangle$ wheres it is roughly half $|0\\rangle$ and half |1\\rangle$ for the plus superposition state. This is because the $|0\\rangle$ and $|1\\rangle$ states are *eigenstates* of the $Z$ operator (with $+1$ and $-1$ eigenvalues, respectively).\n", + "\n", + "Let's switch and measure in the $X$ basis. Using the `Sampler` we must rotate the qubit from the $X$-basis to the $Z$-basis for measurement (because that is the only basis we can actually perform measurement in)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "qc_1.remove_final_measurements()\n", + "qc_plus.remove_final_measurements()\n", + "\n", + "# rotate into the X-basis\n", + "qc_1.h(0)\n", + "qc_plus.h(0)\n", + "\n", + "qc_1.measure_all()\n", + "qc_plus.measure_all()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "sampler = Sampler()\n", + "job_1 = sampler.run(qc_1)\n", + "job_plus = sampler.run(qc_plus)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_histogram([job_1.result().quasi_dists[0], job_plus.result().quasi_dists[0]], legend=legend)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we see the opposite: the plus superposition always give the 1 result, hence an eigenstate of the $X$ operator, whereas the excited $|1\\rangle$ yields a roughtly fifty-fifty split. The $|+\\rangle$ and $|-\\rangle$ states are eigenstates of the $X$ operator, with eigenvalues $+1$ and $-1$, respectively. This is good to remember when considering how the `Estimator` works in the next subsection. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Estimator Primitive\n", + "\n", + "The Qiskit Runtime Primitives allow us to abstract measurement into the `Estimator` primitive, where it is specified as an *observable*. In particular, we can construct the same circuits, the excited $|1\\rangle$ and superposition $|+\\rangle$ as before. However, in the case of the `Estimator`, we *do not* add measurements to the circuit. Instead, specify a list of observables which take the form of Pauli strings. In our case for a measurement of a single qubit, we specify `'Z'` for the $Z$-basis and `'X'` for the $X$-basis." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "qc2_1 = QuantumCircuit(1)\n", + "qc2_1.x(0)\n", + "\n", + "qc2_plus = QuantumCircuit(1)\n", + "qc2_plus.h(0)\n", + "\n", + "obsvs = list(SparsePauliOp(['Z', 'X']))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "estimator = Estimator()\n", + "job2_1 = estimator.run([qc2_1]*len(obsvs), observables=obsvs)\n", + "job2_plus = estimator.run([qc2_plus]*len(obsvs), observables=obsvs)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EstimatorResult(values=array([-1., 0.]), metadata=[{}, {}])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "job2_1.result()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " | | \n", + "----|------------------\n", + "|1> | -1.0 | 0.0\n", + "|+> | 0.0 | 0.9999999999999998\n" + ] + } + ], + "source": [ + "# TODO: make this into module that outputs a nice table\n", + "print(f' | | ')\n", + "print(f'----|------------------')\n", + "print(f'|1> | {job2_1.result().values[0]} | {job2_1.result().values[1]}')\n", + "print(f'|+> | {job2_plus.result().values[0]} | {job2_plus.result().values[1]}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just as before, we see the $|1\\rangle$ state expectation in the $Z$-basis is $-1$ (corresponding to its eigenvalue) and around zero in the $X$-basis (average over $+1$ and $-1$ eigenvalues), and vice-versa for the $|+\\rangle$ state (although its eigenvalue of the $X$ operators is $+1$)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CHSH Inequality\n", + "\n", + "Imagine Alice and Bob are given each one part of a bipartite entangled system. Each of them then performs two measurements on their part in two different bases. Let's call Alice's bases A and a and Bob's B and b. What is the expectation value of the quantity \n", + "\n", + "$$\n", + "\\langle CHSH \\rangle = \\langle AB \\rangle - \\langle Ab \\rangle + \\langle aB \\rangle + \\langle ab \\rangle ?\n", + "$$\n", + "\n", + "Now, Alice and Bob have one qubit each, so any measurement they perform on their system (qubit) can only yield one of two possible outcomes: +1 or -1. Note that whereas we typically refer to the two qubit states as $|0\\rangle$ and $|1\\rangle$, these are eigenstates, and a projective measurement will yield their eigenvalues, +1 and -1, respectively.\n", + "\n", + "Therefore, if any measurement of A, a, B, and b can only yield $\\pm 1$, the quantities $(B-b)$ and $(B+b)$ can only be 0 or $\\pm 2$. And thus, the quantity $A(B-b) + a(B+b)$ can only be either +2 or -2, which means that there should be a bound for the expectation value of the quantity we have called\n", + "\n", + "$$\n", + "|\\langle CHSH \\rangle| = |\\langle AB \\rangle - \\langle Ab \\rangle + \\langle aB \\rangle + \\langle ab \\rangle| \\le 2.\n", + "$$\n", + "\n", + "Now, the above discussion is oversimplified, because we could consider that the outcome on any set of measurements from Alice and Bob could depend on a set of local hidden variables, but it can be shown with some math that, even when that is the case, the expectation value of the quantity $CHSH$ should be bounded by 2 if local realism held.\n", + "\n", + "But what happens when we do these experiments with an entangled system? Let's try it!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first step is to build the observable\n", + "$$\n", + "CHSH = A(B-b) + a(B+b) = AB - Ab + aB +ab\n", + "$$\n", + "where $A, a$ are each one of $\\{IX, IZ\\}$ for qubit 0 and $B, b$ are each one of $\\{XI, ZI\\}$ for qubit 1 (corresponding to little-endian notation). Paulis on different qubits can be composed by specifying order with a Pauli string, for example instantiating a `SparsePauliOp` with the `'ZX'` argument implies a measurement of $\\langle X \\rangle$ on `q0` and $\\langle Z \\rangle$ on `q1` . This *tensor* product (combining operations on *different* qubits) can be explicitly stated using the `.tensor()` method. Additionally, combining operations on the *same* qubit(s) uses the *compositional* product with the `.compose()` method. For example, all these statements create the same Pauli operator:\n", + "\n", + "```\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "ZX = SparsePauliOp('ZX')\n", + "ZX = SparsePauliOp(['ZX'], coeffs=[1.]) # extendable to a sum of Paulis\n", + "ZX = SparsePauliOp('Z').tensor(SparsePauliOp('X')) # extendable to a tensor product of Paulis\n", + "ZX = SparsePauliOp('XZ').compose(SparsePauliOp('YY')) # extendable to a compositional product of Paulis\n", + "```\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ex 1 - create an operator for CHSH witness" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# this is a correct answer:\n", + "obsv = SparsePauliOp('X').tensor(SparsePauliOp(['X', 'Z'], coeffs=[1, -1])) + SparsePauliOp('Z').tensor(SparsePauliOp(['X', 'Z'], coeffs=[1, 1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grading your answer. Please wait...\n", + "\n", + "Congratulations 🎉! Your answer is correct.\n" + ] + } + ], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab2_ex1\n", + "\n", + "grade_lab2_ex1(obsv)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create Entangled Qubit Pair\n", + "\n", + "Next we want to test the $CHSH$ observable on an entangled pair, for example the maximally-entangled Bell state\n", + "$$\n", + "|\\Phi\\rangle = \\frac{1}{\\sqrt{2}} \\left(|00\\rangle + |11\\rangle \\right)\n", + "$$\n", + "which is created with a Hadamard gate followed by a CNOT with the target on the same qubit as the Hadamard. Due to the simplifaction of measuring in just the $X$- and $Z$-bases as discussed above, we will *rotate* the Bell state around the Bloch sphere which is equivalant to changing the measurement basis as demonstrated in the Warmup section. This can be done by applying an $R_y(\\theta)$ gate where $\\theta$ is a `Parameter` to be specified at the `Estimator` API call. This produces the state\n", + "$$\n", + "|\\psi\\rangle = \\frac{1}{\\sqrt{2}} \\left(\\cos(\\theta/2) |00\\rangle + \\sin(\\theta/2)|11\\rangle \\right)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.circuit import Parameter\n", + "\n", + "theta = Parameter('θ')\n", + "\n", + "qc = QuantumCircuit(2)\n", + "qc.h(0)\n", + "qc.cx(0, 1)\n", + "qc.ry(theta, 0)\n", + "\n", + "qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we need to specify a `Sequence` of `Parameter`s that show a clear violation of the CHSH Inequality, namely \n", + "$$\n", + "|\\langle CHSH \\rangle| > 2.\n", + "$$\n", + "Let's make sure we have at least three points in violation." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ex 2 - Create a Parameterization (i.e., list, array) of the angle in the above circuit (in radians)\n", + "\n", + "Hint: Note the `type` for the `parameter_values` argument is `Sequence[Sequence[float]]`." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# this is a correct answer\n", + "num_params = 21\n", + "angles=[[angle] for angle in np.linspace(-np.pi, np.pi, num_params)]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test your angles and observable by running with the `Estimator` before submitting to the grader." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "estimator = Estimator()\n", + "job = estimator.run([qc]*len(angles), observables=[obsv]*len(angles), parameter_values=angles)\n", + "exps = job.result().values\n", + "\n", + "plt.plot(angles, exps, marker='x', ls='-', color='green')\n", + "plt.plot(angles, [2]*len(angles), ls='--', color='red', label='Classical Bound')\n", + "plt.plot(angles, [-2]*len(angles), ls='--', color='red')\n", + "plt.xlabel('angle (rad)')\n", + "plt.ylabel('CHSH Witness')\n", + "plt.legend(loc=4)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Did you see at least 3 points outside the red dashed lines? If so, you are ready to send to the grader!" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grading your answer. Please wait...\n", + "\n", + "Congratulations 🎉! Your answer is correct.\n" + ] + } + ], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab2_ex2\n", + "\n", + "grade_lab2_ex2(obsv, angles)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Teleportation\n", + "\n", + "Quantum information cannot be copied due to the *No Cloning Theorem*, however it can be \"teleported\" in the sense that a qubit can be entangled with a quantum resource, and via a protocol of measurements and *classical communication* of their results, the original quantum state can be reconstructed on a different qubit. This process destroys the information in the original qubit via measurement.\n", + "\n", + "In this exercise, we will construct a particular qubit state and then transfer that state to another qubit using the teleportation protocol. Here we will be looking at specific classical and quantum registers, so we need to import those." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit import ClassicalRegister, QuantumRegister" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the circuit\n", + "\n", + "Define an angle $\\theta$ to rotate our qubit by. This will allow us to easily make comparisons for the original state and the teleported state." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEbklEQVR4nO3dX0ybVRjH8V/70lAY4KgNaYYXlhS6UCwR5p8oWHDT4aKTxUCEhSghgpVkCywx2R+iGdolBJ0XKl4wbUyEJWAjCRanmbTDsGkqcaFO1zhQ0sgylSDU1T8UvCCrqdWsNc3O8eH5JL1529CHfHPO+9I2RbW2trYGRoJa9AAsdTgmIRyTEI5JCMckhGMSwjEJ4ZiEcExCOCYhHJMQjkkIxySEYxLCMQnhmIRwTEI4JiEckxCOSQjHJIRjEsIxCeGYhHBMQjgmIRyTkDTRA4hy8WNg+YqY587OA8z3p/7nbtiYy1eAxaDoKVKLt1lCOCYhHJOQDXvOTNSBvip89d1ZKIoGarUCQ64RjdsPw1ZaJ3q0OBwzAXt3dGHvjiOIRFYwMvkqjg00wpR/O/L1JtGjxeBtNgmKkoaH7noKkdUVXPr+C9HjxOGYSfhj5XeMTvYBAG7RFwmeJh7HTMDA6RdR27UZDx/KwFunjqCzrh8FW6wAAMc7jTh3YTT62OectfBd/FDInNLFXF1dRW9vLwoLC6HValFaWgqv1wuz2YzW1lYhMzVuP4z3uhcx/PyPuHPrLpz/Zjx6n/3RV+A81YXwbyFMTLuwSXsTtpkfFDKndDFbWlrQ3d2NtrY2jI2Nob6+Hg0NDZiZmUF5ebnQ2bIzc9FZ149Pv34fk/4RAEBuVh72VOzHayP7MHD6BTy9+7iw+aS6mh0cHITT6YTH44HNZgMAVFdXY2pqCi6XC2VlZYInBHIydXisshNvfnAIdxc/ArVajZ13PImxz/pRe+8+5GTqhM0m1cp0OByoqamJhrzGZDJBo9HAarUKmizWnsr9WFiax0efvx09tuVmk/A/VaRZmcFgEH6/Hx0dHXH3zc3NwWKxID09/YbP9ZLdE3dskzYHrqMLN3yW65FmZQaD629hGAyGmOPhcBherzfhLValUiV083o9qf4VEub1ehKeMxnSxNTr9QCAQCAQc7ynpwfz8/PCL36u59nHnSgxVgidQZpttqCgAFarFQ6HAzqdDvn5+RgeHobb7QaAhGMm+r2OvpPi3s+02aqw1pf675+UZmWq1WoMDQ3BYrHAbrejubkZer0e7e3tUBRFmosfmUmzMgGgqKgI4+PjMceamppQXFyMjIwMQVP9f0izMv+Nz+eT7nx5wn0Qna/fhxPug6JHiSF1zFAohEAgIMWLBdfMXvbjl1+X8PIzZ7B09Sd8e/lL0SNFSbXN/l1WVhYikYjoMWL4Zz/BtqL1117LCh/A9OwEbjVYBE+1TuqYMlq+uoDRs2/g3YnjCIUXYSutFz1SFMdMUnamDk/sPIp7LLtx7sIofvhZns9rSn3OlFGJsQLTM2cAAOcveXCbsVLwRH/hmEkyGkqQpmhwoK8KaYpGmvMlwNvsf9Ky65joEf4Rr0xCOCYhG3abzc6j99wq/vdRdPA2SwjHJIRjEsIxCeGYhHBMQjgmIRyTEI5JCMckhGMSwjEJ4ZiEcExCOCYhHJMQjkkIxyTkTxqrDTVZhEfTAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "theta = Parameter('θ')\n", + "\n", + "qr = QuantumRegister(1, 'q')\n", + "qc = QuantumCircuit(qr)\n", + "qc.ry(theta, 0)\n", + "qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alice possesses the quantum information $|\\psi\\rangle$ in the state of $q$ and wishes to transfer it to Bob. The resource they share is a special entangled state called a Bell state\n", + "$$\n", + "|\\Phi^+\\rangle = \\frac{1}{2} \\left( |00\\rangle + |11\\rangle \\right)\n", + "$$\n", + "with the first of the pair going to Alice and the second to Bob. Hence Alice has a 2-qubit register ($q$ and $Bell_0$) and Bob has a single-qubit register ($Bell_1$). We will construct the circuit by copying the original `qc` and adding the appropriate registers." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tele_qc = qc.copy()\n", + "bell = QuantumRegister(2, 'Bell')\n", + "alice = ClassicalRegister(2, 'Alice')\n", + "bob = ClassicalRegister(1, 'Bob')\n", + "tele_qc.add_register(bell, alice, bob)\n", + "tele_qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now create the Bell pair with $Bell_0$ going to Alice and $Bell_1$ going to Bob. This is done by using a Hadamard gate to put $Bell_0$ in the $|+\\rangle$ state and then performing a CNOT with the same qubit as the control. After they receive their respective qubit, they part ways." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create Bell state with other two qubits\n", + "tele_qc.barrier()\n", + "tele_qc.h(1)\n", + "tele_qc.cx(1, 2)\n", + "tele_qc.barrier()\n", + "tele_qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, Alice performs a CNOT controlled by $q$ on $Bell_0$, which maps information about the state onto it. She then applies a Hadamard gate on $q$." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# alice operates on her qubits\n", + "tele_qc.cx(0, 1)\n", + "tele_qc.h(0)\n", + "tele_qc.barrier()\n", + "tele_qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now Alice measures her qubits and saves the results to her register." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tele_qc.measure([qr[0], bell[0]], alice)\n", + "tele_qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bob's qubit now has the information $|\\psi\\rangle$ from Alice's qubit $q$ encoded in $Bell_1$, but he does not know what basis to measure in to extract it. Accordingly, Alice must share the information in her register over a *classical* communication channel (this is why teleportation does not violate special relativity, no matter how far Alice and Bob are apart). She instructs Bob to perform an X gate on his qubit if her measurement of $Bell_0$ yields a 1 outcome, followed by a Z gate if her measurement of $q$ yields a 1.\n", + "\n", + "The applications of these gates can be conditioned on the measurement outcomes in two ways:\n", + "- the `.c_if()` [instruction](https://qiskit.org/documentation/stubs/qiskit.circuit.Instruction.c_if.html), which applies the gate it modifies if the value of the `ClassicalRegister` index is equal to the value specified. Note that this works **only** on simulators.\n", + "- the `.if_test()` [context](https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.if_test.html) which operates similarly, but generalizes the syntax to allow for nested conditionals. This works on both simulators and actual hardware." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ex 3 - Add approriate conditional gates to transform Bob's qubit into the $Z$-basis." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# either pairs are correct\n", + "\n", + "# tele_qc.x(2).c_if(alice[1], 1)\n", + "# tele_qc.z(2).c_if(alice[0], 1)\n", + "\n", + "with tele_qc.if_test((alice[1], 1)):\n", + " tele_qc.x(2)\n", + "with tele_qc.if_test((alice[0], 1)):\n", + " tele_qc.z(2)\n", + "\n", + "\n", + "tele_qc.draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, Bob can measure his qubit, which would yield results with the same probabilities as had Alice measured it originally." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tele_qc.barrier()\n", + "tele_qc.measure(bell[1], bob)\n", + "tele_qc.draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grading your answer. Please wait...\n", + "\n", + "Congratulations 🎉! Your answer is correct.\n" + ] + } + ], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab2_ex3\n", + "\n", + "grade_lab2_ex3(tele_qc, theta, 5*np.pi/7)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The statevector simulator cannot work with dynamic circuits because measurement is not a unitary operation. Therefore we import the `Sampler` primitive from `qiskit_aer` to use the `AerSimulator`. We choose our angle to be $5\\pi/7$, which will yield a 1 result about 80\\% of the time and 0 result about 20\\% of the time. Then we run both circuits: the original one Alice had and the teleported one Bob receives. " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original Dists: {'0': 0.2001953125, '1': 0.7998046875}\n", + "Teleported Dists: {'011': 0.041015625, '111': 0.1650390625, '100': 0.2158203125, '110': 0.208984375, '001': 0.044921875, '010': 0.0556640625, '000': 0.048828125, '101': 0.2197265625}\n" + ] + } + ], + "source": [ + "from qiskit_aer.primitives import Sampler\n", + "\n", + "angle = 5*np.pi/7\n", + "\n", + "sampler = Sampler()\n", + "qc.measure_all()\n", + "job_static = sampler.run(qc.bind_parameters({theta: angle}))\n", + "job_dynamic = sampler.run(tele_qc.bind_parameters({theta: angle}))\n", + "\n", + "print(f\"Original Dists: {job_static.result().quasi_dists[0].binary_probabilities()}\")\n", + "print(f\"Teleported Dists: {job_dynamic.result().quasi_dists[0].binary_probabilities()}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wait, we see different results! While measuring Alice's original $q$ yields the expected ratio of outcomes, the teleported distributions have many more values. This is because the teleported circuit includes Alice's measurements of $q$ and $Bell_0$, whereas we only wish to see Bob's measurements of $Bell_1$ yield the same distribution. \n", + "\n", + "In order to rectify this, we must take the *marginal* counts, meaning we combine results in which Bob measures a 0 and all the results in which Bob measures a 1 over all the possible combinations. This is done with the `marginal_counts` [method](https://qiskit.org/documentation/stubs/qiskit.result.marginal_counts.html) from `qiskit.result`, which combines results over measurement indices." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ex 4 - Marginalize the teleported counts\n", + "\n", + "Hint: Remember that bit strings are reported in the little-endian convention." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.result import marginal_counts\n", + "\n", + "# this is correct\n", + "tele_counts = marginal_counts(job_dynamic.result().quasi_dists[0].binary_probabilities(), indices=[2])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we marginalized correctly, we will see that the quasi-distributions from Alice's measurement and Bob's measurement are nearly identical, demonstrating that teleportation was successful!" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "legend = ['Original State', 'Teleported State']\n", + "plot_histogram([job_static.result().quasi_dists[0].binary_probabilities(), tele_counts], legend=legend)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grading your answer. Please wait...\n", + "Failed: 'result'\n", + "Unable to grade your answer.\n" + ] + } + ], + "source": [ + "from qc_grader.challenges.qgss_2023 import grade_lab2_ex4\n", + "\n", + "grade_lab2_ex4(tele_counts, job_dynamic.result().quasi_dists[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.24.0
qiskit-aer0.12.0
qiskit-ignis0.6.0
qiskit-ibmq-provider0.20.2
qiskit0.43.0
System information
Python version3.9.7
Python compilerClang 10.0.0
Python builddefault, Sep 16 2021 08:50:36
OSDarwin
CPUs2
Memory (Gb)8.0
Wed Jun 14 17:44:46 2023 -05
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import qiskit.tools.jupyter\n", + "%qiskit_version_table" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qiskit-runtime", + "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.9.7" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/IBM Quantum Summer School 2023/lab3-solution.ipynb b/IBM Quantum Summer School 2023/lab3-solution.ipynb new file mode 100644 index 0000000..b336ef1 --- /dev/null +++ b/IBM Quantum Summer School 2023/lab3-solution.ipynb @@ -0,0 +1,2951 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "abdd2993", + "metadata": {}, + "source": [ + "# IBM's Qiskit Global Summer School 2023\n", + "## Lab 3 - Diving Into Quantum Algorithms\n", + "\n", + "- In this lab, we will be applying what we've learned so far about quantum algorithms to implement our own version of Quantum Phase Estimation (QPE) as well as Shor's factoring algorithm. We will explore how increasing the number of qubits used to store the phase estimation changes the accuracy, as well as examine how this algorithm performs on real hardware. Afterwards, we will use your implementation of QPE to execute Shor's algorithm to find the prime factors of a small number. Each step will be walked through, and by the end we will have created a complete generalized function which can be run on the QasmSimulator." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4c665ca0-5865-4bc0-b3dd-5f67f4e533c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pip in /opt/conda/lib/python3.10/site-packages (23.2.1)\n", + "Collecting git+https://github.com/qiskit-community/Quantum-Challenge-Grader.git@main\n", + " Cloning https://github.com/qiskit-community/Quantum-Challenge-Grader.git (to revision main) to /tmp/pip-req-build-kxr_vi8h\n", + " Running command git clone --filter=blob:none --quiet https://github.com/qiskit-community/Quantum-Challenge-Grader.git /tmp/pip-req-build-kxr_vi8h\n", + " Resolved https://github.com/qiskit-community/Quantum-Challenge-Grader.git to commit 2eb4d129f12d37c77dfc84f1144ede8e61e611d0\n", + " Preparing metadata (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: numpy in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (1.23.5)\n", + "Requirement already satisfied: qiskit>=0.37 in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (0.43.2)\n", + "Requirement already satisfied: requests in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (2.28.1)\n", + "Requirement already satisfied: networkx in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (2.8.8)\n", + "Requirement already satisfied: ipycytoscape in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (1.3.3)\n", + "Requirement already satisfied: plotly in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (5.12.0)\n", + "Requirement already satisfied: jsonpickle in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (3.0.1)\n", + "Requirement already satisfied: typeguard in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (2.13.3)\n", + "Requirement already satisfied: jupyterplot in /opt/conda/lib/python3.10/site-packages (from qc-grader==0.16.4) (0.0.3)\n", + "Requirement already satisfied: qiskit-terra==0.24.1 in /opt/conda/lib/python3.10/site-packages (from qiskit>=0.37->qc-grader==0.16.4) (0.24.1)\n", + "Requirement already satisfied: qiskit-aer==0.12.1 in /opt/conda/lib/python3.10/site-packages (from qiskit>=0.37->qc-grader==0.16.4) (0.12.1)\n", + "Requirement already satisfied: qiskit-ibmq-provider==0.20.2 in /opt/conda/lib/python3.10/site-packages (from qiskit>=0.37->qc-grader==0.16.4) (0.20.2)\n", + "Requirement already satisfied: scipy>=1.0 in /opt/conda/lib/python3.10/site-packages (from qiskit-aer==0.12.1->qiskit>=0.37->qc-grader==0.16.4) (1.9.3)\n", + "Requirement already satisfied: requests-ntlm<=1.1.0 in /opt/conda/lib/python3.10/site-packages (from qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (1.1.0)\n", + "Requirement already satisfied: urllib3>=1.21.1 in /opt/conda/lib/python3.10/site-packages (from qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (1.26.13)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /opt/conda/lib/python3.10/site-packages (from qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (2.8.2)\n", + "Requirement already satisfied: websocket-client>=1.5.1 in /opt/conda/lib/python3.10/site-packages (from qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (1.5.1)\n", + "Requirement already satisfied: websockets>=10.0 in /opt/conda/lib/python3.10/site-packages (from qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (10.4)\n", + "Requirement already satisfied: rustworkx>=0.12.0 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (0.12.1)\n", + "Requirement already satisfied: ply>=3.10 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (3.11)\n", + "Requirement already satisfied: psutil>=5 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (5.9.4)\n", + "Requirement already satisfied: sympy>=1.3 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (1.11.1)\n", + "Requirement already satisfied: dill>=0.3 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (0.3.6)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (4.1.1)\n", + "Requirement already satisfied: symengine<0.10,>=0.9 in /opt/conda/lib/python3.10/site-packages (from qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (0.9.2)\n", + "Requirement already satisfied: charset-normalizer<3,>=2 in /opt/conda/lib/python3.10/site-packages (from requests->qc-grader==0.16.4) (2.1.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.10/site-packages (from requests->qc-grader==0.16.4) (3.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.10/site-packages (from requests->qc-grader==0.16.4) (2022.9.24)\n", + "Requirement already satisfied: ipywidgets>=7.6.0 in /opt/conda/lib/python3.10/site-packages (from ipycytoscape->qc-grader==0.16.4) (8.0.2)\n", + "Requirement already satisfied: spectate>=1.0.0 in /opt/conda/lib/python3.10/site-packages (from ipycytoscape->qc-grader==0.16.4) (1.0.1)\n", + "Requirement already satisfied: lrcurve==1.1.0 in /opt/conda/lib/python3.10/site-packages (from jupyterplot->qc-grader==0.16.4) (1.1.0)\n", + "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.10/site-packages (from jupyterplot->qc-grader==0.16.4) (3.6.2)\n", + "Requirement already satisfied: ipython in /opt/conda/lib/python3.10/site-packages (from lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (8.7.0)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /opt/conda/lib/python3.10/site-packages (from plotly->qc-grader==0.16.4) (8.1.0)\n", + "Requirement already satisfied: ipykernel>=4.5.1 in /opt/conda/lib/python3.10/site-packages (from ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (6.17.1)\n", + "Requirement already satisfied: traitlets>=4.3.1 in /opt/conda/lib/python3.10/site-packages (from ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (5.6.0)\n", + "Requirement already satisfied: widgetsnbextension~=4.0 in /opt/conda/lib/python3.10/site-packages (from ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (4.0.3)\n", + "Requirement already satisfied: jupyterlab-widgets~=3.0 in /opt/conda/lib/python3.10/site-packages (from ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (3.0.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (1.0.6)\n", + "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (4.38.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (1.4.4)\n", + "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (21.3)\n", + "Requirement already satisfied: pillow>=6.2.0 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (9.2.0)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /opt/conda/lib/python3.10/site-packages (from matplotlib->jupyterplot->qc-grader==0.16.4) (3.0.9)\n", + "Requirement already satisfied: debugpy>=1.0 in /opt/conda/lib/python3.10/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (1.6.4)\n", + "Requirement already satisfied: jupyter-client>=6.1.12 in /opt/conda/lib/python3.10/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (7.3.4)\n", + "Requirement already satisfied: matplotlib-inline>=0.1 in /opt/conda/lib/python3.10/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (0.1.6)\n", + "Requirement already satisfied: nest-asyncio in /opt/conda/lib/python3.10/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (1.5.6)\n", + "Requirement already satisfied: pyzmq>=17 in /opt/conda/lib/python3.10/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (24.0.1)\n", + "Requirement already satisfied: tornado>=6.1 in /opt/conda/lib/python3.10/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (6.1)\n", + "Requirement already satisfied: backcall in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.2.0)\n", + "Requirement already satisfied: decorator in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (5.1.1)\n", + "Requirement already satisfied: jedi>=0.16 in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.18.2)\n", + "Requirement already satisfied: pickleshare in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.7.5)\n", + "Requirement already satisfied: prompt-toolkit<3.1.0,>=3.0.11 in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (3.0.33)\n", + "Requirement already satisfied: pygments>=2.4.0 in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (2.13.0)\n", + "Requirement already satisfied: stack-data in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.6.2)\n", + "Requirement already satisfied: pexpect>4.3 in /opt/conda/lib/python3.10/site-packages (from ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (4.8.0)\n", + "Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.10/site-packages (from python-dateutil>=2.8.0->qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (1.16.0)\n", + "Requirement already satisfied: ntlm-auth>=1.0.2 in /opt/conda/lib/python3.10/site-packages (from requests-ntlm<=1.1.0->qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (1.5.0)\n", + "Requirement already satisfied: cryptography>=1.3 in /opt/conda/lib/python3.10/site-packages (from requests-ntlm<=1.1.0->qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (38.0.4)\n", + "Requirement already satisfied: pbr!=2.1.0,>=2.0.0 in /opt/conda/lib/python3.10/site-packages (from stevedore>=3.0.0->qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (5.11.1)\n", + "Requirement already satisfied: mpmath>=0.19 in /opt/conda/lib/python3.10/site-packages (from sympy>=1.3->qiskit-terra==0.24.1->qiskit>=0.37->qc-grader==0.16.4) (1.2.1)\n", + "Requirement already satisfied: cffi>=1.12 in /opt/conda/lib/python3.10/site-packages (from cryptography>=1.3->requests-ntlm<=1.1.0->qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (1.15.1)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /opt/conda/lib/python3.10/site-packages (from jedi>=0.16->ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.8.3)\n", + "Requirement already satisfied: entrypoints in /opt/conda/lib/python3.10/site-packages (from jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (0.4)\n", + "Requirement already satisfied: jupyter-core>=4.9.2 in /opt/conda/lib/python3.10/site-packages (from jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (5.1.0)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /opt/conda/lib/python3.10/site-packages (from pexpect>4.3->ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /opt/conda/lib/python3.10/site-packages (from prompt-toolkit<3.1.0,>=3.0.11->ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.2.5)\n", + "Requirement already satisfied: executing>=1.2.0 in /opt/conda/lib/python3.10/site-packages (from stack-data->ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (1.2.0)\n", + "Requirement already satisfied: asttokens>=2.1.0 in /opt/conda/lib/python3.10/site-packages (from stack-data->ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (2.2.0)\n", + "Requirement already satisfied: pure-eval in /opt/conda/lib/python3.10/site-packages (from stack-data->ipython->lrcurve==1.1.0->jupyterplot->qc-grader==0.16.4) (0.2.2)\n", + "Requirement already satisfied: pycparser in /opt/conda/lib/python3.10/site-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm<=1.1.0->qiskit-ibmq-provider==0.20.2->qiskit>=0.37->qc-grader==0.16.4) (2.21)\n", + "Requirement already satisfied: platformdirs>=2.5 in /opt/conda/lib/python3.10/site-packages (from jupyter-core>=4.9.2->jupyter-client>=6.1.12->ipykernel>=4.5.1->ipywidgets>=7.6.0->ipycytoscape->qc-grader==0.16.4) (2.5.2)\n" + ] + } + ], + "source": [ + "# upgrade/update pip library\n", + "!pip install --upgrade pip\n", + "\n", + "# install the last official version of the grader from IBM's Qiskit Community\n", + "!pip install git+https://github.com/qiskit-community/Quantum-Challenge-Grader.git@main" + ] + }, + { + "cell_type": "markdown", + "id": "030d4033-274a-4f06-8299-895dc37b875b", + "metadata": {}, + "source": [ + "***" + ] + }, + { + "cell_type": "markdown", + "id": "b82a124a", + "metadata": {}, + "source": [ + "## Section 1: Quantum Phase Estimation (QPE)\n", + "***\n", + "\n", + "\"Quantum\n", + "\n", + "\n", + "As a reminder to you, the above figure outlines the Quantum Phase Estimation (QPE) circuit. Below, we'll provide a few import statements and functions that you'll use throughout the lab." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "01b08df9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# import the quantum circuit, Aer,\n", + "# and execute instruction\n", + "# from the IBM' Qiskit library\n", + "from qiskit import QuantumCircuit, Aer, execute\n", + "\n", + "# import the numpy library\n", + "import numpy as np\n", + "\n", + "# import the plot histogram function\n", + "# from the IBM's Qiskit Visualization module\n", + "from qiskit.visualization import plot_histogram\n", + "\n", + "# import the plotting from\n", + "# the Matplotlib's Pyplot module\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# import the GCD (Greatest Common Divisor)\n", + "# from the built-in mathematics module\n", + "from math import gcd" + ] + }, + { + "cell_type": "markdown", + "id": "4c352e6e-96ab-4312-9453-df6d8051ca7b", + "metadata": {}, + "source": [ + "
Ex. 1 - Create a quantum circuit for the Quantum Phase Estimation on 4 counting qubits, with an angle $\\theta = \\frac{1}{3}$.
" + ] + }, + { + "cell_type": "markdown", + "id": "206bb6b0", + "metadata": {}, + "source": [ + "### Step 1: Set up a QPE Circuit with four counting qubits\n", + "\n", + "Let's pick a phase gate with $\\theta = \\frac{1}{3}$ as a simple example unitary to test creating a QPE circuit. Here we'll use IBM's Qiskit `PhaseGate` which applies $P|1\\rangle{}=e^{i\\lambda}|1\\rangle{}$. Since we want to examine QPE under a unitary with the form $U|1\\rangle{}=e^{i2\\pi \\theta}$, we should set $\\lambda=\\frac{2\\pi}{3}$.\n", + "\n", + "Create a QPE circuit with four counting qubits and name the circuit `qpe4`. It may be helpful to define two `QuantumRegister` objects, one for the \"system\" where the unitary will be applied and one for where the phase information will be stored. Feel free to reference the IBM's Qiskit Textbook's chapter on [Quantum Phase Estimation](https://learn.qiskit.org/course/ch-algorithms/quantum-phase-estimation#getting_more_precision)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3c62e5a7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# define the function to genera the quantum circuit\n", + "# for the Quantum Fourier Transform (QFT) on n qubits\n", + "def qft(n):\n", + " \n", + " # creates a quantum circuit with n qubits,\n", + " # implementing the Quantum Fourier Transform (QFT)\n", + " circuit = QuantumCircuit(n)\n", + " \n", + " \n", + " # define the function to perform the Swap gates\n", + " # on the quantum registers of the quantum circuit\n", + " # for the Quantum Fourier Transform (QFT) on n qubits\n", + " def swap_registers( circuit, n ):\n", + " \n", + " # for a number of iterations equal to half of\n", + " # the number of qubits used on the quantum circuit\n", + " # for the Quantum Fourier Transform (QFT)\n", + " for qubit in range( n // 2 ):\n", + " \n", + " # apply the Swap gate between the kth qubit and\n", + " # the (n - k)th qubit on the quantum register defined before\n", + " circuit.swap( qubit, ( n - qubit - 1 ) )\n", + " \n", + " \n", + " # return the quantum circuit with the Swap gates\n", + " # applied on the n qubits of the quantum register,\n", + " # to implement the Quantum Fourier Transform (QFT)\n", + " return circuit\n", + " \n", + " \n", + " # define the function to perform the Controlled-Phase gates\n", + " # on the quantum registers of the quantum circuit\n", + " # for the Quantum Fourier Transform (QFT) on n qubits\n", + " # (it is applied to the first n qubits,\n", + " # and without the Swap gates performed)\n", + " def qft_rotations( circuit, n ):\n", + " \n", + " # if it is the last opposite iteration\n", + " if n == 0:\n", + " \n", + " # return with the Controlled-Phase gates\n", + " # on the quantum registers of the quantum circuit\n", + " # for the Quantum Fourier Transform (QFT) on n qubits\n", + " # (it is applied to the first n qubits,\n", + " # and without the Swap gates performed)\n", + " return circuit\n", + " \n", + " \n", + " # iterates on the opposite direction,\n", + " # setting a new nth iteration\n", + " n -= 1\n", + " \n", + " \n", + " # apply the Hadamard gate to the kth qubit,\n", + " # on the quantum register defined before,\n", + " # and iterating on the opposite direction\n", + " circuit.h(n)\n", + " \n", + " \n", + " # for the remaining qubits to consider\n", + " # i the kth opposite iteration\n", + " for qubit in range(n):\n", + " \n", + " # apply the Controlled-Phase gate for\n", + " # the theta angle equal to (pi / 2)^(n - k),\n", + " # with control on the nth qubit and target on the kth qubit\n", + " circuit.cp( ( np.pi / 2 )**( n - qubit ), qubit, n )\n", + " \n", + " \n", + " # call this fuction recursively for\n", + " # the next opposite iteration\n", + " qft_rotations( circuit, n )\n", + " \n", + " \n", + " # perform the Controlled-Phase gates\n", + " # on the quantum registers of the quantum circuit\n", + " # for the Quantum Fourier Transform (QFT) on n qubits\n", + " # (it is applied to the first n qubits,\n", + " # and without the Swap gates performed)\n", + " qft_rotations( circuit, n )\n", + " \n", + " # perform the Swap gates on the quantum registers of\n", + " # the quantum circuit for the Quantum Fourier Transform (QFT) on n qubits\n", + " swap_registers( circuit, n )\n", + " \n", + " \n", + " # return the quantum circuit with n qubits,\n", + " # implementing the Quantum Fourier Transform (QFT)\n", + " return circuit\n", + "\n", + "\n", + "# define the function to genera the quantum circuit\n", + "# for the Inverse Quantum Fourier Transform (IQFT) on n qubits\n", + "def qft_dagger( circuit, n ):\n", + "\n", + " # note: do not forget to apply again the Swap gates\n", + " # to peform its inverse operation\n", + " \n", + " # for a number of iterations equal to half of\n", + " # the number of qubits used on the quantum circuit\n", + " # for the Inverse Quantum Fourier Transform (IQFT)\n", + " for qubit in range( n // 2 ):\n", + "\n", + " # apply the Swap gate between the kth qubit and\n", + " # the (n - k)th qubit on the quantum register defined before\n", + " circuit.swap( qubit, ( n - qubit - 1 ) )\n", + " \n", + " \n", + " # for each number of qubits of the quantum register defined before,\n", + " # to consider in the current jth iteration\n", + " for j in range(n):\n", + " \n", + " \n", + " # for each mth qubit of the quantum register defined before,\n", + " # to consider in the current iteration\n", + " for m in range(j):\n", + " \n", + " # apply the Controlled-Phase gate for\n", + " # the theta angle equal to -pi / ( 2^( j - m ) ),\n", + " # with control on the mth qubit and target on the jth qubit\n", + " qc.cp( -np.pi / float( 2**( j - m ) ), m, j )\n", + " \n", + " \n", + " # apply the Hadamard gate to the jth qubit\n", + " # on the quantum register defined before\n", + " qc.h(j)" + ] + }, + { + "cell_type": "markdown", + "id": "67a189c9", + "metadata": {}, + "source": [ + "It should look something like this (note that because IBM's Qiskit uses little endian notation, the ordering of the controlled-$U$ gates are different):\n", + "\n", + "\"QPE" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cdf021ec", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define the size n of the quantum register to\n", + "# store the phase information\n", + "phase_register_size = 4\n", + "\n", + "# create a quantum circuit with a quantum register\n", + "# with n qubits and a classical register with n bits,\n", + "# to implement the Quantum Phase Estimation (QPE) for n = 4 qubits\n", + "qpe4 = QuantumCircuit( ( phase_register_size + 1 ),\n", + " phase_register_size )\n", + "\n", + "\n", + "####################################################\n", + "\n", + "#### insert your code here ####\n", + "\n", + "\n", + "# define the function to perform the Quantum Hadamard Transform on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE)\n", + "def apply_quantum_hadamard_transform( circuit, n ): \n", + " \n", + " # for each qubit of the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE) for n qubits\n", + " for qubit_idx in range(n):\n", + " \n", + " # apply the Hadamard gate to the current ith qubit\n", + " circuit.h(qubit_idx)\n", + "\n", + "\n", + "# define the function to perform the Controlled-Phase gates on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE),\n", + "# as part of the Quantum Fourier Transform (QFT)\n", + "def apply_controlled_phases( theta, circuit, n ):\n", + " \n", + " # for each ith step according to\n", + " # the number of n qubits used\n", + " for step in range(n):\n", + " \n", + " # compute the iteration parameter t\n", + " # as a power of 2, according to the current step\n", + " t = 2**step\n", + " \n", + " \n", + " # for each iteration according to\n", + " # the iteration parameter t\n", + " for _ in range(t):\n", + "\n", + " # apply the Controlled-Phase gate for the theta angle,\n", + " # with control on the ith qubit and target on the last qubit\n", + " circuit.cp( theta, step, n ) \n", + "\n", + "\n", + "# define the function to perform the Swap gates on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE),\n", + "# as part of the Quantum Fourier Transform (QFT)\n", + "def apply_swaps( circuit, n ):\n", + " \n", + " # for a number of iterations equal to half of\n", + " # the number of phase counting qubits used\n", + " # on the resepective quantum circuit\n", + " # for the Quantum Fourier Transform (QFT)\n", + " for qubit_idx in range( phase_register_size // 2 ):\n", + " \n", + " # apply the Swap gate between the kth qubit and\n", + " # the (n - k)th qubit on the quantum register defined before\n", + " circuit.swap( qubit_idx, ( n - qubit_idx - 1 ) )\n", + " \n", + "\n", + "# define the function to perform\n", + "# the Inverse Quantum Fourier Transform (IQFT) on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE)\n", + "def apply_quantum_fourier_transform_inverse( circuit, n ):\n", + " \n", + " # for each qubit on the quantum register\n", + " for j in range(n):\n", + " \n", + " # for each additional mth qubit ranging to\n", + " # the current jth qubit being iterated before\n", + " for m in range(j):\n", + " \n", + " # apply the Controlled-Phase gate for\n", + " # the theta angle equal to -pi / ( 2^( j - m ) ),\n", + " # with control on the mth qubit and target on the jth qubit\n", + " circuit.cp( -np.pi / float( 2**( j - m ) ), m, j )\n", + "\n", + " # apply the Hadamard gate to the jth qubit (system's qubit)\n", + " circuit.h(j)\n", + "\n", + " \n", + "# define the function to perform a measurement of\n", + "# all the n qubits on the quantum register of a quantum circuit,\n", + "# and storing the classical outcomes on the n bits of\n", + "# the classical register of that same quantum circuit\n", + "def measure_all_qubits(circuit, n):\n", + " \n", + " # for each pair of qubits and bits\n", + " for j in range(n):\n", + " \n", + " # measure the current qubit on the quantum register,\n", + " # and stores the classical outcome obtained\n", + " # in the current bit on the classical register\n", + " circuit.measure(j, j)\n", + "\n", + "\n", + "# define the function to perform the Quantum Phase Estimation (QPE)\n", + "# according to a theta angle given, on a quantum circuit of n qubits\n", + "def quantum_phase_estimation( theta, circuit, n ):\n", + " \n", + " # perform the Quantum Hadamard Transform on\n", + " # the n qubits of the quantum register of\n", + " # the quantum circuit implementing\n", + " # the Quantum Phase Estimation (QPE)\n", + " apply_quantum_hadamard_transform( circuit, n )\n", + " \n", + " # apply the Pauli-X gate to the last qubit on\n", + " # the quantum register of the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE) \n", + " circuit.x(n)\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " circuit.barrier()\n", + " \n", + " \n", + " # perform the Controlled-Phase gates on\n", + " # the n qubits of the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE),\n", + " # as part of the Quantum Fourier Transform (QFT)\n", + " apply_controlled_phases( theta, circuit, n )\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " circuit.barrier()\n", + " \n", + " # perform the Swap gates on the n qubits of\n", + " # the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE),\n", + " # as part of the Quantum Fourier Transform (QFT)\n", + " apply_swaps( circuit, n )\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " circuit.barrier()\n", + " \n", + " \n", + " # perform the Inverse Quantum Fourier Transform (IQFT) on\n", + " # the n qubits of the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE)\n", + " apply_quantum_fourier_transform_inverse( circuit, n )\n", + "\n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " circuit.barrier()\n", + " \n", + " \n", + " # perform a measurement of all the n qubits on\n", + " # the quantum register of the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE) and storing\n", + " # the classical outcomes on the n bits of\n", + " # the classical register of that same quantum circuit\n", + " measure_all_qubits( circuit, n )\n", + "\n", + " \n", + "####################################################\n", + "\n", + "\n", + "# define the theta angle to be equal to (2 * pi) / 3\n", + "theta = ( 2 * np.pi ) / 3 \n", + "\n", + "\n", + "# perform the Quantum Phase Estimation (QPE)\n", + "# according to the theta angle defined,\n", + "# on the quantum circuit of n qubits defined before\n", + "quantum_phase_estimation( theta, qpe4, phase_register_size )\n", + "\n", + "\n", + "# draw the quantum circuit implementing\n", + "# the Quantum Phase Estimation (QPE) defined before\n", + "qpe4.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "21259f16", + "metadata": {}, + "source": [ + "Now use the `AerSimulator` to simulate this circuit and plot the histogram of the results. Use 2000 shots.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f091e056", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell to simulate 'qpe4' and\n", + "# to plot the histogram of the result\n", + "\n", + "# create the Aer Simulator object\n", + "sim = Aer.get_backend(\"aer_simulator\")\n", + "\n", + "# define the number of shots\n", + "shots = 20000\n", + "\n", + "\n", + "# execute the simulation for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation\n", + "count_qpe4 = execute( qpe4, sim, shots=shots ).result().get_counts()\n", + "\n", + "\n", + "# plot the histogram of the result counts of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n = 4 counting qubits\n", + "plot_histogram( count_qpe4, figsize=(9,5) )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fb998b47", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 1 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex1 \n", + "\n", + "# grade the exercise 1 of the lab 3\n", + "grade_lab3_ex1( count_qpe4 )" + ] + }, + { + "cell_type": "markdown", + "id": "9ca1785a", + "metadata": {}, + "source": [ + "Next write a function to process the bit strings into the estimate of $\\theta$. Recall that the phase estimate is written in the form:\n", + "\n", + "$$ \\theta = 0.\\theta_1\\theta_2\\theta_3...\\theta_t = \\frac{\\theta_1}{2^1} + \\frac{\\theta_2}{2^2} + \\frac{\\theta_3}{2^3} + ... + \\frac{\\theta_t}{2^t} $$\n", + "\n", + "where $\\theta_i = \\{0,1\\}$. What is the estimated phase? What is the highest power of 2 this circuit can be accurate up to given your choice of the number of counting qubits (e.g. $2^{-2}$, $2^{-3}$, $2^{-4}$, etc.)?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e15cbf0b-7552-4a2a-8495-b57e038d9919", + "metadata": {}, + "source": [ + "
Ex. 2 - Estimate the phase and the accuracy of the quantum circuit for the Quantum Phase Estimation (QPE) defined before.
" + ] + }, + { + "cell_type": "markdown", + "id": "01742f40-0a55-42a3-bbe7-c89171a14d40", + "metadata": {}, + "source": [ + "Let's estimate the phase and the accuracy of the quantum circuit for the Quantum Phase Estimation (QPE):" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0d427100", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# process the result count data to determine accuracy of\n", + "# the estimated phase and grab the highest probability measurement\n", + "\n", + "\n", + "# define the maximum number of counts which will be obtained\n", + "max_binary_counts = 0\n", + "\n", + "# define the maximum binary value which will be obtained\n", + "max_binary_val = \"\"\n", + "\n", + "\n", + "# for each count obtained from the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "for key, item in count_qpe4.items():\n", + " \n", + " # if the current number of counts is greater than\n", + " # the current maximum number of counts obtained\n", + " if item > max_binary_counts:\n", + " \n", + " # update the maximum number of counts obtained\n", + " max_binary_counts = item\n", + " \n", + " # update the maximum binary value obtained\n", + " max_binary_val = key\n", + "\n", + " \n", + "#########################################\n", + " \n", + "\n", + "#### your function to convert a binary ####\n", + "#### string to a decimal number goes here ####\n", + "\n", + "# define the function to convert\n", + "# a binary string to a decimal number\n", + "def bin_to_decimal( binary_string ):\n", + " \n", + " # return a binary string\n", + " # converted to a decimal number\n", + " return int( binary_string, 2 )\n", + "\n", + "\n", + "# calculate the estimated phase obtained\n", + "# from the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "estimated_phase = ( bin_to_decimal(max_binary_val) / 2**phase_register_size )\n", + "\n", + "# calculate the phase accuracy\n", + "# which can be obtained from\n", + "# the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "# with the quantum circuit defined before,\n", + "# inverse of the highest power of 2\n", + "# (i.e. smallest decimal) this quantum circuit can estimate\n", + "phase_accuracy_window = 2**( -phase_register_size )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "732d9625", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 2 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex2 \n", + "\n", + "# grade the exercise 2 of the lab 3\n", + "grade_lab3_ex2( [ estimated_phase, phase_accuracy_window ] )" + ] + }, + { + "cell_type": "markdown", + "id": "3820b0e3", + "metadata": {}, + "source": [ + "## Step 2: Run on Noisy Hardware\n", + "\n", + "Now run this circuit using your favorite backend! Transpile this circuit a number of times (you pick how many) and pick the one with the lowest and highest circuit depth. \n", + "\n", + "Transpile the circuit with the parameter optimization_level = 3 to reduce the error in the result. Qiskit by default uses a stochastic swap mapper to place the needed SWAP gates, which varies the transpiled circuit results even under the same runtime settings. Therefore, to achieve shorter depth transpiled circuit for smaller error in the outcome, transpile qpe4 multiple times and choose one with the minimum circuit depth. Select the maximum circuit depth one as well to compare against, name them `min_depth_qpe` and `max_depth_qpe`.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "1e44a3f5-7d1a-41a4-9081-ddec182d54c2", + "metadata": {}, + "source": [ + "
Ex. 3 - Run an optimized quantum circuit for the Quantum Phase Estimation (QPE) on Quantum Noisy Hardware.
" + ] + }, + { + "cell_type": "markdown", + "id": "540d14ee-6e58-496a-a78a-a334c5720545", + "metadata": {}, + "source": [ + "Let's transpile/optimize the quantum circuit for the Quantum Phase Estimation (QPE) several times, to execute the best one on a Quantum Noisy Hardware:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8297c6da", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# import the IBM's Provider from\n", + "# the Qiskit's IBM Provider module\n", + "from qiskit_ibm_provider import IBMProvider\n", + "\n", + "# import the transpile function from\n", + "# the IBM's Qikist Compiler module\n", + "from qiskit.compiler import transpile\n", + "\n", + "\n", + "# create an IBM's Provider object\n", + "provider = IBMProvider()\n", + "\n", + "\n", + "# define the hub for the IBM's Provider\n", + "hub = \"summer-school-6\"\n", + "\n", + "# define the group for the IBM's Provider\n", + "group = \"group-3\"\n", + "\n", + "# define the project for the IBM's Provider\n", + "project = \"7048813929\"\n", + "\n", + "\n", + "# define the backend's name for the IBM's Provider\n", + "backend_name = \"ibmq_manila\"\n", + "\n", + "\n", + "# retrieve the backend from the IBM's Provider\n", + "backend = provider.get_backend( backend_name, instance=f\"{hub}/{group}/{project}\" )\n", + "\n", + "\n", + "\n", + "##########################################\n", + "\n", + "#### your code goes here ####\n", + "\n", + "\n", + "# define the initial maximum quantum circuit depth obtained\n", + "max_depth = 1e-20\n", + "\n", + "# define the initial minimum quantum circuit depth obtained\n", + "min_depth = 1e20\n", + "\n", + "\n", + "# define the number of trials to transpile/optimize\n", + "# the quantum circuit for the Quantum Phase Estimation (QPE) \n", + "num_trials = 10\n", + "\n", + "\n", + "# for each trial to transpile/optimize the quantum circuit\n", + "# for the Quantum Phase Estimation (QPE) \n", + "for _ in range(num_trials):\n", + " \n", + " # transpile/optimize the quantum circuit\n", + " # for the Quantum Phase Estimation (QPE),\n", + " # for the current considering trial\n", + " transpiled_qpe4 = transpile( qpe4, backend, optimization_level=3 )\n", + " \n", + " # retrieve the quantum circuit depth of\n", + " # the transpiled/optimized quantum circuit\n", + " # for the Quantum Phase Estimation (QPE) \n", + " transpiled_qpe4_depth = transpiled_qpe4.depth()\n", + " \n", + " \n", + " # if the quantum circuit depth of\n", + " # the transpiled/optimized quantum circuit\n", + " # for the Quantum Phase Estimation (QPE)\n", + " # is greater than the current maximum\n", + " # quantum circuit depth obtained \n", + " if transpiled_qpe4_depth > max_depth:\n", + " \n", + " # update the maximum quantum circuit depth\n", + " # obtained with the current quantum circuit depth\n", + " max_depth = transpiled_qpe4_depth\n", + " \n", + " # update the quantum circuit with the maximum depth\n", + " # with the current quantum circuit transpiled/optimized\n", + " max_depth_qpe = transpiled_qpe4\n", + " \n", + " \n", + " # if the quantum circuit depth of\n", + " # the transpiled/optimized quantum circuit\n", + " # for the Quantum Phase Estimation (QPE)\n", + " # is lower than the current minimum\n", + " # quantum circuit depth obtained \n", + " if transpiled_qpe4_depth < min_depth:\n", + "\n", + " # update the minimum quantum circuit depth\n", + " # obtained with the current quantum circuit depth\n", + " min_depth = transpiled_qpe4_depth\n", + " \n", + " # update the quantum circuit with the minimum depth\n", + " # with the current quantum circuit transpiled/optimized\n", + " min_depth_qpe = transpiled_qpe4\n", + "\n", + " \n", + "##########################################" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7b389bc6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 3 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex3\n", + "\n", + "# grade the exercise 3 of the lab 3\n", + "grade_lab3_ex3( [ max_depth_qpe, min_depth_qpe ] )" + ] + }, + { + "cell_type": "markdown", + "id": "8d262a40-e04c-4ada-b994-26d6ff4fbf73", + "metadata": {}, + "source": [ + "Run the best optimized/transpiled quantum circuits for the Quantum Phase Estimation (QPE) on Noisy Quantum Hardware (with the minimum quantum circuit depth):" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5adcd092", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# define the number of shots\n", + "#shots = 2000\n", + "\n", + "# OPTIONAL: run the minimum depth quantum circuit for\n", + "# the Quantum Phase Estimation (QPE)\n", + "\n", + "# execute and retrieve the job for the simulation\n", + "# for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation,\n", + "# using the minimum quantum circuit depth\n", + "#job_min_qpe4 = backend.run( min_depth_qpe, sim, shots=shots )\n", + "\n", + "# print the id of the job of the simulation\n", + "# for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation,\n", + "# using the minimum quantum circuit depth\n", + "#print( job_min_qpe4.job_id() )\n", + "\n", + "\n", + "# gather the result counts data\n", + "\n", + "# execute the simulation for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation,\n", + "# using the minimum quantum circuit depth\n", + "#count_min_qpe4 = job_min_qpe4.result().get_counts()\n", + "\n", + "# plot the histogram of the result counts of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n = 4 counting qubits,\n", + "# and using the minimum quantum circuit depth\n", + "#plot_histogram( count_min_qpe4, figsize=(9,5) )" + ] + }, + { + "cell_type": "markdown", + "id": "cec7c84f-b962-4822-a21e-a5f9c3cf508e", + "metadata": {}, + "source": [ + "Run the best optimized/transpiled quantum circuits for the Quantum Phase Estimation (QPE) on Noisy Quantum Hardware (with the maximum quantum circuit depth):" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a05d8270", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# OPTIONAL: run the maximum depth quantum circuit for\n", + "# the Quantum Phase Estimation (QPE)\n", + "\n", + "# execute and retrieve the job for the simulation\n", + "# for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation,\n", + "# using the maximum quantum circuit depth\n", + "#job_max_qpe4 = backend.run( max_depth_qpe, sim, shots=shots )\n", + "\n", + "# print the id of the job of the simulation\n", + "# for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation,\n", + "# using the maximum quantum circuit depth\n", + "#print( job_max_qpe4.job_id() )\n", + "\n", + "\n", + "# gather the result counts data\n", + "\n", + "# execute the simulation for the Quantum Phase Estimation (QPE),\n", + "# with n = 4 counting qubits, and retrieve\n", + "# the result counts of this quantum simulation,\n", + "# using the maximum quantum circuit depth\n", + "#count_max_qpe4 = job_max_qpe4.result().get_counts()\n", + "\n", + "# plot the histogram of the result counts of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n = 4 counting qubits,\n", + "# and using the maximum quantum circuit depth\n", + "#plot_histogram( count_max_qpe4, figsize=(9,5) )" + ] + }, + { + "cell_type": "markdown", + "id": "8138984d-c546-4785-9acc-7f407ee7c091", + "metadata": { + "tags": [] + }, + "source": [ + "
Ex. 4 - Create a quantum circuit for the Quantum Phase Estimation (QPE) of $n$ qubits, with an angle $\\theta = \\frac{1}{7}$.
" + ] + }, + { + "cell_type": "markdown", + "id": "3b2b49a6", + "metadata": {}, + "source": [ + "## Step 3: Try with a different $\\theta$\n", + "\n", + "Now try the same procedure with $\\theta = \\frac{1}{7}$. Rewrite your code written above to create a function which generates a QPE circuit with $n$ register qubits. How many register qubits storing the phase information are needed for the estimate to be accurate to within $2^{-6}$? \n", + "\n", + "*Hint: It may be easier to iterate over different phase register sizes by creating a callable function. Perhaps call it* `qpe_circuit`" + ] + }, + { + "cell_type": "markdown", + "id": "a5561153-f7fc-4822-b6fc-257c7cb00afb", + "metadata": {}, + "source": [ + "Let's implement a function to generate a quantum circuit for the Quantum Phase Estimation (QPE), considering now the phase angle $\\theta = \\frac{1}{7}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b121893f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# define the function to perform the Quantum Hadamard Transform on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE)\n", + "def apply_quantum_hadamard_transform( circuit, n ):\n", + " \n", + " # for each qubit of the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE) for n qubits\n", + " for qubit_idx in range(n):\n", + " \n", + " # apply the Hadamard gate to the current ith qubit\n", + " circuit.h(qubit_idx)\n", + " \n", + "\n", + "# define the function to perform the Controlled-Phase gates on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE),\n", + "# as part of the Quantum Fourier Transform (QFT)\n", + "def apply_controlled_phases( theta, circuit, n ):\n", + " \n", + " # for each ith step according to\n", + " # the number of n qubits used\n", + " for step in range(n):\n", + " \n", + " # compute the iteration parameter t\n", + " # as a power of 2, according to the current step\n", + " t = 2**step\n", + "\n", + " \n", + " # for each iteration according to\n", + " # the iteration parameter t\n", + " for _ in range(t):\n", + "\n", + " # apply the Controlled-Phase gate for the theta angle,\n", + " # with control on the ith qubit and target on the last qubit\n", + " circuit.cp( theta, step, n ) \n", + "\n", + " \n", + "# define the function to perform the Swap gates on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE),\n", + "# as part of the Quantum Fourier Transform (QFT)\n", + "def apply_swaps( circuit, n ):\n", + " \n", + " # for a number of iterations equal to half of\n", + " # the number of phase counting qubits used\n", + " # on the resepective quantum circuit\n", + " # for the Quantum Fourier Transform (QFT)\n", + " for qubit_idx in range( phase_register_size // 2 ):\n", + " \n", + " # apply the Swap gate between the kth qubit and\n", + " # the (n - k)th qubit on the quantum register defined before\n", + " circuit.swap( qubit_idx, ( n - qubit_idx - 1 ) )\n", + " \n", + "\n", + "# define the function to perform\n", + "# the Inverse Quantum Fourier Transform (IQFT) on\n", + "# the n qubits of the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE)\n", + "def apply_quantum_fourier_transform_inverse( circuit, n ):\n", + " \n", + " # for each jth qubit on the quantum register\n", + " for j in range(n):\n", + " \n", + " # for each additional mth qubit ranging to\n", + " # the current jth qubit being iterated before\n", + " for m in range(j):\n", + " \n", + " # apply the Controlled-Phase gate for\n", + " # the theta angle equal to -pi / ( 2^( j - m ) ),\n", + " # with control on the mth qubit and target on the jth qubit\n", + " circuit.cp( -np.pi / float( 2**( j - m ) ), m, j )\n", + "\n", + " \n", + " # apply the Hadamard gate to the jth qubit\n", + " circuit.h(j)\n", + "\n", + "\n", + "# define the function to perform a measurement of\n", + "# all the n qubits on the quantum register of a quantum circuit,\n", + "# and storing the classical outcomes on the n bits of\n", + "# the classical register of that same quantum circuit\n", + "def measure_all_qubits( circuit, n ):\n", + " \n", + " # for each pair of qubits and bits\n", + " for j in range(n): \n", + " \n", + " # measure the current qubit on the quantum register,\n", + " # and stores the classical outcome obtained\n", + " # in the current bit on the classical register\n", + " circuit.measure(j, j)\n", + "\n", + "\n", + "# define the function to create a quantum circuit,\n", + "# implementing the Quantum Phase Estimation (QPE) on (n + 1) qubits\n", + "def qpe_circuit(register_size):\n", + " \n", + " #########################################\n", + " \n", + " #### your code goes here ####\n", + " \n", + " \n", + " # define the theta phase angle to estimate\n", + " theta = 1/7\n", + " \n", + " # create the quantum circuit with a quantum register with (n + 1) qubits\n", + " # and a classical register with n bits, intended to implement\n", + " # the Quantum Phase Estimation (QPE) on n qubits\n", + " qpe = QuantumCircuit( ( register_size + 1 ), register_size )\n", + " \n", + " \n", + " # perform the Quantum Hadamard Transform on\n", + " # the n qubits of the quantum register of\n", + " # the quantum circuit implementing\n", + " # the Quantum Phase Estimation (QPE)\n", + " apply_quantum_hadamard_transform( qpe, register_size )\n", + " \n", + " # apply the Pauli-X gate to the last qubit on\n", + " # the quantum register of the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " qpe.x(register_size)\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " qpe.barrier()\n", + " \n", + " \n", + " # perform the Controlled-Phase gates on\n", + " # the n qubits of the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE),\n", + " # as part of the Quantum Fourier Transform (QFT)\n", + " apply_controlled_phases( theta, qpe, register_size )\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " qpe.barrier()\n", + " \n", + " # perform the Swap gates on the n qubits of\n", + " # the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE),\n", + " # as part of the Quantum Fourier Transform (QFT)\n", + " apply_swaps( qpe, register_size )\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " qpe.barrier()\n", + " \n", + " \n", + " # perform the Inverse Quantum Fourier Transform (IQFT) on\n", + " # the n qubits of the quantum register of the quantum circuit\n", + " # implementing the Quantum Phase Estimation (QPE)\n", + " apply_quantum_fourier_transform_inverse( qpe, register_size )\n", + " \n", + " # apply a barrier to the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE)\n", + " qpe.barrier()\n", + " \n", + " \n", + " # perform a measurement of all the n qubits on\n", + " # the quantum register of the quantum circuit of\n", + " # the Quantum Phase Estimation (QPE) and storing\n", + " # the classical outcomes on the n bits of\n", + " # the classical register of that same quantum circuit\n", + " measure_all_qubits( qpe, register_size )\n", + " \n", + " \n", + " # return the quantum circuit, implementing\n", + " # the Quantum Phase Estimation (QPE) on n qubits\n", + " return qpe\n", + " \n", + " #########################################" + ] + }, + { + "cell_type": "markdown", + "id": "a90df2f0-a16c-4741-a095-1cd0f3a980d9", + "metadata": {}, + "source": [ + "Let's try the previous function with several sizes of quantum and classical register, and execute a simulation of the resulting quantum circuits:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "42ec48b0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell to simulate 'qpe' and\n", + "# to plot the histogram of the result\n", + "\n", + "# define several quantum register sizes\n", + "# equal to n, allowing to vary them\n", + "#reg_size = 4\n", + "reg_size = 5\n", + "#reg_size = 6\n", + "#reg_size = 7\n", + "#reg_size = 8\n", + "\n", + "# create a quantum circuit for\n", + "# the Quantum Phase Estimation (QPE),\n", + "# given the quantum register defined before,\n", + "# with n counting qubits\n", + "qpe_check = qpe_circuit( reg_size )\n", + "\n", + "\n", + "# create the Aer Simulator object\n", + "sim = Aer.get_backend(\"aer_simulator\")\n", + "\n", + "# define the number of shots\n", + "shots = 10000\n", + "\n", + "\n", + "# execute the simulation for the Quantum Phase Estimation (QPE),\n", + "# with n counting qubits, and retrieve its result counts\n", + "count_qpe = execute( qpe_check, sim, shots=shots ).result().get_counts()\n", + "\n", + "# plot the histogram of the result counts of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n counting qubits\n", + "plot_histogram( count_qpe, figsize=(9,5) )" + ] + }, + { + "cell_type": "markdown", + "id": "0a7a5290-36e1-4216-9bb7-6c655d3f13e0", + "metadata": {}, + "source": [ + "Let's compute the estimated phase, phase accuracy of the quantum circuit, and the accuracy of the estimated phase, from the previously executed quantum simulation:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c2691d92-19ce-4335-aaab-a7bfd6c15968", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated Phase: 0.03125\n", + "Phase Accuracy Window: 0.03125\n", + "Accuracy of the Estimated Phase: 0.11160714285714285\n" + ] + } + ], + "source": [ + "# process the result count data to determine accuracy of\n", + "# the estimated phase and grab the highest probability measurement\n", + "\n", + "\n", + "# define the maximum number of counts which will be obtained\n", + "max_binary_counts = 0\n", + "\n", + "# define the maximum binary value which will be obtained\n", + "max_binary_val = \"\"\n", + "\n", + "\n", + "# for each count obtained from the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "for key, item in count_qpe.items():\n", + " \n", + " # if the current number of counts is greater than\n", + " # the current maximum number of counts obtained\n", + " if item > max_binary_counts:\n", + " \n", + " # update the maximum number of counts obtained\n", + " max_binary_counts = item\n", + " \n", + " # update the maximum binary value obtained\n", + " max_binary_val = key\n", + "\n", + " \n", + "#########################################\n", + " \n", + "\n", + "#### your function to convert a binary ####\n", + "#### string to a decimal number goes here ####\n", + "\n", + "# define the function to convert\n", + "# a binary string to a decimal number\n", + "def bin_to_decimal( binary_string ):\n", + " \n", + " # return a binary string\n", + " # converted to a decimal number\n", + " return int( binary_string, 2 )\n", + "\n", + "\n", + "# calculate the estimated phase obtained\n", + "# from the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "estimated_phase = ( bin_to_decimal(max_binary_val) / 2**reg_size )\n", + "\n", + "# print the estimated phase obtained\n", + "# from the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "print(\"Estimated Phase:\", estimated_phase)\n", + "\n", + "\n", + "# calculate the phase accuracy\n", + "# which can be obtained from\n", + "# the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "# with the quantum circuit defined before,\n", + "# inverse of the highest power of 2\n", + "# (i.e. smallest decimal) this quantum circuit can estimate\n", + "phase_accuracy_window = 2**( -reg_size )\n", + "\n", + "# print the phase accuracy\n", + "# which can be obtained from\n", + "# the quantum simulation of\n", + "# the Quantum Phase Estimation (QPE)\n", + "# with the quantum circuit defined before,\n", + "# inverse of the highest power of 2\n", + "# (i.e. smallest decimal) this quantum circuit can estimate\n", + "print(\"Phase Accuracy Window:\", phase_accuracy_window)\n", + "\n", + "\n", + "# define the theta phase angle,\n", + "# which was pretended to be estimated\n", + "theta = 1 / 7\n", + "\n", + "# compute the accuracy of the estimated phase,\n", + "# as the distance between the estimated phase \n", + "# and the theta phase angle, which was pretended to be estimated\n", + "accuracy_estimated_phase = abs( theta - estimated_phase )\n", + "\n", + "# print the accuracy of the estimated phase,\n", + "# as the distance between the estimated phase \n", + "# and the theta phase angle, which was pretended to be estimated\n", + "print(\"Accuracy of the Estimated Phase:\", accuracy_estimated_phase)" + ] + }, + { + "cell_type": "markdown", + "id": "065ab0aa-c2c1-44ee-a64e-a914e64c1d03", + "metadata": {}, + "source": [ + "Let's compute the required register size to store the phase information of the Quantum Phase Estimation (QPE) with a accuracy to be within ${2}^{-6}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "190454a7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "### put your answer here ###\n", + "\n", + "# to estimate accurately the phase information to be within 2^(-6)\n", + "# we need n + 1 = 6 (=) n = 5 qubits to store the phase information\n", + "required_register_size = 5" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c08ac980", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "### submit your answer ###\n", + "\n", + "# import the grader for the exercise 4 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex4\n", + "\n", + "# grade the exercise 4 of the lab 3\n", + "grade_lab3_ex4( required_register_size )" + ] + }, + { + "cell_type": "markdown", + "id": "0a450574", + "metadata": {}, + "source": [ + "## Section 2: Shor's Algorithm\n", + "***\n", + "\n", + "Here we will construct a set of functions to implement Shor's algorithm. Remember that the goal of this algorithm is to find the prime factors of some large number $N$ and the key speedup this algorithm provides is by executing the period-finding part using a quantum computer. This is where this section of the lab will focus.\n", + "\n", + "\n", + "Shor's algorithm is composed of the following steps:\n", + "1. Choose a co-prime $a$, where $a\\in [2,N-1]$ and the greatest common divisor of $a$ and $N$ is 1.\n", + "1. Find the order (periodicity) of $a$ modulo $N$, i.e. the smallest integer $r$ such that $a^r\\text{mod} N=1$\n", + "1. Obtain the factor of $N$ by computing the greatest common divisor of $a^{r/2} \\pm 1$ and $N$." + ] + }, + { + "cell_type": "markdown", + "id": "818edadf", + "metadata": {}, + "source": [ + "## Step 1. Period Finding\n", + "\n", + "To begin, we'll use the unitary operator:\n", + "\n", + "$$ U|y\\rangle{} \\equiv |ay\\ \\text{mod} N\\rangle{} $$\n", + "\n", + "\n", + "And explore the superposition state: \n", + "\n", + "$$\n", + "|u\\rangle{} = \\frac{1}{\\sqrt{r}}\\sum_{k=0}^{r-1} e^{-\\frac{2\\pi ik}{r}}|a^k \\text{mod}N\\rangle{}\n", + "$$\n", + "\n", + "Let's pick $a=3$ and $N=35$ as an example and investigate what the action of $U$ is on $|u\\rangle{}$:\n", + "\n", + "\\begin{align}\n", + " U|u\\rangle{} &= U\\frac{1}{\\sqrt{r}}\\left( |1\\rangle{} + e^{-\\frac{2\\pi i}{r}}|3\\rangle{} + e^{\\frac{-4\\pi i}{r}}|9\\rangle{} + ... + e^{\\frac{-20\\pi i}{r}}|4\\rangle{} + e^{\\frac{-22\\pi i}{r}}|12\\rangle{} \\right) \\\\\n", + " & =\\frac{1}{\\sqrt{r}}\\left( U|1\\rangle{} + e^{-\\frac{2\\pi i}{r}}U|3\\rangle{} + e^{\\frac{-4\\pi i}{r}}U|9\\rangle{} + ... + e^{\\frac{-20\\pi i}{r}}U|4\\rangle{} + e^{\\frac{-22\\pi i}{r}}U|12\\rangle{} \\right) \\\\\n", + " &= \\frac{1}{\\sqrt{r}}\\left( |3\\rangle{} + e^{-\\frac{2\\pi i}{r}}|9\\rangle{} + e^{\\frac{-4\\pi i}{r}}|27\\rangle{} + ... + e^{\\frac{-20\\pi i}{r}}|12\\rangle{} + e^{\\frac{-22\\pi i}{r}}|1\\rangle{} \\right) \\\\\n", + " &= \\frac{e^{\\frac{2\\pi i}{r}}}{\\sqrt{r}}\\left( e^{-\\frac{2\\pi i}{r}}|3\\rangle{} + e^{\\frac{-4\\pi i}{r}}|9\\rangle{} + ... + e^{\\frac{-20\\pi i}{r}}|4\\rangle{} + e^{\\frac{-22\\pi i}{r}}|12\\rangle{} + |1\\rangle{} \\right) \\\\\n", + " &= \\frac{e^{\\frac{2\\pi i}{r}}}{\\sqrt{r}} |u\\rangle{}\n", + "\\end{align}\n", + "\n", + "\n", + "This is a particularly helpful eigenvalue as it contains $r$. In fact, it needs to be included in order to ensure the phase differences between the basis states are equal. This is also not the only eigenstate of $U$. For us to generalize further, we can multiply an integer $s$ to each of these phases, which will then show up in our eigenvalue:\n", + "\n", + "\\begin{align}\n", + " |u_s\\rangle{} &= \\frac{1}{\\sqrt{r}}\\sum_{k=0}^{r-1} e^{\\frac{-2\\pi isk}{r}|a^k\\text{mod} N\\rangle{}} \\\\\n", + " U|u_s\\rangle{} &= e^{\\frac{2\\pi is}{r}}|u_s\\rangle{}\n", + "\\end{align}\n", + "\n", + "\n", + "Now we have an eigenstate for each integer $0 \\leq s \\leq r$. Notably, if we add up all of these eigenstates, the phases cancel all other basis states except $|1\\rangle{}$:\n", + "\n", + "$$ \\frac{1}{\\sqrt{r}} \\sum_{s=0}^{r-1}|u_s\\rangle{} = |1\\rangle{} $$\n", + "\n", + "\n", + "Since any state in the computational basis can be written as a linear combination of these eigenstates, if we do QPE on $U$ using the state $|1\\rangle{}$, we will measure a phase:\n", + "\n", + "$$ \\phi = \\frac{s}{r} $$\n", + "\n", + "Where $s$ is a random integer between $0$ and $r-1$. Finally, we can use a method called the continued fraction algorithm on $\\phi$ in order to find r. The final circuit will look something like this:\n", + "\n", + "\n", + "\"Shor\n", + "\n", + "***" + ] + }, + { + "cell_type": "markdown", + "id": "6fdd37ac-0a87-4a55-9499-13ce9eabf9ef", + "metadata": {}, + "source": [ + "
Ex. 5 - Create a quantum circuit to solve the Period Finding Problem (with $a=7$ and $N=15$).
" + ] + }, + { + "cell_type": "markdown", + "id": "03df2e95", + "metadata": {}, + "source": [ + "Below we'll provide the unitary $U$ needed for solving this period finding problem with $a=7$ and $N=15$:\n", + "\n", + "$$ \n", + " U|y\\rangle{} = |7y\\ \\text{mod}\\ 15\\rangle{}\n", + "$$\n", + "\n", + "To create $U^x$ we will simply repeat the circuit $x$ times. The cell below will construct this unitary:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f44d5c01", + "metadata": {}, + "outputs": [], + "source": [ + "# create 7 mod 15 unitary operator\n", + "# for a quantum circuit\n", + "N = 15\n", + "\n", + "# define the number of m qubits required\n", + "# for the 7 mod 15 operator to be executed\n", + "m = int( np.ceil( np.log2( N ) ) )\n", + "\n", + "# create the quantum circuit with\n", + "# a quantum register of m qubits\n", + "# to implement the 7 mod 15 unitary operator\n", + "U_qc = QuantumCircuit( m )\n", + "\n", + "\n", + "# apply the Pauli-X gate to all the m qubits of\n", + "# the quantum register of the quantum circuit\n", + "# implementing the 7 mod 15 unitary operator\n", + "U_qc.x( range(m) )\n", + "\n", + "\n", + "# apply the Swap gate between the 2nd qubit and\n", + "# the 3rd qubit on the quantum register of\n", + "# the quantum circuit implementing\n", + "# the 7 mod 15 unitary operator\n", + "U_qc.swap(1, 2)\n", + "\n", + "# apply the Swap gate between the 3rd qubit and\n", + "# the 4th qubit on the quantum register of\n", + "# the quantum circuit implementing\n", + "# the 7 mod 15 unitary operator\n", + "U_qc.swap(2, 3)\n", + "\n", + "# apply the Swap gate between the 1st qubit and\n", + "# the 4th qubit on the quantum register of\n", + "# the quantum circuit implementing\n", + "# the 7 mod 15 unitary operator\n", + "U_qc.swap(0, 3)\n", + "\n", + "\n", + "# convert the quantum circuit implementing\n", + "# the 7 mod 15 unitary operator to\n", + "# a quantum unitary gate \n", + "U = U_qc.to_gate()\n", + "\n", + "\n", + "# define the name of the 7 mod 15\n", + "# unitary operator created before\n", + "U.name =\"{}Mod{}\".format(7, N)" + ] + }, + { + "cell_type": "markdown", + "id": "755e83e3", + "metadata": {}, + "source": [ + "Confirm if the operator $U$ works as intended by creating a quantum circuit with $m=4$ qubits. Prepare the inpute state $|y\\rangle{}$ representing any integer between $0$ and $15$ (remembering that Qiskit uses little endian notation) such as $|1\\rangle{} = |0001\\rangle{}$,
$|5\\rangle{} = |0101\\rangle{}$, etc. and apply $U|y\\rangle{}$. Check if the circuit produces the expected outcomes for several inputs: $|1\\rangle{}$, $|2\\rangle{}$, and $|5\\rangle{}$. (For example, the outcome for input state $|2\\rangle{}$ should be $|14\\rangle{}=|1110\\rangle{}$)." + ] + }, + { + "cell_type": "markdown", + "id": "61461a72-c321-4fea-afce-0f02bc7bc3c9", + "metadata": {}, + "source": [ + "Run these quantum circuits through the `aer_simulator` backend with $20000$ shots, save the count data as `input_1`, `input_2`, and `input_5`:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2413af6c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num. qubits: m = 4\n" + ] + } + ], + "source": [ + "# your code goes here\n", + "\n", + "# print the number of qubits\n", + "print(\"Num. qubits: m =\", m);\n", + "\n", + "\n", + "\n", + "# define the quantum circuits for the inputs\n", + "# |1> = |0001>, |2> = |0010>, and |5> = |0101>\n", + "\n", + "\n", + "#########################################\n", + "\n", + "\n", + "# create the a quantum circuit with m qubits,\n", + "# for the input state |1> = |0001>\n", + "qcirc_input_1 = QuantumCircuit(m)\n", + "\n", + "# apply the Pauli-X gate to\n", + "# the 1st qubit of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_1.x(0)\n", + "\n", + "# apply the U gate to all\n", + "# the m qubits of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_1.append( U, range(m) )\n", + "\n", + "# measure all the m qubits of\n", + "# the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_1.measure_all()\n", + "\n", + "\n", + "#########################################\n", + "\n", + "\n", + "# create the a quantum circuit with m qubits,\n", + "# for input state |2> = |0010>\n", + "qcirc_input_2 = QuantumCircuit(m)\n", + "\n", + "# apply the Pauli-X gate to\n", + "# the 2nd qubit of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_2.x(1)\n", + "\n", + "# apply the U gate to all\n", + "# the m qubits of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_2.append( U, range(m) )\n", + "\n", + "# measure all the m qubits of\n", + "# the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_2.measure_all()\n", + "\n", + "\n", + "#########################################\n", + "\n", + "\n", + "# create the a quantum circuit with m qubits,\n", + "# for input state |5> = |0101>\n", + "qcirc_input_5 = QuantumCircuit(m)\n", + "\n", + "# apply the Pauli-X gate to\n", + "# the 1st qubit of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_5.x(0)\n", + "\n", + "# apply the Pauli-X gate to\n", + "# the 3rd qubit of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_5.x(2)\n", + "\n", + "# apply the U gate to all\n", + "# the m qubits of the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_5.append( U, range(m) )\n", + "\n", + "# measure all the m qubits of\n", + "# the quantum register of\n", + "# the quantum circuit defined before\n", + "qcirc_input_5.measure_all()\n", + "\n", + "\n", + "#########################################" + ] + }, + { + "cell_type": "markdown", + "id": "01aebfd7-b3e6-4289-aa14-f1fa047e989d", + "metadata": {}, + "source": [ + "Let's execute the quantum simulation for the input quantum states defined before:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "64292ddb", + "metadata": {}, + "outputs": [], + "source": [ + "# run this cell to simulate 'qcirc' and to plot the histogram of the result\n", + "\n", + "# create the Aer Simulator object\n", + "sim = Aer.get_backend(\"aer_simulator\")\n", + "\n", + "# define the number of shots\n", + "shots = 20000\n", + "\n", + "# save the count data for the input state |1> = |0001>\n", + "input_1 = execute(qcirc_input_1, sim, shots=shots).result().get_counts()\n", + "\n", + "# save the count data for the input state |2> = |0010>\n", + "input_2 = execute(qcirc_input_2, sim, shots=shots).result().get_counts()\n", + "\n", + "# save the count data for the input state |5> = |0101>\n", + "input_5 = execute(qcirc_input_5, sim, shots=shots).result().get_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fc5f5437", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 5 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex5\n", + "\n", + "# grade the exercise 5 of the lab 3\n", + "grade_lab3_ex5( [ input_1, input_2, input_5 ] )" + ] + }, + { + "cell_type": "markdown", + "id": "c0b545ec", + "metadata": {}, + "source": [ + "## Step 2. Implementing $U^{2^{m-1}}$\n", + "\n", + "Now we'll use this controlled-$U$ to estimate the phase $\\phi=\\frac{s}{r}$. But first, a quick point to note here. It turns out a sequence of `7Mod15` gates produce the identity when executed by a multiple of 4 times. To test this, create a quantum circuit implementing the `7mod15` gate $2^2$ times and run it on the `unitary_simulator` backend to obtain the matrix represenation of the gates in the circuit. Verify $U^{2^2}=I$." + ] + }, + { + "cell_type": "markdown", + "id": "fcb69e74-ba1d-4992-85bc-19710cbb3bfb", + "metadata": {}, + "source": [ + "
Ex. 6 - Create a quantum circuit for the Quantum Phase Estimation (QPE) of the phase angle $\\phi$.
" + ] + }, + { + "cell_type": "markdown", + "id": "e320b3c8-e35b-49ef-89c5-caf53887ca55", + "metadata": {}, + "source": [ + "Let's create the unitary quantum circuit for the Quantum Phase Estimation (QPE) of the phase angle $\\phi$:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "28ef3fd2", + "metadata": {}, + "outputs": [], + "source": [ + "# create an unitary quantum circuit\n", + "# with a quantum register of m qubits\n", + "unitary_circ = QuantumCircuit(m)\n", + "\n", + "\n", + "#### your code goes here ####\n", + "\n", + "# for each iteration in a range of 2^2 = 4\n", + "for _ in range( 2**2 ):\n", + " \n", + " # apply the U gate on all\n", + " # the m qubits on the quantum register\n", + " unitary_circ.append( U, range(m) )" + ] + }, + { + "cell_type": "markdown", + "id": "956fabba-7063-4966-bed1-cd39f7f218fe", + "metadata": {}, + "source": [ + "Let's execute the unitary quantum circuit created for the Quantum Phase Estimation (QPE) of the phase angle $\\phi$ on the ``unitary_simulator``:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "5ba2ce23", + "metadata": {}, + "outputs": [], + "source": [ + "# create a Unitary Simulator object\n", + "sim = Aer.get_backend(\"unitary_simulator\")\n", + "\n", + "# execute the quantum simulation of\n", + "# an unitary quantum circuit with\n", + "# a quantum register of m qubits,\n", + "# defined before, retrieving its unitary operator\n", + "unitary = execute( unitary_circ, sim ).result().get_unitary()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "fef158df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 6 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex6\n", + "\n", + "# grade the exercise 6 of the lab 3\n", + "grade_lab3_ex6( unitary, unitary_circ )" + ] + }, + { + "cell_type": "markdown", + "id": "b80f494e", + "metadata": {}, + "source": [ + "## Step 3. Finding $\\phi$ and Continued Fractions\n", + "\n", + "\n", + "Now armed with a way to execute $U^{2^{m-1}}$, let's use it in the QPE circuit you created earlier. Below is a function to construct a controlled-$U$ gate. Use $8$ qubits for the phase register and 4 qubits for the register which $U$ will act on, using the `aer_simulator` again, estimate the phase $\\phi$ given an input state of $|0\\rangle{}$.\n", + "\n", + "*Hint: at each step in the QPE circuit, you'll need to construct a new `cU_multi` circuit and append it to the QPE circuit. There will be several estimates that have approximately equal probability.*" + ] + }, + { + "cell_type": "markdown", + "id": "2826b389-1c0a-4908-8d5a-01f7c93e75a7", + "metadata": {}, + "source": [ + "
Ex. 7 - Create a quantum circuit that implements the Quantum Phase Estimation (QPE) for the Shor's Algorithm.
" + ] + }, + { + "cell_type": "markdown", + "id": "b38a0bf0-774e-4fa1-a8a5-46eb3e34ac4b", + "metadata": {}, + "source": [ + "Let's create the ${2}^{k}$-Controlled-$U$ gate to be applied on 4 qubits for the quantum register, on which the gate $U$ will act on:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "71b9775b", + "metadata": {}, + "outputs": [], + "source": [ + "# define the function to built a 2^k-Controlled-U gate object,\n", + "# which repeats the action of the operator U, 2^k times\n", + "def cU_multi(k):\n", + " \n", + " # define the size n of the system's quantum register\n", + " sys_register_size = 4\n", + " \n", + " # create the quantum circuit with n qubits on\n", + " # the system's quantum register, to build\n", + " # a 2^k-Controlled-U gate object\n", + " circ = QuantumCircuit( sys_register_size )\n", + " \n", + " \n", + " # for each iteration ranging until 2^k\n", + " for _ in range(2**k):\n", + " \n", + " # apply the U gate to all the n qubits on\n", + " # the system's quantum register of\n", + " # the quantum circuit to represent\n", + " # the 2^k-Controlled-U gate\n", + " circ.append(U, range(sys_register_size))\n", + " \n", + " \n", + " # convert the operator resulting from the construction of\n", + " # the quantum circuit defined before, to a quantum gate\n", + " U_multi = circ.to_gate()\n", + " \n", + " \n", + " # define the name of the 2^k-Controlled-U gate,\n", + " # as being a \"7 Mod 15 gate\"\n", + " U_multi.name = \"7Mod15_[2^{}]\".format(k)\n", + " \n", + " # set this 2^k-Controlled-U gate as multi-qubit gate,\n", + " # depending on a given control qubit\n", + " cU_multi = U_multi.control()\n", + " \n", + " \n", + " # return the 2^k-Controlled-U gate object,\n", + " # which repeats the action of the operator U, 2^k times\n", + " return cU_multi" + ] + }, + { + "cell_type": "markdown", + "id": "47f0a1aa-e415-40ec-bdfa-75deeda64f63", + "metadata": {}, + "source": [ + "Let's implement the quantum circuit for the Shor's Algorithm, based on Quantum Phase Estimation (QPE), with $m = 8$ phase counting qubits and $n = 4$ qubits on which will be applied successively the ${2}^{k}$-Controlled-$U$ gate:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "8f0f482f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define the size m of the quantum register\n", + "# for the phase counting of the qubits\n", + "phase_register_size = 8\n", + "\n", + "# define the size n of the quantum register\n", + "# for the successive applications of\n", + "# the 2^k-Controlled-U gate defined before\n", + "cu_register_size = 4\n", + "\n", + "\n", + "# create the Quantum Circuit needed to run\n", + "# with m = 8 qubits for the phase counting\n", + "# and with n = 4 qubits for the successive\n", + "# applications of the 2^k-Controlled-U gate\n", + "# defined before, to implement the Shor's Algorithm\n", + "# for Factoring, based on Quantum Phase Estimation (QPE)\n", + "shor_qpe = QuantumCircuit( ( phase_register_size + cu_register_size ),\n", + " phase_register_size )\n", + "\n", + "\n", + "# perform the Quantum Hadamard Transform on\n", + "# the m qubits for the phase counting of\n", + "# the quantum register of the quantum circuit\n", + "# implementing the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "apply_quantum_hadamard_transform( shor_qpe, phase_register_size )\n", + "\n", + "# apply the Pauli-X gate to the last qubit on\n", + "# the quantum register of the quantum circuit to\n", + "# implement the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "shor_qpe.x( phase_register_size )\n", + "\n", + "# apply a barrier to the quantum circuit to\n", + "# implement the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "shor_qpe.barrier()\n", + "\n", + "\n", + "# for each kth qubit on the quantum register \n", + "# for the phase counting of the qubits\n", + "for k in range( phase_register_size ):\n", + " \n", + " # retrieve the 2^k-Controlled-U gate object,\n", + " # which repeats the action of the operator U,\n", + " # 2^k times, defined before\n", + " cU = cU_multi(k)\n", + " \n", + " # apply the 2^k-Controlled-U gate object,\n", + " # which repeats the action of the operator U,\n", + " # 2^k times, defined before, for the kth iteration,\n", + " # to the quantum circuit to implement\n", + " # the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE)\n", + " shor_qpe.append( cU, [k] + list( range( phase_register_size,\n", + " ( phase_register_size + cu_register_size ) ) ) )\n", + "\n", + "\n", + "# apply a barrier to the quantum circuit to\n", + "# implement the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE) \n", + "shor_qpe.barrier()\n", + "\n", + "# perform the Swap gates on the n qubits of\n", + "# the quantum register of the quantum circuit\n", + "# implementing the Quantum Phase Estimation (QPE),\n", + "# as part of the Quantum Fourier Transform (QFT),\n", + "# required to build the quantum circuit to implement\n", + "# the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE) \n", + "apply_swaps(shor_qpe, phase_register_size)\n", + "\n", + "# apply a barrier to the quantum circuit to\n", + "# implement the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "shor_qpe.barrier()\n", + "\n", + "\n", + "# perform the Inverse Quantum Fourier Transform (IQFT) on\n", + "# the m qubits for the phase counting of\n", + "# the quantum register of the quantum circuit\n", + "# implementing the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "apply_quantum_fourier_transform_inverse( shor_qpe, phase_register_size )\n", + "\n", + "\n", + "# apply a barrier to the quantum circuit to\n", + "# implement the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "shor_qpe.barrier()\n", + "\n", + "\n", + "# perform a measurement of all\n", + "# the m qubits for the phase counting of\n", + "# the quantum register of the quantum circuit\n", + "# implementing the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "shor_qpe.measure( range( phase_register_size ),\n", + " range( phase_register_size ) )\n", + "\n", + "\n", + "# draw the quantum circuit implementing\n", + "# the quantum circuit to\n", + "# implement the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE)\n", + "shor_qpe.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "813b76e4-9f53-4953-be62-bd87e3e89ac5", + "metadata": {}, + "source": [ + "Let's run the quantum simulation of the quantum circuit for the Shor's Algorithm, based on Quantum Phase Estimation (QPE), with $m = 8$ phase counting qubits:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f25f9d0b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# run this cell to simulate 'shor_qpe' and\n", + "# to plot the histogram of the results\n", + "\n", + "\n", + "# create an Aer Simulator object\n", + "sim = Aer.get_backend(\"aer_simulator\")\n", + "\n", + "# define the number of shots\n", + "shots = 20000\n", + "\n", + "\n", + "# execute the quantum simulation for\n", + "# the quantum circuit for the Shor's Algorithm,\n", + "# based on Quantum Phase Estimation (QPE),\n", + "# with n phase counting qubits, and retrieve\n", + "# the result counts of this quantum simulation\n", + "shor_qpe_counts = execute(shor_qpe, sim, shots=shots).result().get_counts()\n", + "\n", + "# plot the histogram of the result counts of the quantum simulation\n", + "# for the quantum circuit for the Shor's Algorithm, based on\n", + "# Quantum Phase Estimation (QPE), with n phase counting qubits\n", + "plot_histogram( shor_qpe_counts, figsize=(9,5) )" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "20888bbf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 7 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex7\n", + "\n", + "# grade the exercise 7 of the lab 3\n", + "grade_lab3_ex7( shor_qpe_counts )" + ] + }, + { + "cell_type": "markdown", + "id": "94c8b2c0", + "metadata": {}, + "source": [ + "We can then find the integers $s$ and $r$ using the continued fractions algorithm. Luckily python has built-in functionality for this using the `Fraction` function, where we will limit the denominator to $r<15$. Use this to find the estimated $s$ and $r$ for each outcome you measured above." + ] + }, + { + "cell_type": "markdown", + "id": "51923e83-7afa-4938-ba11-fa0933f12756", + "metadata": {}, + "source": [ + "Let's try the function to build ``Fraction`` objects in Python:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "fc619b09", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unlimited Fraction(0.666): 5998794703657501/9007199254740992 \n", + "\n", + "Limited Fraction(0.666), with a max. denominator of 15: 2/3\n" + ] + } + ], + "source": [ + "# import the Fraction object\n", + "# from the built-in fractions module\n", + "from fractions import Fraction\n", + "\n", + "\n", + "# print the number '0.666',\n", + "# as an unlimited Fraction object\n", + "print( \"Unlimited Fraction(0.666):\",\n", + " Fraction(0.666), '\\n')\n", + "\n", + "# print the number '0.666',\n", + "# as a limited Fraction object\n", + "# with the denominator of 15\n", + "print( \"Limited Fraction(0.666), with a max. denominator of 15:\",\n", + " Fraction(0.666).limit_denominator(15) )" + ] + }, + { + "cell_type": "markdown", + "id": "ef44a8bd-3bc3-4411-8cad-6d5d88bac116", + "metadata": {}, + "source": [ + "
Ex. 8 - Compute the estimated fractions obtained from the Shor's Algorithm for Factoring, based on Quantum Phase Estimation (QPE).
" + ] + }, + { + "cell_type": "markdown", + "id": "f885c631-7793-4185-94d3-2f8def1a86c9", + "metadata": {}, + "source": [ + "Let's compute the estimated fractions obtained from the Shor's Algorithm for Factoring, based on Quantum Phase Estimation (QPE), built before:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0cd183a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated Phases: [0.5, 0.75, 0.25, 0.0]\n", + "Estimated Fractions: [Fraction(1, 2), Fraction(3, 4), Fraction(1, 4), Fraction(0, 1)]\n" + ] + } + ], + "source": [ + "# create a list with the estimated phases of the result counts\n", + "# obtained from the execution of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n counting qubits\n", + "estimated_phases = [ bin_to_decimal(binary_val) / 2**phase_register_size\n", + " for binary_val in shor_qpe_counts ]\n", + "\n", + "# print the list with the estimated phases of the result counts\n", + "# obtained from the execution of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n counting qubits\n", + "print( \"Estimated Phases:\", estimated_phases )\n", + "\n", + "\n", + "# create a list of with the estimated phases of the result counts\n", + "# obtained from the execution of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n counting qubits,\n", + "# represented as Fraction objects with the format s/r\n", + "shor_qpe_fractions = [ Fraction(estimated_phase).limit_denominator(15)\n", + " for estimated_phase in estimated_phases ]\n", + "\n", + "# print the list of with the estimated phases of the result counts\n", + "# obtained from the execution of the quantum simulation\n", + "# for the Quantum Phase Estimation (QPE), with n counting qubits,\n", + "# represented as Fraction objects with the format s/r\n", + "print( \"Estimated Fractions:\", shor_qpe_fractions )" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "64f3ab41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your answer\n", + "\n", + "# import the grader for the exercise 8 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex8\n", + "\n", + "# grade the exercise 8 of the lab 3\n", + "grade_lab3_ex8( shor_qpe_fractions )" + ] + }, + { + "cell_type": "markdown", + "id": "151c485d-48d5-461b-82d1-dafc5d9c905f", + "metadata": {}, + "source": [ + "
Ex. 9 - Build the Shor's Algorithm for Factoring, based on Quantum Phase Estimation (QPE).
" + ] + }, + { + "cell_type": "markdown", + "id": "7be59ad2", + "metadata": {}, + "source": [ + "## Step 4. Putting it all together\n", + "\n", + "Now let's put all of these steps together in order to factor the (very simple) number, $N = 15$. We'll continue with our example of $a=7$, remember that the phase we measure $s/r$ where $s$ is a random integer between $0$ and $r-1$ and:\n", + "\n", + "$$\n", + " a^r\\text{mod}N = 1\n", + "$$\n", + "\n", + "Then, once we have $r$, we can find a factor of $N$ by:\n", + "\n", + "$$\n", + " \\left(a^r-1\\right)\\text{mod} N = 0\n", + "$$\n", + "which requires that $N$ must divide by $a^r-1$. If $r$ is even, we can also write\n", + "\n", + "$$\n", + " a^r-1 = \\left(a^{r/2}+1\\right)\\left(a^{r/2}-1\\right).\n", + "$$\n", + "\n", + "Put together a function called `shor_qpe` which takes an argument for $k$ (the number of counting qubits) and composes, runs, and processes Shor's algorithm to guess the factors. Use an input state of $|y\\rangle{}=|1\\rangle{}$ for the phase estimation. (Note: The function `cU_multi()` only executes $|ay\\ \\text{mod}\\ 15\\rangle{}$ for $a=7$)" + ] + }, + { + "cell_type": "markdown", + "id": "141bf124-bb0d-46c3-9657-6cf253610fc8", + "metadata": {}, + "source": [ + "Let's build the complete Shor's Algorithm for Factoring, based on the Quantum Phase Estimation, for the factoring problem proposed above:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "5be23ac1", + "metadata": {}, + "outputs": [], + "source": [ + "# define the function to create and execute\n", + "# the Shor's Algorithm for Factoring,\n", + "# based on Quantum Phase Estimation (QPE),\n", + "# with k phase counting qubits\n", + "def shor_qpe(k):\n", + "\n", + " # define the co-prime a\n", + " a = 7\n", + " \n", + " # define the number N to factor\n", + " N = 15\n", + " \n", + " # compute the number m of\n", + " # additional qubits required\n", + " m = int( np.ceil( np.log2(N) ) )\n", + " \n", + " \n", + " #################################################\n", + " \n", + " # step 1. Begin a while loop until a nontrivial guess is found\n", + " #### your code goes here ####\n", + " \n", + " # define the boolean flag to determine\n", + " # if a non trivial guess was found, initially as False\n", + " non_trivial_guess_found = False\n", + " \n", + " \n", + " # while no trivial factor guess was found,\n", + " # execute the while loop\n", + " while( not non_trivial_guess_found ):\n", + " \n", + " \n", + " #################################################\n", + "\n", + " # step 2a. construct a QPE quantum circuit\n", + " # with m phase counting qubits to guess\n", + " # the phase phi = s/r, using the function\n", + " # cU_multi() defined before\n", + " \n", + " \n", + " #### your code goes here ####\n", + " \n", + " # create a quantum circuit for\n", + " # the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE),\n", + " # with k phase counting qubits,\n", + " # and additional m qubits for\n", + " # the successive applications of\n", + " # the 2^k-Controlled-U gate defined before\n", + " qc = QuantumCircuit( ( k + m ), k)\n", + " \n", + " \n", + " # perform the Quantum Hadamard Transform on\n", + " # the k phase counting qubits of the respective\n", + " # quantum register of the quantum circuit\n", + " # for the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE)\n", + " apply_quantum_hadamard_transform( qc, k )\n", + " \n", + " # apply a Pauli-X gate to the last\n", + " # phase counting qubit of the respective\n", + " # quantum register of the quantum circuit\n", + " # for the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE)\n", + " qc.x(k)\n", + "\n", + " # apply a barrier to the quantum circuit for\n", + " # the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE),\n", + " # with k phase counting qubits,\n", + " # and additional m qubits for\n", + " # the successive applications of\n", + " # the 2^k-Controlled-U gate defined before\n", + " qc.barrier()\n", + " \n", + " \n", + " # for each kth qubit on the quantum register \n", + " # for the phase counting of the qubits\n", + " for k_i in range(k):\n", + "\n", + " # retrieve the 2^k-Controlled-U gate object,\n", + " # which repeats the action of the operator U,\n", + " # 2^k times, defined before\n", + " cU = cU_multi(k_i)\n", + " \n", + " # apply the 2^k-Controlled-U gate object,\n", + " # which repeats the action of the operator U,\n", + " # 2^k times, defined before, for the kth iteration,\n", + " # to the quantum circuit for the Shor's Algorithm\n", + " # for Factoring, based on Quantum Phase Estimation (QPE),\n", + " # with k phase counting qubits, and additional m qubits\n", + " # for the successive applications of\n", + " # the 2^k-Controlled-U gate defined before\n", + " qc.append( cU, [k_i] + list( range( k, ( k + m ) ) ) )\n", + "\n", + " \n", + " # apply a barrier to the quantum circuit for\n", + " # the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE),\n", + " # with k phase counting qubits,\n", + " # and additional m qubits for\n", + " # the successive applications of\n", + " # the 2^k-Controlled-U gate defined before\n", + " qc.barrier()\n", + " \n", + " # perform the Swap gates on the k\n", + " # phase counting qubits of the respective\n", + " # quantum register of the quantum circuit\n", + " # for the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE),\n", + " # as part of the Quantum Fourier Transform (QFT)\n", + " apply_swaps( qc, k )\n", + "\n", + " # apply a barrier to the quantum circuit for\n", + " # the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE),\n", + " # with k phase counting qubits,\n", + " # and additional m qubits for\n", + " # the successive applications of\n", + " # the 2^k-Controlled-U gate defined before\n", + " qc.barrier()\n", + " \n", + " \n", + " # perform the Inverse Quantum Fourier Transform (IQFT) on\n", + " # the k phase counting qubits of the respective\n", + " # quantum register of the quantum circuit\n", + " # for the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE)\n", + " apply_quantum_fourier_transform_inverse( qc, k )\n", + "\n", + " # apply a barrier to the quantum circuit for\n", + " # the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE),\n", + " # with k phase counting qubits,\n", + " # and additional m qubits for\n", + " # the successive applications of\n", + " # the 2^k-Controlled-U gate defined before\n", + " qc.barrier()\n", + " \n", + " \n", + " # perform a measurement of all\n", + " # the k phase counting qubits of the respective\n", + " # quantum register of the quantum circuit\n", + " # for the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE)\n", + " qc.measure( range(k), range(k) )\n", + " \n", + " \n", + " #################################################\n", + " \n", + " \n", + " # step 2b. run the QPE quantum circuit with a single shot,\n", + " # record the results and convert the estimated phase\n", + " # bitstring to a decimal format\n", + " \n", + " \n", + " #### your code goes here ####\n", + " \n", + " # create an Aer Simulator object\n", + " sim = Aer.get_backend(\"aer_simulator\")\n", + " \n", + " \n", + " # define the number of shots\n", + " shots = 1\n", + " \n", + " \n", + " # execute the simulation for the Quantum Phase Estimation (QPE),\n", + " # with n counting qubits, and retrieve the result counts\n", + " # obtained from this quantum simulation\n", + " shor_qpe_counts = execute( qc, sim, shots=shots ).result().get_counts()\n", + " \n", + " \n", + " # plot the histogram of the result counts of the quantum simulation\n", + " # for the Quantum Phase Estimation (QPE), with n counting qubits\n", + " plot_histogram( shor_qpe_counts, figsize=(9,5) )\n", + " \n", + " \n", + " # compute the estimated phases from the result counts\n", + " # obtained from the quantum simulation of the quantum circuit\n", + " # implementing the Shor's Algorithm for Factoring,\n", + " # based on Quantum Phase Estimation (QPE)\n", + " estimated_phases = [ bin_to_decimal( binary_val ) / 2**k\n", + " for binary_val in shor_qpe_counts ]\n", + " \n", + " \n", + " #################################################\n", + "\n", + " \n", + " # step 3. use the Fraction object to find the guess for r\n", + " \n", + " #### your code goes here ####\n", + "\n", + " # convert the estimated phase to a fraction s/r format\n", + " fraction_s_r = [ Fraction(estimated_phase).limit_denominator(N)\n", + " for estimated_phase in estimated_phases ][0]\n", + " \n", + " # retrieve the numerator s and the denominator r\n", + " # from the estimated phase represented as a fraction\n", + " s, r = fraction_s_r.numerator, fraction_s_r.denominator\n", + " \n", + " \n", + " #################################################\n", + " \n", + " \n", + " # step 4. now that r has been found, use the built-in\n", + " # greatest common divisor function to determine\n", + " # the guesses for a factor of N\n", + " \n", + " # build the list of guesses for possible non-trivial factors of N\n", + " guesses = [ gcd( a**( r // 2 ) - 1, N ),\n", + " gcd( a**( r // 2 ) + 1, N ) ]\n", + " \n", + " \n", + " #################################################\n", + " \n", + " \n", + " # step 5. for each guess in guesses, check if\n", + " # at least one is a non-trivial factor,\n", + " # i.e., ( ( guess != 1 ) or ( guess != N ) )\n", + " # and ( N % guess == 0 )\n", + " \n", + " #### your code goes here ####\n", + " \n", + " # for each of the guesses computed before\n", + " for guess in guesses:\n", + " \n", + " # if the current guess is not a trivial factor\n", + " if ( ( ( guess != 1 ) or ( guess != N ) )\n", + " and ( N % guess == 0 ) ):\n", + " \n", + " # update the boolean flag to determine\n", + " # if a non trivial guess was found, as True\n", + " non_trivial_guess_found = True\n", + " \n", + " # break the current for loop\n", + " break\n", + " \n", + " \n", + " #################################################\n", + " \n", + " # step 6. if a non-trivial factor is found return\n", + " # the list 'guesses', otherwise\n", + " # continue the while loop\n", + " \n", + " # return the list of the guesses,\n", + " # containing a non-trivial factor of N\n", + " return guesses\n", + " \n", + " #################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "03a369ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitting your answer. Please wait...\n", + "Congratulations 🎉! Your answer is correct and has been submitted.\n" + ] + } + ], + "source": [ + "# submit your circuit\n", + "\n", + "# import the grader for the exercise 9 of the lab 3\n", + "from qc_grader.challenges.qgss_2023 import grade_lab3_ex9\n", + "\n", + "# grade the exercise 9 of the lab 3\n", + "grade_lab3_ex9( shor_qpe )" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "c95af0f3-8c55-4c3c-9291-10bd8a1faa2e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.24.1
qiskit-aer0.12.1
qiskit-ibmq-provider0.20.2
qiskit0.43.2
qiskit-nature0.6.2
qiskit-finance0.3.4
qiskit-optimization0.5.0
qiskit-machine-learning0.6.1
System information
Python version3.10.8
Python compilerGCC 10.4.0
Python buildmain, Nov 22 2022 08:26:04
OSLinux
CPUs8
Memory (Gb)31.211322784423828
Wed Aug 02 17:17:13 2023 UTC
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import the IBM's Qiskit Jupyter Tools\n", + "import qiskit.tools.jupyter\n", + "\n", + "# show the table of the IBM's Qiskit version\n", + "%qiskit_version_table" + ] + }, + { + "cell_type": "markdown", + "id": "6a1e61fd", + "metadata": {}, + "source": [ + "Congratulations! You've completed Lab 3 of the Global Summer School!! 🎉\n", + "\n", + "This lab was adapted from both the [Qiskit QPE Lab](https://learn.qiskit.org/course/ch-labs/lab-5-accuracy-of-quantum-phase-estimation#lab-3-0) as well as the [Qiskit Shor's Algorithm](https://learn.qiskit.org/course/ch-labs/lab-7-scalable-shors-algorithm) lab." + ] + }, + { + "cell_type": "markdown", + "id": "d7eb40e3-2737-42d0-97f7-0ae1006b0908", + "metadata": {}, + "source": [ + "Made with ❤ by Rúben André Barreiro (and adapted from IBM Quantum)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "047901446fe745fd944f3b7a1c91ff79": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_2243d93ce5134a40ab799df08f66b497", + "style": "IPY_MODEL_bc70c43c2b974d158821f8e30f8261a3", + "value": "
Status
" + } + }, + "0de53a9200bf4a0cacbb10371b370b80": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_2c7701a6300c4a0495b360e343e8a1e9" + ], + "layout": "IPY_MODEL_3169fb47c9024692b2321a6c632c4504" + } + }, + "2243d93ce5134a40ab799df08f66b497": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "27a9fe66885946829c075227d4a90530": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "2c7701a6300c4a0495b360e343e8a1e9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_568a487adc4240be98d24420fa48c7e0", + "style": "IPY_MODEL_e8dba497e8694267ad38dc566aed53d8", + "tooltip": null + } + }, + "306aadb01d6b4e1ebb08ff594af92d21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": {} + }, + "3169fb47c9024692b2321a6c632c4504": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "38a15edf53664ac3a879eb457ada71ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_3d77e30305dc4a87bc642964d831d240", + "style": "IPY_MODEL_f1b8153e15f94d5ea2e93382173cd785", + "value": "
Queue
" + } + }, + "3a80a7ac9f734095bf0ac57308e3602d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_27a9fe66885946829c075227d4a90530", + "style": "IPY_MODEL_bc856143b8b14b239766abef697a5777", + "value": "
Backend
" + } + }, + "3d77e30305dc4a87bc642964d831d240": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "44564b757fc54611b33c05f1a0e11d0a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4495e851479d4fa7a0631abb1d3b9d31": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f1fb01470de44d0cb6da2ad979ed9745", + "style": "IPY_MODEL_92b8a242ea26479da547a3d059bb2faf", + "value": "
Job ID
" + } + }, + "568a487adc4240be98d24420fa48c7e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + }, + "7afdab9537994bafa4c679b3b067b88a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_306aadb01d6b4e1ebb08ff594af92d21", + "style": "IPY_MODEL_def803f9b4124ccd93af8445cdd210eb", + "value": "
Message
" + } + }, + "92b8a242ea26479da547a3d059bb2faf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aa2740979b364dab97828d117ea2a3fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "af9359098981440b9519bc55cca26882": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_4495e851479d4fa7a0631abb1d3b9d31", + "IPY_MODEL_3a80a7ac9f734095bf0ac57308e3602d", + "IPY_MODEL_047901446fe745fd944f3b7a1c91ff79", + "IPY_MODEL_38a15edf53664ac3a879eb457ada71ac", + "IPY_MODEL_7afdab9537994bafa4c679b3b067b88a" + ], + "layout": "IPY_MODEL_aa2740979b364dab97828d117ea2a3fc" + } + }, + "bc70c43c2b974d158821f8e30f8261a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "bc856143b8b14b239766abef697a5777": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "cfe4b2f7edad4620abc9208d6f16b2dc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d749d94c52e6406d97d0297759c43615", + "style": "IPY_MODEL_44564b757fc54611b33c05f1a0e11d0a", + "value": "

Circuit Properties

" + } + }, + "d749d94c52e6406d97d0297759c43615": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "def803f9b4124ccd93af8445cdd210eb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e8dba497e8694267ad38dc566aed53d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ButtonStyleModel", + "state": { + "font_family": null, + "font_size": null, + "font_style": null, + "font_variant": null, + "font_weight": null, + "text_color": null, + "text_decoration": null + } + }, + "f1b8153e15f94d5ea2e93382173cd785": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f1fb01470de44d0cb6da2ad979ed9745": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/IBM Quantum Summer School 2023/lab4-solution.ipynb b/IBM Quantum Summer School 2023/lab4-solution.ipynb new file mode 100644 index 0000000..91ea406 --- /dev/null +++ b/IBM Quantum Summer School 2023/lab4-solution.ipynb @@ -0,0 +1,968 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab 4 : Iterative phase estimation\n", + "\n", + "In this lab, you'll implement a simple version of the iterative phase estimation algorithm. Using the recently introduced dynamic circuits capabilities, you'll be able to run the algorithm on an IBM quantum processor! This lab was adapted from the IBM Quantum Spring Challenge 2023, so if you participated in that challenge, it may look familiar. To encourage you to review the lab nevertheless, we added an extra exercise at the end." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Background\n", + "\n", + "The quantum phase estimation (QPE) algorithm is one of the most important and famous quantum algorithms. It is a key subroutine of Shor's factoring algorithm, as well as algorithms for quantum simulation. The textbook version of the algorithm uses a number of auxiliary qubits which scales with the desired precision, leading to circuits that are challenging to execute on today's noisy devices with limited qubit number and connectivity.\n", + "\n", + "Iterative phase estimation (IPE) is a variant of QPE which requires only one auxiliary qubit. In IPE, the auxiliary qubit is repeatedly measured, with the measurement results used to guide future quantum operations. Such classical feed-forward was previously impossible to execute on IBM's quantum processors, but with the recently introduced dynamic circuits capabilities, it is now possible.\n", + "\n", + "Like any phase estimation algorithm, IPE is designed to solve the following problem:\n", + "\n", + "**Problem statement:** Given a unitary matrix $U$ and an eigenstate $|\\Psi\\rangle$ of $U$ with an unknown eigenvalue $e^{i 2\\pi \\varphi}$, estimate the value of $\\varphi$.\n", + "\n", + "A few important details need to be clarified in this problem statement, namely, how $U$ and $|\\Psi\\rangle$ are specified. We assume that $U$ is given as a quantum circuit implementing $U$, and in fact, we assume we have the ability to efficiently implement the operations *controlled*-$U^{2^t}$ for positive integers $t$.\n", + "This is the same assumption used in the original QPE algorithm.\n", + "The eigenstate is also given as a quantum circuit: we assume we have the ability to efficiently prepare $|\\Psi\\rangle$.\n", + "\n", + "Let's first assume for simplicity that $\\varphi$ can have an exact binary expansion, that is, it can be written as\n", + "$$\n", + "\\varphi = \\varphi_1/2 + \\varphi_2/4 + \\cdots + \\varphi_m/2^m = 0.\\varphi_1 \\varphi_2 \\cdots \\varphi_m\n", + "$$\n", + "where in the final equality we are using \"decimal\" point notation in base 2.\n", + "For simplicity, suppose $U$ is a unitary operator acting on one qubit (everything we say here also applies to the case where $U$ acts on multiple qubits). Since IPE requires an auxiliary qubit, we need a system of two qubits, $q_0$ and $q_1$, where $q_0$ is the auxiliary qubit and $q_1$ represents the physical system on which $U$ operates.\n", + "\n", + "Now, suppose that we initialize $q_0$ in the state $|+\\rangle = \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}$ and $q_1$ in the state $|\\Psi \\rangle$.\n", + "What happens if we apply the *controlled*-$U^{2^t}$ gate, with $q_0$ being the control and $q_1$ being the target?\n", + "Since $|\\Psi \\rangle$ is an eigenstate of $U$ with eigenvalue $e^{i 2\\pi \\varphi}$, we have\n", + "$$\n", + "\\begin{align}\n", + "|+\\rangle |\\Psi \\rangle &= \\left(\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\right) |\\Psi \\rangle \\\\\n", + "&= \\frac{|0\\rangle |\\Psi \\rangle + |1\\rangle |\\Psi \\rangle}{\\sqrt{2}} \\\\\n", + "&\\xrightarrow{\\text{controlled-}U^{2^t}} \\frac{|0\\rangle |\\Psi \\rangle + e^{i 2 \\pi 2^{t} \\varphi} |1\\rangle |\\Psi \\rangle}{\\sqrt{2}} \\\\\n", + "&= \\left(\\frac{|0\\rangle + e^{i 2 \\pi 2^{t} \\varphi} |1\\rangle}{\\sqrt{2}}\\right) |\\Psi \\rangle.\n", + "\\end{align}\n", + "$$\n", + "That is, the state of the system qubit remains unchanged, while a phase of $e^{i 2 \\pi 2^{t} \\varphi}$ has been \"kicked back\" into the state of the auxiliary qubit.\n", + "\n", + "Now, note that\n", + "$$\n", + "e^{i 2 \\pi 2^{t} \\varphi} = e^{i 2 \\pi 2^{t} (0.\\varphi_1 \\varphi_2 \\cdots \\varphi_m)}\n", + "= e^{i 2 \\pi (\\varphi_1 \\cdots \\varphi_t . \\varphi_{t + 1} \\cdots \\varphi_m)}\n", + "= e^{i 2 \\pi (0. \\varphi_{t + 1} \\cdots \\varphi_m)},\n", + "$$\n", + "where in the last equality, the whole number part of the \"decimal\" representation of the phase has disappeared because $e^{i 2\\pi n} = 1$ for any integer $n$.\n", + "For example:\n", + "- for $t=0$, the phase would be $e^{i 2 \\pi 2^{0} \\varphi} = e^{i 2 \\pi \\varphi} = e^{i 2 \\pi 0.\\varphi_1 \\varphi_2 ... \\varphi_m}$\n", + "- for $t=1$, the phase would be $e^{i 2 \\pi 2^{1} \\varphi}= e^{i 2 \\pi \\varphi_1} e^{i 2 \\pi 0.\\varphi_2 \\varphi_3 ... \\varphi_m} = e^{i 2 \\pi 0.\\varphi_2 \\varphi_3 ... \\varphi_m}$\n", + "- for $t=2$, the phase would be $e^{i 2 \\pi 2^{2} \\varphi} = e^{i 2 \\pi 0.\\varphi_3 \\varphi_4 ... \\varphi_m}$\n", + "- for $t=m-1$, the phase would be $e^{i 2 \\pi 2^{m-1} \\varphi} = e^{i 2 \\pi 0.\\varphi_m}$.\n", + "\n", + "In the last case where $t = m - 1$, the phase is $e^{i 2 \\pi 0.\\varphi_m}$, which is equal to $1$ if $\\varphi_m = 0$ and $-1$ if $\\varphi_m = 1$.\n", + "In the first case, the auxiliary qubit $q_0$ would be in the state $|+\\rangle = \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}$, and in the second case it would be\n", + "in the state $|-\\rangle = \\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}$. Therefore, measuring the qubit in the Pauli $X$ basis would distinguish these cases with a 100\\% success rate.\n", + "This is done by performing a Hadamard gate on the qubit before measuring it. In the first case we would measure 0 and in the second case we would measure 1;\n", + "in other words, the measured bit would be equal to $\\varphi_m$.\n", + "\n", + "### The algorithm\n", + "\n", + "In the first step of the IPE algorithm, we directly measure the least significant bit of the phase $\\varphi$, $\\varphi_m$, by initializing the 2-qubit registers as described above ( $q_0 \\rightarrow |+\\rangle$ and $q_1 \\rightarrow |\\Psi \\rangle$ ), performing a *controlled*-$U^{2^{m-1}}$ operation, and measuring $q_0$ in the Pauli $X$ basis.\n", + "\n", + "in the second step, we initialize the systems in the same way and apply a *controlled*-$U^{2^{m-2}}$ operation. The relative phase in $q_0$ after these operations is now $e^{i 2 \\pi 0.\\varphi_{m-1}\\varphi_{m}}= e^{i 2 \\pi 0.\\varphi_{m-1}} e^{i 2 \\pi \\varphi_m/4}$. \n", + "To extract the phase bit $\\varphi_{m-1}$, first perform a phase correction by rotating around the $Z$-axis by an angle $-2 \\pi \\varphi_m/4=-\\pi \\varphi_m/2$, which results in the state of $q_0$ to be $|0\\rangle + e^{i 2 \\pi 0.\\varphi_{m-1}} | 1 \\rangle$. Perform a measurement on $q_0$ in the Pauli $X$ basis to obtain the phase bit $\\varphi_{m-1}$. \n", + "\n", + "Therefore, the $k$-th step of the IPE, getting $\\varphi_{m-k+1}$, consists of the register initialization ($q_0$ in $|+\\rangle$, $q_1$ in $|\\Psi\\rangle$), the application of a *controlled*-$U^{2^{m-k}}$, a rotation around $Z$ of angle $\\omega_k = -2 \\pi 0.0\\varphi_{m-k+2} ... \\varphi_m$, and a measurement of $q_0$ in the Pauli $X$ basis: a Hadamard transform to $q_0$, and a measurement of $q_0$ in the computational basis. Note that $q_1$ remains in the state $|\\Psi\\rangle$ throughout the algorithm." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementation\n", + "\n", + "In this lab, we will perform IPE on the single-qubit $S$-gate. The $S$ gate is given by the matrix\n", + "\n", + "$$ S =\n", + "\\begin{pmatrix}\n", + "1 & 0\\\\\n", + "0 & e^{i\\pi / 2}\n", + "\\end{pmatrix}$$\n", + "\n", + "We will use the eigenstate $|\\Psi\\rangle = |1\\rangle$, which has eigenvalue $e^{i\\pi / 2}= e^{i2\\pi \\cdot 1/4}$. So we have $\\varphi = 1/4 = 0.01 = 0.\\varphi_1 \\varphi_2$. Since $\\varphi$ can be represented exactly with 2 bits, our quantum circuit implementation will use a classical register with two bits to store the result.\n", + "\n", + "The controlled-$S$ gate can be implemented using the controlled phase gate, available in Qiskit as `CPhaseGate`, which can also be applied by calling the `cp` method of a `QuantumCircuit`. The controlled phase gate is parameterized by an angle $\\theta$ and has the matrix\n", + "$$\n", + " \\text{CPhase}(\\theta) =\n", + " \\begin{pmatrix}\n", + " 1 & 0 & 0 & 0 \\\\\n", + " 0 & 1 & 0 & 0 \\\\\n", + " 0 & 0 & 1 & 0 \\\\\n", + " 0 & 0 & 0 & e^{i\\theta}\n", + " \\end{pmatrix}\n", + "$$" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Step 1\n", + "\n", + "In the first step of the algorithm, we measure the least significant bit of $\\varphi$.\n", + "\n", + "#### Exercise 1\n", + "\n", + "Obtain the least significant bit of $\\varphi$ by performing the following steps:\n", + "1. Initialize the qubits:\n", + " - Apply a Hadamard on the auxiliary qubit.\n", + " - Apply an X gate on the system qubit to put it in the $|1\\rangle$ state.\n", + "2. Apply a *controlled*-$S^{2}$ gate by applying a `CPhaseGate` with the appropriate angle.\n", + "3. Measure the auxiliary qubit in the $X$ basis:\n", + " - Apply a Hadamard gate on the auxiliary qubit.\n", + " - Measure it in the computational basis.\n", + "\n", + "The resulting circuit should look something like this:\n", + "\n", + "![step1-circuit](resources/step1-circuit.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", + "import numpy as np\n", + "\n", + "\n", + "def step_1_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n", + " # qr is a quantum register with 2 qubits\n", + " # cr is a classical register with 2 bits\n", + "\n", + " qc = QuantumCircuit(qr, cr)\n", + "\n", + " ####### your code goes here #######\n", + "\n", + " ##1 Initialization\n", + "\n", + " q0, q1 = qr\n", + " # apply Hadamard on the auxiliary qubit\n", + " qc.h(q0)\n", + " # put the system qubit into the |1> state\n", + " qc.x(q1)\n", + "\n", + " ##2 Apply control-U operator as many times as needed to get the least significant phase bit\n", + "\n", + " # controlled-S is equivalent to CPhase with angle pi / 2\n", + " s_angle = np.pi / 2\n", + " # we want to apply controlled-S 2^k times\n", + " k = 1\n", + " # calculate the angle of CPhase corresponding to 2^k applications of controlled-S\n", + " cphase_angle = s_angle * 2**k\n", + " # apply the controlled phase gate\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " ##3 Measure the auxiliary qubit in x-basis into the first classical bit\n", + "\n", + " # apply Hadamard to change to the X basis\n", + " qc.h(q0)\n", + " # measure the auxiliary qubit into the first classical bit\n", + " c0, _ = cr\n", + " qc.measure(q0, c0)\n", + "\n", + " return qc\n", + "\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(2, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = step_1_circuit(qr, cr)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your circuit\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab4_ex1\n", + "\n", + "grade_lab4_ex1(qc)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 2\n", + "\n", + "In the first step, we measured the least significant bit $\\varphi_2$. In the second (and final) step, we extract the next bit $\\varphi_1$, which will involve applying a phase correction to cancel out the phase contribution from $\\varphi_2$. The phase correction depends on the value of the classical register holding $\\varphi_2$. We need dynamic circuits to perform this classical feedback! The phase correction can be applied using `PhaseGate` or by directly calling the `p` method of a QuantumCircuit.\n", + "\n", + "#### Exercise 2\n", + "\n", + "In this exercise, we begin with the circuit from Step 1, which you should have constructed in Exercise 1.\n", + "\n", + "Obtain the next bit of $\\varphi$ by performing the following steps:\n", + "1. Reset and re-initialize the auxiliary qubit.\n", + "2. Apply the controlled unitary gate.\n", + "3. Measure the auxiliary qubit in the $X$ basis.\n", + "\n", + "The resulting circuit should look something like this:\n", + "\n", + "![step1-circuit](resources/step2-circuit.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def step_2_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n", + " # qr is a quantum register with 2 qubits\n", + " # cr is a classical register with 2 bits\n", + "\n", + " # begin with the circuit from Step 1\n", + " qc = step_1_circuit(qr, cr)\n", + "\n", + " ####### your code goes here #######\n", + "\n", + " ##1 Reset and re-initialize the auxiliary qubit\n", + "\n", + " q0, q1 = qr\n", + " # reset the auxiliary qubit\n", + " qc.reset(q0)\n", + " # apply Hadamard on the auxiiliary qubit\n", + " qc.h(q0)\n", + "\n", + " ##2 Apply phase correction conditioned on the first classical bit\n", + "\n", + " c0, c1 = cr\n", + " with qc.if_test((c0, 1)):\n", + " qc.p(-np.pi / 2, q0)\n", + "\n", + " ##3 Apply control-U operator as many times as needed to get the next phase bit\n", + "\n", + " # controlled-S is equivalent to CPhase with angle pi / 2\n", + " s_angle = np.pi / 2\n", + " # we want to apply controlled-S 2^k times\n", + " k = 0\n", + " # calculate the angle of CPhase corresponding to 2^k applications of controlled-S\n", + " cphase_angle = s_angle * 2**k\n", + " # apply the controlled phase gate\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " ##4 Measure the auxiliary qubit in x-basis into the second classical bit\n", + "\n", + " # apply Hadamard to change to the X basis\n", + " qc.h(q0)\n", + " # measure the auxiliary qubit into the first classical bit\n", + " qc.measure(q0, c1)\n", + "\n", + " return qc\n", + "\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(2, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = step_2_circuit(qr, cr)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your circuit\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab4_ex2\n", + "\n", + "grade_lab4_ex2(qc)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run on simulator\n", + "\n", + "Now that we have the complete circuit, let's first run it on a local simulator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer import AerSimulator\n", + "\n", + "sim = AerSimulator()\n", + "job = sim.run(qc, shots=1000)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "counts" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If your circuit is correct, you should have gotten the bitstring `01` with 100% probability. This value corresponds to the phase written in binary as $\\varphi = 0.01 = 1/4$. Indeed, this is the correct phase!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 3\n", + "\n", + "Construct an IPE circuit to estimate the phase of the T gate, whose matrix is given by\n", + "\n", + "$$ T =\n", + "\\begin{pmatrix}\n", + "1 & 0\\\\\n", + "0 & e^{i\\pi / 4}\n", + "\\end{pmatrix}$$\n", + "\n", + "How many bits are needed to represent the phase in this case?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", + "import numpy as np\n", + "\n", + "\n", + "def t_gate_ipe_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n", + " # qr is a quantum register with 2 qubits\n", + " # cr is a classical register with 3 bits\n", + "\n", + " qc = QuantumCircuit(qr, cr)\n", + "\n", + " ####### your code goes here #######\n", + "\n", + " # Initialization\n", + " q0, q1 = qr\n", + " qc.h(q0)\n", + " qc.x(q1)\n", + "\n", + " # Apply control-U operator as many times as needed to get the least significant phase bit\n", + " t_angle = np.pi / 4\n", + " k = 2\n", + " cphase_angle = t_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis into the first classical bit\n", + " qc.h(q0)\n", + " c0, c1, c2 = cr\n", + " qc.measure(q0, c0)\n", + "\n", + " # Reset and re-initialize the auxiliary qubit\n", + " qc.reset(q0)\n", + " qc.h(q0)\n", + "\n", + " # Apply phase correction conditioned on the first classical bit\n", + " with qc.if_test((c0, 1)):\n", + " qc.p(-np.pi / 2, q0)\n", + "\n", + " # Apply control-U operator as many times as needed to get the next phase bit\n", + " k = 1\n", + " cphase_angle = t_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis into the second classical bit\n", + " qc.h(q0)\n", + " qc.measure(q0, c1)\n", + "\n", + " # Reset and re-initialize the auxiliary qubit\n", + " qc.reset(q0)\n", + " qc.h(q0)\n", + "\n", + " # Apply phase correction conditioned on the first and second classical bits\n", + " with qc.if_test((c0, 1)):\n", + " qc.p(-np.pi / 4, q0)\n", + " with qc.if_test((c1, 1)):\n", + " qc.p(-np.pi / 2, q0)\n", + "\n", + " # Apply control-U operator as many times as needed to get the next phase bit\n", + " k = 0\n", + " cphase_angle = t_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis into the third classical bit\n", + " qc.h(q0)\n", + " qc.measure(q0, c2)\n", + "\n", + " return qc\n", + "\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(3, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = t_gate_ipe_circuit(qr, cr)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer import AerSimulator\n", + "\n", + "sim = AerSimulator()\n", + "job = sim.run(qc, shots=1000)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "counts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your circuit\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab4_ex3\n", + "\n", + "grade_lab4_ex3(qc)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### When the phase does not have an exact binary expansion\n", + "\n", + "Let's consider the case when the phase does not have an exact binary expansion, for example, $\\varphi = 1/3$.\n", + "In this case, the single-qubit gate has the unitary\n", + "\n", + "$$ U =\n", + "\\begin{pmatrix}\n", + "1 & 0\\\\\n", + "0 & e^{i2\\pi / 3}\n", + "\\end{pmatrix}\n", + "$$\n", + "\n", + "The angle $\\varphi = 1/3$ does not have an exact finite binary expansion. In contrast, it has the infinite binary expansion\n", + "\n", + "$$\n", + "1/3 = 0.010101\\ldots\n", + "$$\n", + "\n", + "In practice we work with a fixed number of bits of precision, so our goal is to obtain the closest value that can be represented with those bits. In the following example, we will use two bits of precision. In this case, the closest value is $0.01 = 1/4$. Because this value does not represent the exact phase, there is some probability that we will obtain a different, less precise result.\n", + "\n", + "In the following code cells, we construct and simulate an IPE circuit to measure the phase of this gate." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", + "import numpy as np\n", + "\n", + "\n", + "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n", + " # qr is a quantum register with 2 qubits\n", + " # cr is a classical register with 2 bits\n", + "\n", + " qc = QuantumCircuit(qr, cr)\n", + "\n", + " # Initialization\n", + " q0, q1 = qr\n", + " qc.h(q0)\n", + " qc.x(q1)\n", + "\n", + " # Apply control-U operator as many times as needed to get the least significant phase bit\n", + " u_angle = 2 * np.pi / 3\n", + " k = 1\n", + " cphase_angle = u_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis into the first classical bit\n", + " qc.h(q0)\n", + " c0, c1 = cr\n", + " qc.measure(q0, c0)\n", + "\n", + " # Reset and re-initialize the auxiliary qubit\n", + " qc.reset(q0)\n", + " qc.h(q0)\n", + "\n", + " # Apply phase correction conditioned on the first classical bit\n", + " with qc.if_test((c0, 1)):\n", + " qc.p(-np.pi / 2, q0)\n", + "\n", + " # Apply control-U operator as many times as needed to get the next phase bit\n", + " k = 0\n", + " cphase_angle = u_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis into the second classical bit\n", + " qc.h(q0)\n", + " qc.measure(q0, c1)\n", + "\n", + " return qc\n", + "\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(2, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = u_circuit(qr, cr)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer import AerSimulator\n", + "\n", + "sim = AerSimulator()\n", + "job = sim.run(qc, shots=1000)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "print(counts)\n", + "success_probability = counts[\"01\"] / counts.shots()\n", + "print(f\"Success probability: {success_probability}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, this time, we are not guaranteed to obtain the desired result. A natural question to ask is: How can we boost the success probability?\n", + "\n", + "One way that the algorithm fails is that the first measured bit is incorrect. In this case, the phase correction applied before measuring the second bit is also incorrect, causing the rest of the bits to be likely incorrect as well. A simple way to mitigate this problem is to repeat the measurement of the first few bits several times and take a majority vote to increase the likelihood that we measure the bit correctly. Implementing this procedure within a single circuit requires performing arithmetic on the measured outcomes. Due to a temporary limitation in Qiskit, it is currently not possible to perform arithmetic on measured bits and condition future circuit operations on the results. So, here we will measure each bit using separate circuits.\n", + "\n", + "The following code cells construct and simulate an IPE circuit for measuring just the first bit of the phase." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", + "import numpy as np\n", + "\n", + "\n", + "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n", + " # qr is a quantum register with 2 qubits\n", + " # cr is a classical register with 1 bits\n", + "\n", + " qc = QuantumCircuit(qr, cr)\n", + "\n", + " # Initialization\n", + " q0, q1 = qr\n", + " qc.h(q0)\n", + " qc.x(q1)\n", + "\n", + " # Apply control-U operator as many times as needed to get the least significant phase bit\n", + " u_angle = 2 * np.pi / 3\n", + " k = 1\n", + " cphase_angle = u_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis\n", + " qc.h(q0)\n", + " (c0,) = cr\n", + " qc.measure(q0, c0)\n", + "\n", + " return qc\n", + "\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(1, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = u_circuit(qr, cr)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "job = sim.run(qc, shots=15)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "print(counts)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hopefully, the correct bit was measured more often than not.\n", + "\n", + "### Exercise 4\n", + "\n", + "Examine the counts dictionary from the output of the last code cell. What is the correct value for the first bit? Was it measured more often than not? If not, rerun the last code cell until it is. Then, write some code in the code cell below that sets the variable `step1_bit` equal to the value of the bit that was measured the majority of the time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "step1_bit: int\n", + "\n", + "####### your code goes here #######\n", + "\n", + "step1_bit = 1 if counts[\"1\"] > counts[\"0\"] else 0\n", + "\n", + "print(step1_bit)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your result\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab4_ex4\n", + "\n", + "grade_lab4_ex4(step1_bit)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 5\n", + "\n", + "Now construct the circuit to measure the second bit of the phase. Replace the first stage of the circuit with one which simply sets the auxiliary bit to the value we measured above, so that we always measure the correct value for the first bit of the phase." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", + "import numpy as np\n", + "\n", + "\n", + "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n", + " # qr is a quantum register with 2 qubits\n", + " # cr is a classical register with 2 bits\n", + "\n", + " qc = QuantumCircuit(qr, cr)\n", + "\n", + " ####### your code goes here #######\n", + "\n", + " # Initialization\n", + " q0, q1 = qr\n", + " if step1_bit:\n", + " qc.x(q0)\n", + " qc.x(q1)\n", + "\n", + " # Measure the auxiliary qubit\n", + " c0, c1 = cr\n", + " qc.measure(q0, c0)\n", + "\n", + " # Reset and re-initialize the auxiliary qubit\n", + " qc.reset(q0)\n", + " qc.h(q0)\n", + "\n", + " # Apply phase correction conditioned on the first classical bit\n", + " with qc.if_test((c0, 1)):\n", + " qc.p(-np.pi / 2, q0)\n", + "\n", + " # Apply control-U operator as many times as needed to get the next phase bit\n", + " u_angle = 2 * np.pi / 3\n", + " k = 0\n", + " cphase_angle = u_angle * 2**k\n", + " qc.cp(cphase_angle, q0, q1)\n", + "\n", + " # Measure the auxiliary qubit in x-basis into the second classical bit\n", + " qc.h(q0)\n", + " qc.measure(q0, c1)\n", + "\n", + " return qc\n", + "\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(2, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = u_circuit(qr, cr)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your result\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab4_ex5\n", + "\n", + "grade_lab4_ex5(qc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer import AerSimulator\n", + "\n", + "sim = AerSimulator()\n", + "job = sim.run(qc, shots=1000)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "print(counts)\n", + "success_probability = counts[\"01\"] / counts.shots()\n", + "print(f\"Success probability: {success_probability}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, the success probability is much higher than before!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 6 (ungraded)\n", + "\n", + "So far, the IPE circuits we constructed were designed for a specific gate and a specific number of bits of precision. Let's now generalize your code to implement a general IPE routine that can handle different gates and levels of precision.\n", + "\n", + "Complete the following function to implement a generalized IPE routine. It takes the following inputs:\n", + "- `qr`: The quantum register. The first qubit is assumed to be the auxiliary qubit, and the rest of them the system qubits.\n", + "- `cr`: The classical register. Its length indicates the desired number of bits of precision.\n", + "- `controlled_unitaries`: A list of gates implementing *controlled*-$U^{2^t}$ for $t = 0, \\ldots, m-1$, where $m$ is the number of bits of precision.\n", + "- `state_prep`: A gate used to initialize the state of the system qubits." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit import Gate\n", + "\n", + "\n", + "def iterative_phase_estimation(\n", + " qr: QuantumRegister,\n", + " cr: ClassicalRegister,\n", + " controlled_unitaries: list[Gate],\n", + " state_prep: Gate,\n", + ") -> QuantumCircuit:\n", + " qc = QuantumCircuit(qr, cr)\n", + "\n", + " ####### your code goes here #######\n", + "\n", + " auxiliary_qubit = qr[0]\n", + " system_qubits = qr[1:]\n", + " qc.append(state_prep, system_qubits)\n", + " for i in range(len(cr)):\n", + " k = len(cr) - 1 - i\n", + " qc.reset(auxiliary_qubit)\n", + " qc.h(auxiliary_qubit)\n", + " for j in range(i):\n", + " with qc.if_test((cr[j], 1)):\n", + " qc.p(-np.pi / 2 ** (i - j), auxiliary_qubit)\n", + " qc.append(controlled_unitaries[k], qr)\n", + " qc.h(auxiliary_qubit)\n", + " qc.measure(auxiliary_qubit, cr[i])\n", + " return qc" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The example below shows how one would use this function to generate the IPE circuit for the $S$ gate. The simulation results should match what you got above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import CPhaseGate, XGate\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(2, \"c\")\n", + "\n", + "s_angle = np.pi / 2\n", + "controlled_unitaries = [CPhaseGate(s_angle * 2**k) for k in range(2)]\n", + "qc = iterative_phase_estimation(qr, cr, controlled_unitaries, XGate())\n", + "\n", + "sim = AerSimulator()\n", + "job = sim.run(qc, shots=1000)\n", + "result = job.result()\n", + "counts = result.get_counts()\n", + "counts" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run on hardware\n", + "\n", + "In the final part of this lab, we will run some circuits on real hardware! The code cells below initialize and run the circuit you created in Exercise 2 to measure the phase of the $S$ gate. Because current quantum hardware suffers from noise, the results will not be as good as what you got on the simulator. Feel free to try running the other circuits you created in this lab, though be aware that larger circuits, like the one from Exercise 3 for measuring the phase of the $T$ gate, will suffer from even more noise." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_provider import IBMProvider\n", + "\n", + "provider = IBMProvider()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hub = \"YOUR_HUB\"\n", + "group = \"YOUR_GROUP\"\n", + "project = \"YOUR_PROJECT\"\n", + "\n", + "backend_name = \"ibmq_manila\"\n", + "backend = provider.get_backend(backend_name, instance=f\"{hub}/{group}/{project}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import transpile\n", + "\n", + "qr = QuantumRegister(2, \"q\")\n", + "cr = ClassicalRegister(2, \"c\")\n", + "qc = QuantumCircuit(qr, cr)\n", + "qc = step_2_circuit(qr, cr)\n", + "qc_transpiled = transpile(qc, backend)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "job = backend.run(qc_transpiled, shots=1000, dynamic=True)\n", + "job_id = job.job_id()\n", + "print(job_id)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "retrieve_job = provider.retrieve_job(job_id)\n", + "retrieve_job.status()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.tools.visualization import plot_histogram\n", + "\n", + "counts = retrieve_job.result().get_counts()\n", + "plot_histogram(counts)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.11" + }, + "vscode": { + "interpreter": { + "hash": "c2040b9df22fb8e6f552d9b589c97ff536ffe03a0da1ea2949f78b5a0e303bb6" + } + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/IBM Quantum Summer School 2023/lab5-solution.ipynb b/IBM Quantum Summer School 2023/lab5-solution.ipynb new file mode 100644 index 0000000..7d635b1 --- /dev/null +++ b/IBM Quantum Summer School 2023/lab5-solution.ipynb @@ -0,0 +1,657 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab 5: Error mitigation with Qiskit Runtime\n", + "\n", + "In this lab, we'll explore a few of the error mitigation options available through Qiskit Runtime. Specifically, we'll define a simple observable and initial state and use the Estimator primitive to measure the expectation value. Using noisy simulations, we'll explore the effect of different error mitigation strategies." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "We'll define a simple Heisenberg Hamiltonian model to use as an example. We'll also construct a simple state preparation circuit." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit, QuantumRegister\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "\n", + "\n", + "def heisenberg_hamiltonian(\n", + " length: int, jx: float = 1.0, jy: float = 0.0, jz: float = 0.0\n", + ") -> SparsePauliOp:\n", + " terms = []\n", + " for i in range(length - 1):\n", + " if jx:\n", + " terms.append((\"XX\", [i, i + 1], jx))\n", + " if jy:\n", + " terms.append((\"YY\", [i, i + 1], jy))\n", + " if jz:\n", + " terms.append((\"ZZ\", [i, i + 1], jz))\n", + " return SparsePauliOp.from_sparse_list(terms, num_qubits=length)\n", + "\n", + "\n", + "def state_prep_circuit(num_qubits: int, layers: int = 1) -> QuantumCircuit:\n", + " qubits = QuantumRegister(num_qubits, name=\"q\")\n", + " circuit = QuantumCircuit(qubits)\n", + " circuit.h(qubits)\n", + " for _ in range(layers):\n", + " for i in range(0, num_qubits - 1, 2):\n", + " circuit.cx(qubits[i], qubits[i + 1])\n", + " circuit.ry(0.1, qubits)\n", + " for i in range(1, num_qubits - 1, 2):\n", + " circuit.cx(qubits[i], qubits[i + 1])\n", + " circuit.ry(0.1, qubits)\n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "length = 5\n", + "\n", + "hamiltonian = heisenberg_hamiltonian(length, 1.0, 1.0)\n", + "circuit = state_prep_circuit(length, layers=2)\n", + "\n", + "print(hamiltonian)\n", + "circuit.draw(\"mpl\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Calculate exact expectation value (energy)\n", + "\n", + "First, we'll calculate the exact expectation value using a local simulator implementation of the Estimator primitive. The expectation value of a Hamiltonian is also referred to as \"energy.\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer.primitives import Estimator\n", + "\n", + "estimator = Estimator(approximation=True)\n", + "job = estimator.run(circuit, hamiltonian, shots=None)\n", + "result = job.result()\n", + "exact_value = result.values[0]\n", + "\n", + "print(f\"Exact energy: {exact_value}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run noisy simulation through Qiskit Runtime\n", + "\n", + "Next, we'll initialize the Qiskit Runtime service and switch to using its Estimator primitive, backed by a simulator that can handle noise." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "hub = \"ibm-q-internal\"\n", + "group = \"deployed\"\n", + "project = \"default\"\n", + "service = QiskitRuntimeService(instance=f\"{hub}/{group}/{project}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime import Estimator, Options, Session\n", + "from qiskit.transpiler import CouplingMap\n", + "\n", + "backend = service.get_backend(\"simulator_statevector\")\n", + "# set simulation options\n", + "simulator = {\n", + " \"basis_gates\": [\"id\", \"rz\", \"sx\", \"cx\", \"reset\"],\n", + " \"coupling_map\": list(CouplingMap.from_line(length + 1)),\n", + "}\n", + "shots = 10000" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### No noise" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we'll run the simulation with no noise." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "options = Options(\n", + " simulator=simulator,\n", + " resilience_level=0,\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variance = result.metadata[0][\"variance\"]\n", + "std = math.sqrt(variance / shots)\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variance: {variance}\")\n", + "print(f\"Standard error: {std}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Readout error\n", + "\n", + "Next, let's run a simulation with readout error." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exercise 1\n", + "\n", + "In this exercise, you'll construct a noise model that has modest readout error on all qubits except for the first qubit, which will have really bad readout error.\n", + "\n", + "Specifically, construct a noise model with the following properties:\n", + "- For the first qubit (qubit 0):\n", + " - A readout of 1 has a 50% probability of being erroneously read as 0.\n", + " - A readout of 0 has a 20% probability of being erroneously read as 1.\n", + "- For the rest of the qubits:\n", + " - A readout of 1 has a 5% probability of being erroneously read as 0.\n", + " - A readout of 0 has a 2% probability of being erroneously read as 1.\n", + "\n", + "You may find it helpful to consult the following resources:\n", + " - https://qiskit.org/ecosystem/aer/apidocs/aer_noise.html\n", + " - https://qiskit.org/documentation/tutorials/simulators/3_building_noise_models.html" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer.noise import NoiseModel, ReadoutError\n", + "\n", + "noise_model = NoiseModel()\n", + "\n", + "##### your code here #####\n", + "\n", + "# add modest readout error on all qubits\n", + "p0given1 = 0.05\n", + "p1given0 = 0.02\n", + "readout_error = ReadoutError(\n", + " [\n", + " [1 - p1given0, p1given0],\n", + " [p0given1, 1 - p0given1],\n", + " ]\n", + ")\n", + "noise_model.add_all_qubit_readout_error(readout_error)\n", + "\n", + "# add really bad readout error on qubit 0\n", + "p0given1 = 0.5\n", + "p1given0 = 0.2\n", + "readout_error = ReadoutError(\n", + " [\n", + " [1 - p1given0, p1given0],\n", + " [p0given1, 1 - p0given1],\n", + " ]\n", + ")\n", + "noise_model.add_readout_error(readout_error, [0])\n", + "\n", + "print(noise_model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your answer\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab5_ex1\n", + "\n", + "grade_lab5_ex1(noise_model)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's try running the simulation without doing anything to mitigate the readout error. We'll explicitly set `resilience_level = 0` to ensure that no error mitigation is applied by the Runtime service. To illustrate the effect of a poor choice of qubits, we'll explicitly specify an initial layout that includes qubit 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=0,\n", + " transpilation=dict(initial_layout=list(range(length))),\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variance = result.metadata[0][\"variance\"]\n", + "std = math.sqrt(variance / shots)\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variance: {variance}\")\n", + "print(f\"Standard error: {std}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The error we get is pretty large. To improve things, let's pick a qubit layout that avoids qubit 0." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=0,\n", + " transpilation=dict(initial_layout=list(range(1, length + 1))),\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variance = result.metadata[0][\"variance\"]\n", + "std = math.sqrt(variance / shots)\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variance: {variance}\")\n", + "print(f\"Standard error: {std}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The error is smaller now, but still significant. Let's now enable readout error mitigation by setting `resilience_level = 1`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=1,\n", + " transpilation=dict(initial_layout=list(range(1, length + 1))),\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variance = result.metadata[0][\"variance\"]\n", + "std = math.sqrt(variance / shots)\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variance: {variance}\")\n", + "print(f\"Standard error: {std}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, the effect of readout error has been almost completely mitigated! This mitigation did not come for free. In particular,\n", + "- To perform readout error mitigation, the Runtime service has to run additional calibration circuits, so the overall running time may be longer.\n", + "- The variance of the estimator has increased, leading to a larger standard error of the mean. As a consequence, a larger number of shots needs to be specified in order to achieve a given standard error.\n", + "\n", + "Typically, these costs are relatively small, so it is almost always worthwhile to enable readout error mitigation." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exercise 2\n", + "\n", + "Suppose that turning on readout error mitigation increases the variance of your estimator by a factor of 2. If you originally ran your experiment with 10,000 shots, how many shots should you now use to achieve the same standard error of the mean?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_shots: int\n", + "\n", + "##### your code here #####\n", + "\n", + "new_shots = 20000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your answer\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab5_ex2\n", + "\n", + "grade_lab5_ex2(new_shots)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Depolarizing error and zero-noise extrapolation\n", + "\n", + "In this section, we will see how depolarizing error can be mitigated using zero-noise extrapolation. Because the zero-noise extrapolation feature of Qiskit Runtime is still in beta, it currently has a few limitations. In particular, as of the time of this writing, the zero-noise extrapolation feature does not mitigate readout error. Therefore, in the examples below, we will remove readout error from our noise model." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exercise 3\n", + "\n", + "Construct a noise model that adds two-qubit depolarizing error after each CNOT gate, such that the error channel maps the input quantum state to the completely mixed state with 1% probability." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer.noise import depolarizing_error\n", + "\n", + "noise_model = NoiseModel()\n", + "\n", + "##### your code here #####\n", + "\n", + "noise_model.add_all_qubit_quantum_error(depolarizing_error(0.01, 2), [\"cx\"])\n", + "\n", + "print(noise_model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Submit your answer\n", + "\n", + "from qc_grader.challenges.qgss_2023 import grade_lab5_ex3\n", + "\n", + "grade_lab5_ex3(noise_model)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's run the estimator with `resilience_level = 1`, which turns on readout error mitigation. Because our noise model doesn't include readout error mitigation, we don't expect this to help." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=1,\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variance = result.metadata[0][\"variance\"]\n", + "std = math.sqrt(variance / shots)\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variance: {variance}\")\n", + "print(f\"Standard error: {std}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the error we get is pretty significant.\n", + "\n", + "Now, let's turn on zero-noise extrapolation by setting `resilience_level = 2`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=2,\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variances = result.metadata[0][\"zne\"][\"noise_amplification\"][\"variance\"]\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variances: {variances}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, the effect of depolarizing noise has been almost completely mitigated! Note that instead of getting a single variance value for the estimator, we are now returned a list of variances, one for each data point measured for the extrapolation. In a future version of Qiskit Runtime, these variances will also be extrapolated to return a single variance for the final estimator." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exercise 4 (ungraded)\n", + "\n", + "Besides depolarizing error, what other kinds of noise can be mitigated by zero-noise extrapolation? Test your proposals by constructing other noise models, and then simulating them with and without zero-noise extrapolation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_aer.noise import depolarizing_error, amplitude_damping_error\n", + "\n", + "noise_model = NoiseModel()\n", + "\n", + "##### your code here #####\n", + "\n", + "noise_model.add_all_qubit_quantum_error(amplitude_damping_error(0.01).tensor(amplitude_damping_error(0.05)), [\"cx\"])\n", + "\n", + "print(noise_model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=1,\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variance = result.metadata[0][\"variance\"]\n", + "std = math.sqrt(variance / shots)\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variance: {variance}\")\n", + "print(f\"Standard error: {std}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "options = Options(\n", + " simulator=dict(noise_model=noise_model, **simulator),\n", + " resilience_level=2,\n", + ")\n", + "\n", + "with Session(service=service, backend=backend):\n", + " estimator = Estimator(options=options)\n", + " job = estimator.run(circuit, hamiltonian, shots=shots)\n", + "\n", + "result = job.result()\n", + "experiment_value = result.values[0]\n", + "error = abs(experiment_value - exact_value)\n", + "variances = result.metadata[0][\"zne\"][\"noise_amplification\"][\"variance\"]\n", + "\n", + "print(f\"Estimated energy: {experiment_value}\")\n", + "print(f\"Energy error: {error}\")\n", + "print(f\"Variances: {variances}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qgss-2023-svnk7ds3", + "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.10.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md index ad5fc2b..300fdea 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ Qiskit is an open-source framework developed by IBM for programming quantum comp - [IBM Quantum Summer School 2020](https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges/tree/main/IBM%20Quantum%20Summer%20School%202020) : Introduction to Quantum Computing and Quantum Algorithms. - [IBM Quantum Summer School 2021](https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges/tree/main/IBM%20Quantum%20Summer%20School%202021) : Introduction to Quantum Machine Learning like VQE and QAOA - [IBM Quantum Summer School 2022](https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges/tree/main/IBM%20Quantum%20Summer%20School%202022) : Introduction to Quantum Simulations and Chemistry -- [IBM Quantum Summer School 2023](#ibm-quantum-summer-school-2023) +- [IBM Quantum Summer School 2023](https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges/tree/main/IBM%20Quantum%20Summer%20School%202023) : Theory to Implementation ### Quantum Challenges Fall