From 676abd66b37b396a1ec6513458f0b5e1f396152d Mon Sep 17 00:00:00 2001 From: Katie McCormick Date: Thu, 9 Oct 2025 12:37:34 -0700 Subject: [PATCH 1/6] add qft module --- learning/modules/computer-science/_toc.json | 4 + learning/modules/computer-science/qft.ipynb | 1050 +++++++++++++++++ .../modules/computer-science/qft/Cchord.avif | Bin 0 -> 46743 bytes .../computer-science/qft/Cchordfreq.avif | Bin 0 -> 13981 bytes .../modules/computer-science/qft/Cnote.avif | Bin 0 -> 52437 bytes .../computer-science/qft/Cnotefreq.avif | Bin 0 -> 13614 bytes .../modules/computer-science/qft/QPE.avif | Bin 0 -> 8216 bytes .../computer-science/qft/QPE1qubit.avif | Bin 0 -> 11048 bytes .../computer-science/qft/QPE_withpi.avif | Bin 0 -> 9025 bytes .../modules/computer-science/qft/phi0.avif | Bin 0 -> 24784 bytes .../modules/computer-science/qft/phi1.avif | Bin 0 -> 25040 bytes .../modules/computer-science/qft/phi2.avif | Bin 0 -> 26024 bytes .../modules/computer-science/qft/phi3.avif | Bin 0 -> 26322 bytes 13 files changed, 1054 insertions(+) create mode 100644 learning/modules/computer-science/qft.ipynb create mode 100644 public/learning/images/modules/computer-science/qft/Cchord.avif create mode 100644 public/learning/images/modules/computer-science/qft/Cchordfreq.avif create mode 100644 public/learning/images/modules/computer-science/qft/Cnote.avif create mode 100644 public/learning/images/modules/computer-science/qft/Cnotefreq.avif create mode 100644 public/learning/images/modules/computer-science/qft/QPE.avif create mode 100644 public/learning/images/modules/computer-science/qft/QPE1qubit.avif create mode 100644 public/learning/images/modules/computer-science/qft/QPE_withpi.avif create mode 100644 public/learning/images/modules/computer-science/qft/phi0.avif create mode 100644 public/learning/images/modules/computer-science/qft/phi1.avif create mode 100644 public/learning/images/modules/computer-science/qft/phi2.avif create mode 100644 public/learning/images/modules/computer-science/qft/phi3.avif diff --git a/learning/modules/computer-science/_toc.json b/learning/modules/computer-science/_toc.json index 7e74e0bf783..048f8378825 100644 --- a/learning/modules/computer-science/_toc.json +++ b/learning/modules/computer-science/_toc.json @@ -29,6 +29,10 @@ "title": "Quantum key distribution", "url": "/learning/modules/computer-science/quantum-key-distribution" }, + { + "title": "Quantum Fourier transform", + "url": "/learning/modules/computer-science/qft" + }, { "title": "Variational quantum eigensolver", "url": "/learning/modules/computer-science/vqe" diff --git a/learning/modules/computer-science/qft.ipynb b/learning/modules/computer-science/qft.ipynb new file mode 100644 index 00000000000..c2d37a579aa --- /dev/null +++ b/learning/modules/computer-science/qft.ipynb @@ -0,0 +1,1050 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dd33e9e7-3e4c-48ea-81a9-70b74c34b130", + "metadata": {}, + "source": [ + "# Quantum Fourier transform" + ] + }, + { + "cell_type": "markdown", + "id": "a920f884-f6b0-46fd-a4ef-126f9c281f17", + "metadata": {}, + "source": [ + "For this Qiskit in Classrooms module, students must have a working Python environment with the following packages installed:\n", + "- `qiskit` v2.1.0 or newer\n", + "- `qiskit-ibm-runtime` v0.40.1 or newer\n", + "- `qiskit-aer` v0.17.0 or newer\n", + "- `qiskit.visualization`\n", + "- `numpy`\n", + "- `pylatexenc`\n", + "\n", + "To set up and install the packages above, see the [Install Qiskit](/docs/guides/install-qiskit) guide.\n", + "In order to run jobs on real quantum computers, students will need to set up an account with IBM Quantum® by following the steps in the [Set up your IBM Cloud account](/docs/guides/cloud-setup) guide.\n", + "\n", + "This module was tested and used XX seconds of QPU time. This is a good-faith estimate; your actual usage may vary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46231c35-a3f5-4b04-83c5-6f15d6a5785c", + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment and modify this line as needed to install dependencies\n", + "#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'" + ] + }, + { + "cell_type": "markdown", + "id": "d77edd39-2574-41bb-9338-13d139f1a6a9", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "A Fourier transform is a ubiquitous tool with applications in math, physics, signal processing, data compression, and countless other fields. A *quantum* version of the Fourier transform, aptly named the quantum Fourier transform, forms the basis for some of the most important quantum algorithms. \n", + "\n", + "Today, after a reminder of the classical Fourier transform, we'll talk about how we implement the quantum Fourier transform on a quantum computer. Then, we'll discuss one of the applications of the quantum Fourier transform to an algorithm called the phase estimation algorithm. Quantum phase estimation is a subroutine in Shor's famous factoring algorithm, which is sometimes referred to as the \"crown jewel\" of quantum computing. This module builds toward another module all about Shor's algorithm, but it's also meant to be stand-alone. The quantum Fourier transform is a fascinating and useful algorithm in its own right!\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "24e8de09-0876-46cd-9346-c0d46ffce8a9", + "metadata": {}, + "source": [ + "## The classical Fourier transform\n", + "\n", + "Before we jump into the quantum Fourier transform, let's first remind ourselves of the classical version. The Fourier transform is a method of transforming from one so-called \"basis\" to another. You can think of two bases as different perspectives of the same problem — they are both valid ways to express a function, but one or the other might be more illuminating, depending on the problem at hand. Some examples of pairs of bases that are connected by Fourier transform are position and momentum, and time and frequency.\n", + "\n", + "Let's see an example of how the Fourier transform might help us figure out what note an instrument is playing based on its audio waveform. Typically, we see the waveforms represented in the time basis — that is, the amplitude of the wave is expressed as a function of time. \n", + "\n", + "![Single sinusoidal signal plotted as a function of time.](/learning/images/modules/computer-science/qft/Cnote.avif)\n", + "\n", + "We can Fourier transform this waveform to go from the time basis to the frequency basis:\n", + "\n", + "![Frequency spectrum of the audio waveform. one clear sharp peak at 260 Hz.](/learning/images/modules/computer-science/qft/my-course/Cnotefreq.avif)\n", + "\n", + "In the frequency basis, we can easily see a clear peak at about 260 Hz. That's a middle C! \n", + "\n", + "Now, you might have been able to do determine that a middle C was being played without the use of a Fourier transform, but what if multiple notes are played at once? Then the waveform becomes more complicated when we plot it in the time basis:\n", + "\n", + "![Displacement vs. time graph of multiple sine waves at once, creating a more complicated periodic pattern.](/learning/images/modules/computer-science/qft/Cchord.avif)\n", + "\n", + "But the frequency spectrum clearly identifies three peaks:\n", + "\n", + "![Frequency spectrum of the above audio waveform. Three peaks at approximately 260 Hz, 330 Hz, and 392 Hz. The last peak is very weak, but visible.](/learning/images/modules/computer-science/qft/Cchordfreq.avif)\n", + "\n", + "\n", + "This was a C-major chord, playing the notes C, E, and G.\n", + "\n", + "This kind of Fourier analysis can help us extract the frequency components of any sort of complicated signal. \n", + "\n", + "\n", + "### Discrete Fourier transform\n", + "\n", + "The Fourier transform is useful for any number of signal-processing applications. But in most of these real-world applications (including the music example we used above), we want to transform a discrete set of $N$ data points — not a continuous function. In this case, we use the *discrete* Fourier transform. The discrete Fourier transform acts on a vector $(x_0, ..., x_{N-1})$ and maps it to the vector $(y_0, ..., y_{N-1})$ according to the formula:\n", + "\n", + "$$y_k = \\frac{1}{\\sqrt{N}}\\sum_{j=0}^{N-1}x_j\\omega_N^{jk}$$\n", + "\n", + "where we take $\\omega_N^{jk} = e^{2\\pi i \\frac{jk}{N}}$. (Note that there are other conventions that have a minus sign in the exponential, so be careful when you see the DFT in the wild.) Recall that $e^{2\\pi i \\frac{jk}{N}}$ is a periodic function, with period $\\frac{N}{k}$. So, by multiplying by this function, the Fourier transform is essentially a way to break the (discrete) function $\\{x_{j}\\}$ into a linear combination of its constituent periodic functions, each with period $\\frac{N}{k}$.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e1271322-48e3-47e1-90e1-7cf7117ccd7c", + "metadata": {}, + "source": [ + "## The quantum Fourier transform\n", + "\n", + "So now, we've seen how the Fourier transform is used to represent a function as a linear combination of a new set of so-called \"basis functions.\" Basis transformations are regularly done on qubit states, too. For example, the state of a single qubit $|\\psi\\rangle$ can be expressed in the computational basis $|\\psi\\rangle = c_0 |0\\rangle + c_1 |1\\rangle$, with basis states $|0\\rangle$ and $|1\\rangle$, or in the $X$ basis $|\\psi\\rangle = c_+ |+\\rangle + c_- |-\\rangle$ with basis states $|+\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |1\\rangle)$ and $|-\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle - |1\\rangle)$. Both are equally valid, but one might be more natural than the other, depending on the type of problem you are trying to solve. \n", + "\n", + "Qubit states can also be expressed in the Fourier basis where a state is expressed in terms of a linear combination of the Fourier basis states $|\\phi_y\\rangle$, rather than the usual, computational basis states, $|x\\rangle$. To do this, you need to apply a quantum Fourier transform (QFT):\n", + "\n", + "$$ | \\phi_y \\rangle = \\frac{1}{\\sqrt{N}}\\sum_{x=0}^{N-1}\\omega_N^{y x} \\vert x \\rangle$$\n", + "\n", + "with $\\omega_N^{yx} = e^{\\frac{2\\pi y x}{N}}$ as above, and $N$ is the number of basis states in your quantum system. Note that, since we're working with qubits now, $m$ qubits gives you $2^m$ basis states, so $N=2^m$. Here, the basis states are written as just a single number $|x\\rangle$ where $x$ ranges from $0$ to $N-1$, but you might more typically see the basis states expressed as $|00...00\\rangle$, $|00...01\\rangle$, $|00...11\\rangle$, ..., $|11...11\\rangle$, where each binary digit represents the state of qubit 0 through $m-1$, from right to left. There's an easy way to convert these binary states to a single number: just treat them like binary numbers! So, $|00...00\\rangle = |0\\rangle$, $|00...01\\rangle = |1\\rangle$, $|00...10\\rangle = |2\\rangle$, $|00...11\\rangle = |3\\rangle$, and so on, all the way up to $|11...11\\rangle = |2^m -1\\rangle = |N-1\\rangle$.\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "07d09c65-9ba8-41cb-983d-b5dd33d99458", + "metadata": {}, + "source": [ + "### Building intuition for the Fourier basis states \n", + "\n", + "So, we've just gone over what the computational basis states are and how they're ordered: they're the set of states where each qubit is either in $0$ or $1$, and we order them from the state where all qubits are $0$, $|00...00\\rangle$, to the state where they are all $1$, $|11...11\\rangle$. \n", + "\n", + "But how can we make sense of the *Fourier* basis states? All of the Fourier basis states are equal superpositions of all the computational basis states, but each state differs from the other in the periodicity in the components' *phase*. To understand this more concretely, let's take a look at the four Fourier basis states of a two-qubit system. The lowest Fourier state is one whose phase does not vary at all:\n", + "\n", + "$$|\\phi_0\\rangle = \\frac{1}{2} (|00\\rangle + |01\\rangle + |10\\rangle + |11\\rangle)$$\n", + "\n", + "We can visualize this state by plotting the complex amplitude of each of the terms. The red line guides the eye to show you how the phase of this amplitude winds around the complex plane as a function of the computational basis state. For $|\\phi_0\\rangle$, the phase remains constant:\n", + "\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_0$. They are all real, and so the bars all point to +1 on the x-axis](/learning/images/modules/computer-science/qft/phi0.avif)\n", + "\n", + "The next Fourier basis state is the one whose components' phases wind around from $0$ to $2\\pi$ just once:\n", + "\n", + "$$|\\phi_1\\rangle = \\frac{1}{2} (|00\\rangle + e^{i\\pi/2}|01\\rangle + e^{i\\pi}|10\\rangle + e^{3i\\pi/2}|11\\rangle) = \\frac{1}{2}(|00\\rangle + i|01\\rangle - |10\\rangle - i|11\\rangle)$$\n", + "\n", + "And we can see this winding in the plot of complex amplitude vs. computational basis state:\n", + "\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_1$. The red line shows how the complex phase accumulates such that it winds around $2\\pi$ once as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi1.avif)\n", + "\n", + "\n", + "So, each state has a phase that is $2\\pi/4$ radians higher than the state before it when they're ordered in the standard way, since in this example we have four basis states ($N=4$). The next basis state winds around from 0 to 2$\\pi$ twice:\n", + "\n", + "$$|\\phi_2\\rangle = \\frac{1}{2} (|00\\rangle + e^{i\\pi}|01\\rangle + e^{2i\\pi}|10\\rangle + e^{3i\\pi}|11\\rangle) = \\frac{1}{2} (|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle)$$\n", + "\n", + "\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_2$. The red line shows how the complex phase accumulates such that it winds around $2\\pi$ twice as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi2.avif)\n", + "\n", + "\n", + "Finally, the highest Fourier component is the one with the fastest varying phase. For our example with two qubits, it's the one whose phases wind around from 0 to $2\\pi$ three times:\n", + "\n", + "$$|\\phi_3\\rangle = \\frac{1}{2} (|00\\rangle + e^{3i\\pi/2}|01\\rangle + e^{6i\\pi/2}|10\\rangle + e^{9i\\pi/2}|11\\rangle) = \\frac{1}{2} (|00\\rangle - i|01\\rangle - |10\\rangle + i|11\\rangle)$$\n", + "\n", + "\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_3$. The red line shows how the complex phase accumulates such that it winds around $2\\pi$ three times as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi3.avif)\n", + "\n", + "\n", + "\n", + "In general, for an $n$-qubit state, there will be $2^n$ Fourier basis states, whose frequency in phase variation ranges from constant, for $|\\phi_0\\rangle$, to rapidly varying for $|\\phi_{2^n-1}\\rangle$, completing $2^n-1$ windings around $2\\pi$ over the superposition of states. So, when we take a QFT of a quantum state, we're essentially doing the same basic analysis that we did for the musical waveform in the Intro. We're determining the Fourier frequency components that contribute to creating the quantum state of interest.\n", + "\n", + "### Try some example QFTs:\n", + "\n", + "Let's try to continue to build our intuition for the quantum Fourier transform by making a state in the computational basis, then seeing what happens when we apply the QFT to it. For now, we'll just treat the QFT as a black box that we apply using the `QFTGate` from the Qiskit circuit library. Later, we'll take a peak under the hood to see how it's implemented. \n", + "\n", + "We start by loading the necessary packages and selecting a device to run our circuit on:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3b420ee9-fe1f-4f29-aa73-1306e7a86688", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit.circuit.library import QFTGate\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f93e8786-96e4-4adf-97b1-1d6c1222b3dc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibm_pinguino2\n" + ] + } + ], + "source": [ + "#Load the Qiskit Runtime service\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "#Load the Runtime primitive and session\n", + "from qiskit_ibm_runtime import SamplerV2 as Sampler\n", + "\n", + "service = QiskitRuntimeService()\n", + "\n", + "#Use the least busy backend\n", + "#backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)\n", + "backend = service.backend(\"ibm_pinguino2\")\n", + "\n", + "print(backend.name)" + ] + }, + { + "cell_type": "markdown", + "id": "ea5beb2c-d7b2-4d7b-9015-02dad90d44b6", + "metadata": {}, + "source": [ + "If you don't have time available on your account or want to use a simulator for any reason, you can run the cell below to set up a simulator that will mimic the quantum device we selected above:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7f33f044-a798-4b9c-baad-6676650cd322", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the backend sampler\n", + "from qiskit.primitives import BackendSamplerV2\n", + "\n", + "# Load the Aer simulator and generate a noise model based on the currently-selected backend.\n", + "from qiskit_aer import AerSimulator\n", + "from qiskit_aer.noise import NoiseModel\n", + "noise_model = NoiseModel.from_backend(backend)\n", + "\n", + "# Define a simulator using Aer, and use it in Sampler.\n", + "backend_sim = AerSimulator(noise_model=noise_model)\n", + "sampler_sim = BackendSamplerV2(backend = backend_sim)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d4d986a-6164-40cd-8bba-0289af2430f4", + "metadata": {}, + "outputs": [], + "source": [ + "# Alternatively, load a fake backend with generic properties and define a simulator.\n", + "from qiskit.providers.fake_provider import GenericBackendV2\n", + "backend_gen = GenericBackendV2(num_qubits=18)\n", + "sampler_gen = BackendSamplerV2(backend = backend_gen)" + ] + }, + { + "cell_type": "markdown", + "id": "bce6f65e-1105-4abf-80ab-476385ff5b60", + "metadata": {}, + "source": [ + "#### Single computational basis state\n", + "\n", + "First, let's try just transforming a single computational basis state. We'll start with making a random computational state:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "79943d18-2d57-41f4-ba6e-9c40aca24d38", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 1: Map\n", + "\n", + "qubits = 4\n", + "N = 2**qubits\n", + "\n", + "\n", + "qc = QuantumCircuit(qubits)\n", + "\n", + "# flip state of random qubits to put in a random single computational basis state\n", + "for i in range(1, qubits):\n", + " if np.random.randint(0, 2):\n", + " qc.x(i)\n", + "\n", + "\n", + "# make a copy of the above circuit. (to be used when we apply the QFT in next part) \n", + "qc_qft = qc.copy() \n", + "\n", + "\n", + "qc.measure_all()\n", + "qc.draw('mpl')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c16bbbb1-99fe-4824-b9a5-b74fa79eeedf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/g0lEQVR4nO3deVjU5f7/8dfMsIgKKMgiiihWoKZpZqi5oaYhaovaZmJmnWPHFrU86rFMU7PstJ+T7dqprGyzNFPcPeaaxjHNzMzEVFRcQEBZhs/vj77MT0JMEJjm5vm4Lq6Luedm5v2+Z5QXn/ksNsuyLAEAAMDj2d1dAAAAACoGwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADOHl7gI8VWFhoQ4ePCh/f3/ZbDZ3lwMAAAxlWZZOnTqliIgI2e3n3yZHsCungwcPKjIy0t1lAACAamL//v1q2LDheecQ7MrJ399f0m+LHBAQ4OZqAACAqTIzMxUZGenKHudDsCunoo9fAwICCHYAAKDSXciuXxw8AQAAYAiCHQAAgCEIdkAZnDp1SqNGjVJUVJT8/PzUsWNHbd68udicnTt3qn///goMDFStWrXUrl07paamuu7fs2ePbrzxRoWEhCggIEA333yzDh8+XNWtAAAMRLADyuDuu+/W0qVL9c477+i7775Tr1691LNnTx04cEDSb6GtU6dOio2N1apVq7Rt2zY9+uijqlGjhiQpOztbvXr1ks1m04oVK/T1118rLy9P/fr1U2FhoTtbAwAYwGZZluXuIjxRZmamAgMDlZGRwcET1cTp06fl7++vzz//XImJia7xtm3bKiEhQdOmTdOtt94qb29vvfPOO+d8jOTkZCUkJOjEiROu901GRobq1q2r5ORk9ezZs0p6AQB4jrJkDrbYAReooKBATqfTtfWtiJ+fn9auXavCwkJ9+eWXuuyyy9S7d2+FhoYqLi5O8+fPd83Nzc2VzWaTr6+va6xGjRqy2+1au3ZtVbUCADAUwQ64QP7+/urQoYOmTp2qgwcPyul06t1339X69et16NAhHTlyRFlZWXryySd13XXXKTk5WTfeeKNuuukmrV69WpLUvn171apVS+PGjVNOTo6ys7P18MMPy+l06tChQ27uEADg6Qh2QBm88847sixLDRo0kK+vr1588UXddtttstvtrn3krr/+eo0ePVqtW7fW+PHj1bdvX73yyiuSpJCQEH300UdasGCBateurcDAQJ08eVJXXnnlH14mBgCAP8IJioEyaNq0qVavXq3s7GxlZmaqfv36uuWWWxQdHa169erJy8tLzZs3L/YzzZo1K/Yxa69evbRnzx6lp6fLy8tLderUUXh4uKKjo6u6HQCAYdhEAJRDrVq1VL9+fZ04cUJLlizR9ddfLx8fH7Vr1067du0qNvfHH39UVFRUiceoV6+e6tSpoxUrVujIkSPq379/VZUPADAUW+yAMliyZIksy1JMTIx++uknjR07VrGxsRo2bJgkaezYsbrlllvUpUsXxcfHa/HixVqwYIFWrVrleozZs2erWbNmCgkJ0fr16/Xggw9q9OjRiomJcVNXAABTEOyAMsjIyNCECRP066+/KigoSAMGDND06dPl7e0tSbrxxhv1yiuvaMaMGXrggQcUExOjTz75RJ06dXI9xq5duzRhwgQdP35cjRs31sSJEzV69Gh3tQQAMAjnsSsnzmMHAACqAuexAwAAqIYIdgAAAIYg2AEAABiCYAcAAGCIP12wW7Nmjfr166eIiAjZbLZi19mUJMuyNGnSJNWvX19+fn7q2bOndu/eXWzO8ePHNXjwYAUEBKhOnToaPny4srKyis3Ztm2bOnfurBo1aigyMlIzZ86s7NYAAAAq1Z8u2GVnZ+uKK67Qv//973PeP3PmTL344ot65ZVXtHHjRtWqVUu9e/fWmTNnXHMGDx6sHTt2aOnSpVq4cKHWrFmjv/zlL677MzMz1atXL0VFRWnLli16+umnNXnyZL322muV3h8AAEBl+VOf7sRms+mzzz7TDTfcIOm3rXURERF66KGH9PDDD0v67bxiYWFhmjNnjm699Vbt3LlTzZs31+bNm3XVVVdJkhYvXqw+ffro119/VUREhGbNmqWJEycqLS1NPj4+kqTx48dr/vz5+uGHHy6oNk53AgAAqoKxpzvZu3ev0tLS1LNnT9dYYGCg4uLitH79eknS+vXrVadOHVeok6SePXvKbrdr48aNrjldunRxhTpJ6t27t3bt2qUTJ05UUTcAAAAVy6OuPJGWliZJCgsLKzYeFhbmui8tLU2hoaHF7vfy8lJQUFCxOU2aNCnxGEX31a1bt8Rz5+bmKjc313U7MzNTkpSfn6/8/HxJkt1ul8PhkNPpVGFhoWtu0XhBQYHO3kDqcDhkt9tLHS963LP7kKSCgoILGvf29lZhYaGcTqdrzGazycvLq9Tx0mqnJ3qiJ3qiJ3qiJ/f0dPbP/hGPCnbuNGPGDE2ZMqXEeHJysmrWrClJatSokdq0aaNt27YpNTXVNScmJkaxsbHatGmTjh496hpv3bq1oqKitGbNGp06dco13qFDB4WGhio5ObnYGyc+Pl5+fn5atGhRsRr69Omj06dPa+XKla4xLy8vJSYmKj093bU1U5L8/f3VvXt37d+/XykpKa7xkJAQdezYUbt37y52EXt6oid6oid6oid6cm9PDRo00IXyqH3sfv75ZzVt2lTffvutWrdu7ZrXtWtXtW7dWi+88ILeeustPfTQQ8U+Ui0oKFCNGjX00Ucf6cYbb1RSUpIyMzOLHXG7cuVKde/eXcePH7/gLXaRkZFKT093fd5dnf56oCd6oid6oid6oqeq6SkrK0tBQUEXtI+dR22xa9KkicLDw7V8+XJXsMvMzNTGjRt17733SvoteZ88eVJbtmxR27ZtJUkrVqxQYWGh4uLiXHMmTpyo/Px818Xbly5dqpiYmHOGOkny9fWVr69viXFvb2/XYxRxOBxyOBwl5ha9GS50/PePW55xu90uu73krpSljZdWOz3RU1nH6YmeJHoqrcayjtNT9e7pXHNK86c7eCIrK0spKSmuTZZ79+5VSkqKUlNTZbPZNGrUKE2bNk1ffPGFvvvuOyUlJSkiIsK1Va9Zs2a67rrrdM8992jTpk36+uuvdd999+nWW29VRESEJOn222+Xj4+Phg8frh07dujDDz/UCy+8oDFjxripawAAgIv3p/sodtWqVYqPjy8xPnToUM2ZM0eWZemxxx7Ta6+9ppMnT6pTp056+eWXddlll7nmHj9+XPfdd58WLFggu92uAQMG6MUXX1Tt2rVdc7Zt26aRI0dq8+bNqlevnu6//36NGzfuguvkdCcAAKAqlCVz/OmCnacg2AEAgKpg7HnsAAAAUDqCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhPOrKE0BlaDz+S3eXUGa/PJno7hIAAH9CbLEDAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMIRHBrvGjRvLZrOV+Bo5cqQkqVu3biXuGzFiRLHHSE1NVWJiomrWrKnQ0FCNHTtWBQUF7mgHAACgQni5u4Dy2Lx5s5xOp+v29u3bde2112rQoEGusXvuuUePP/6463bNmjVd3zudTiUmJio8PFzr1q3ToUOHlJSUJG9vbz3xxBNV0wQAAEAF88hgFxISUuz2k08+qaZNm6pr166usZo1ayo8PPycP5+cnKzvv/9ey5YtU1hYmFq3bq2pU6dq3Lhxmjx5snx8fCq1fgAAgMrgkcHubHl5eXr33Xc1ZswY2Ww21/h7772nd999V+Hh4erXr58effRR11a79evXq2XLlgoLC3PN7927t+69917t2LFDbdq0KfE8ubm5ys3Ndd3OzMyUJOXn5ys/P1+SZLfb5XA45HQ6VVhY6JpbNF5QUCDLslzjDodDdru91PGixy3i5fXby/X7j4xLG/f29lZhYWGxrZs2m01eXl6ljpdWe3XoyZNU59eJnuiJnuipuvV09s/+EY8PdvPnz9fJkyd15513usZuv/12RUVFKSIiQtu2bdO4ceO0a9cuffrpp5KktLS0YqFOkut2WlraOZ9nxowZmjJlSonx5ORkV2Bs1KiR2rRpo23btik1NdU1JyYmRrGxsdq0aZOOHj3qGm/durWioqK0Zs0anTp1yjXeoUMHhYaGKjk5udgbJz4+Xn5+flq0aFGxGvr06aPTp09r5cqVrjEvLy8lJiYqPT1d69evd437+/ure/fu2r9/v1JSUlzjISEh6tixo3bv3q1du3a5xqtHT573z6B6vk70RE/0RE/Vs6cGDRroQtmss2OrB+rdu7d8fHy0YMGCUuesWLFCPXr00E8//aSmTZvqL3/5i/bt26clS5a45uTk5KhWrVpatGiREhISSjzGubbYRUZGKj09XQEBAZKq118PJvV06aPJ8jR7pl9X7V4neqIneqKn6tpTVlaWgoKClJGR4cocpfG8TRVn2bdvn5YtW+baEleauLg4SXIFu/DwcG3atKnYnMOHD0tSqfvl+fr6ytfXt8S4t7e3vL29i405HA45HI4Sc4veDBc6/vvHLc+43W6X3V7y4OfSxkurvTr15Al4neiptBrLOk5P9CTRU2k1lnW8snoqy+8qjzzdSZHZs2crNDRUiYmJ551XtPmzfv36kn7b7Prdd9/pyJEjrjlLly5VQECAmjdvXmn1AgAAVCaP3WJXWFio2bNna+jQocXS9549ezR37lz16dNHwcHB2rZtm0aPHq0uXbqoVatWkqRevXqpefPmGjJkiGbOnKm0tDQ98sgjGjly5Dm3ygEAAHgCjw12y5YtU2pqqu66665i4z4+Plq2bJmef/55ZWdnKzIyUgMGDNAjjzzimuNwOLRw4ULde++96tChg2rVqqWhQ4cWO+8dAACAp/HYYNerVy+d67iPyMhIrV69+g9/PioqqsSRLgAAAJ7Mo/exAwAAwP9HsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAMQbADAAAwBMEOAADAEAQ7AAAAQxDsAAAADEGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxR7mC3Zs0apaamnnfO/v37tWbNmvI+BQAAAMqg3MEuPj5ec+bMOe+c//znP4qPjy/vUwAAAKAMyh3sLMv6wzmFhYWy2WzlfQoAAACUQaXuY7d7924FBgZW5lMAAADg/3iVZfJdd91V7Pb8+fP1yy+/lJjndDpd+9clJCRcVIEAAAC4MGUKdmfvU2ez2ZSSkqKUlJRzzrXZbGrXrp2ee+65i6kPAAAAF6hMwW7v3r2Sftu/Ljo6WqNGjdKDDz5YYp7D4VDdunVVq1atiqkSAAAAf6hMwS4qKsr1/ezZs9WmTZtiYwAAAHCfMgW7sw0dOrQi6wAAAMBFKnewK7Jp0yZt3rxZJ0+elNPpLHG/zWbTo48+erFPAwAAgD9Q7mB3/Phx3XDDDfr666/Pe047gh0AAEDVKHewGzNmjNauXatu3bpp6NChatiwoby8LnoDIAAAAMqp3Els4cKFuvrqq7V8+XKuLgEAAPAnUO4rT5w+fVpdunQh1AEAAPxJlDvYtW7d+pxXnQAAAIB7lDvYPfbYY/riiy+0YcOGiqwHAAAA5VTufezS0tKUmJiorl27avDgwbryyisVEBBwzrlJSUnlLhAAAAAXxmad71wl52G322Wz2Yqd6uT3+9tZliWbzXbO89t5uszMTAUGBiojI6PUQAvP0Hj8l+4uocx+eTLR3SUAAKpIWTJHubfYzZ49u7w/CgAAgErAJcUAAAAMUe6DJwAAAPDnUu4tdqmpqRc8t1GjRuV9GgAAAFygcge7xo0bX9DJiW02mwoKCsr7NAAAALhA5Q52SUlJ5wx2GRkZ+t///qe9e/eqa9euaty48cXUBwAAgAtU7mA3Z86cUu+zLEvPPPOMZs6cqTfffLO8TwEAAIAyqJSDJ2w2mx5++GG1aNFCY8eOrYynAAAAwO9U6lGxV111lVasWFGZTwEAAID/U6nBbs+ePRw4AQAAUEXKvY9daQoLC3XgwAHNmTNHn3/+uXr06FHRTwEAAIBzKHewK7pWbGksy1LdunX1zDPPlPcpAAAAUAblDnZdunQ5Z7Cz2+2qW7eu2rVrp2HDhik0NPSiCgQAAMCFKXewW7VqVQWWAQAAgIvFtWIBAAAMUSEHT3z99ddKSUlRZmamAgIC1Lp1a11zzTUV8dAAAAC4QBe1xW7dunWKiYlRly5d9MADD2jixIl64IEH1KVLF8XGxmr9+vUVVafL5MmTZbPZin3Fxsa67j9z5oxGjhyp4OBg1a5dWwMGDNDhw4eLPUZqaqoSExNVs2ZNhYaGauzYsZyWBQAAeLxyb7HbsWOHevXqpZycHF177bWKj49X/fr1lZaWppUrVyo5OVm9e/fWhg0b1Lx584qsWS1atNCyZctct728/n8bo0eP1pdffqmPPvpIgYGBuu+++3TTTTfp66+/liQ5nU4lJiYqPDxc69at06FDh5SUlCRvb2898cQTFVonAABAVSp3sHv88ceVl5enRYsW6brrrit237hx47R48WL1799fjz/+uD744IOLLvRsXl5eCg8PLzGekZGhN998U3PnzlX37t0lSbNnz1azZs20YcMGtW/fXsnJyfr++++1bNkyhYWFqXXr1po6darGjRunyZMny8fHp0JrBQAAqCrl/ih21apVGjhwYIlQV+S6667TwIEDtXLlynIXV5rdu3crIiJC0dHRGjx4sFJTUyVJW7ZsUX5+vnr27OmaGxsbq0aNGrk+Fl6/fr1atmypsLAw15zevXsrMzNTO3bsqPBaAQAAqkq5t9hlZGSoSZMm553TpEkTZWRklPcpzikuLk5z5sxRTEyMDh06pClTpqhz587avn270tLS5OPjozp16hT7mbCwMKWlpUmS0tLSioW6ovuL7itNbm6ucnNzXbczMzMlSfn5+crPz5f02zn8HA6HnE6nCgsLXXOLxgsKCmRZlmvc4XDIbreXOl70uEWKPnL+/f6ApY17e3ursLBQTqfTNWaz2eTl5VXqeGm1V4eePEl1fp3oiZ7oiZ6qW09n/+wfKXewi4iI0IYNG847Z+PGjYqIiCjvU5xTQkKC6/tWrVopLi5OUVFRmjdvnvz8/Cr0uc42Y8YMTZkypcR4cnKyatasKUlq1KiR2rRpo23btrm2IkpSTEyMYmNjtWnTJh09etQ13rp1a0VFRWnNmjU6deqUa7xDhw4KDQ1VcnJysTdOfHy8/Pz8tGjRomI19OnTR6dPny62ddTLy0uJiYlKT08vdhCLv7+/unfvrv379yslJcU1HhISoo4dO2r37t3atWuXa7x69FThV9ardNXzdaIneqIneqqePTVo0EAXymadHVvLYNSoUXrppZf0j3/8QxMnTlSNGjVc9505c0YzZszQtGnT9MADD+i5554rz1NcsHbt2qlnz5669tpr1aNHD504caLYVruoqCiNGjVKo0eP1qRJk/TFF18UW+C9e/cqOjpaW7duVZs2bc75HOfaYhcZGan09HQFBARIql5/PZjU06WPJsvT7Jl+XbV7neiJnuiJnqprT1lZWQoKClJGRoYrc5Sm3MHu2LFjiouL0969exUcHKyrr75aYWFhOnz4sDZv3qyjR48qOjpamzZtUlBQUHme4oJkZWWpUaNGmjx5soYOHaqQkBC9//77GjBggCRp165drlOvtG/fXl999ZX69u2rQ4cOuS539tprr2ns2LE6cuSIfH19L+h5MzMzFRgYeEGLjD+3xuO/dHcJZfbLk4nuLgEAUEXKkjnK/RlUcHCwNmzYoL///e/64IMPim2qrFGjhoYNG6annnqqwkPdww8/rH79+ikqKkoHDx7UY489JofDodtuu02BgYEaPny4xowZo6CgIAUEBOj+++9Xhw4d1L59e0lSr1691Lx5cw0ZMkQzZ85UWlqaHnnkEY0cOfKCQx0AAMCf0UXtXFSvXj299dZbevXVV/XDDz+4rjwRGxsrb2/viqqxmF9//VW33Xabjh07ppCQEHXq1EkbNmxQSEiIJOm5556T3W7XgAEDlJubq969e+vll192/bzD4dDChQt17733qkOHDqpVq5aGDh2qxx9/vFLqBQAAqCpl/ih2+vTpys7O1pQpU0oNb3l5eZoyZYr8/f01fvz4Cin0z4aPYs3BR7EAgD+zsmSOMp3HbtmyZZo0aZKCg4PPu0XOx8dHwcHBmjhxYqWcxw4AAAAllSnY/ec//1HdunV13333/eHckSNHKigoSLNnzy53cQAAALhwZQp269atU8+ePS/oIANfX1/17NnTdY1WAAAAVK4yBbuDBw8qOjr6guc3adJEhw4dKnNRAAAAKLsyBbtzncDvfPLz82W3l/tytAAAACiDMqWuiIgIbd++/YLnb9++vUyXwQAAAED5lSnYde7cWStWrNAvv/zyh3N/+eUXrVixQl26dClvbQAAACiDMgW7kSNHKj8/XwMHDlR6enqp844dO6ZBgwapoKBA995770UXCQAAgD9WpitPXHnllRo1apSef/55NW/eXCNGjFB8fLwaNmwoSTpw4ICWL1+u1157TUePHtWYMWN05ZVXVkrhAAAAKK7MlxR75plnVKNGDT399NOaPn26pk+fXux+y7LkcDg0YcIETZs2rcIKBQAAwPmVOdjZbDY98cQTGj58uGbPnq1169YpLS1NkhQeHq5rrrlGd955p5o2bVrhxQIAAKB0ZQ52RZo2bcoWOQAAgD8RTjIHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACG8LhgN2PGDLVr107+/v4KDQ3VDTfcoF27dhWb061bN9lstmJfI0aMKDYnNTVViYmJqlmzpkJDQzV27FgVFBRUZSsAAAAVysvdBZTV6tWrNXLkSLVr104FBQX6xz/+oV69eun7779XrVq1XPPuuecePf74467bNWvWdH3vdDqVmJio8PBwrVu3TocOHVJSUpK8vb31xBNPVGk/AAAAFcXjgt3ixYuL3Z4zZ45CQ0O1ZcsWdenSxTVes2ZNhYeHn/MxkpOT9f3332vZsmUKCwtT69atNXXqVI0bN06TJ0+Wj49PpfYAAABQGTzuo9jfy8jIkCQFBQUVG3/vvfdUr149XX755ZowYYJycnJc961fv14tW7ZUWFiYa6x3797KzMzUjh07qqZwAACACuZxW+zOVlhYqFGjRumaa67R5Zdf7hq//fbbFRUVpYiICG3btk3jxo3Trl279Omnn0qS0tLSioU6Sa7baWlp53yu3Nxc5ebmum5nZmZKkvLz85Wfny9JstvtcjgccjqdKiwsdM0tGi8oKJBlWa5xh8Mhu91e6njR4xbx8vrt5fr9voCljXt7e6uwsFBOp9M1ZrPZ5OXlVep4abVXh548SXV+neiJnuiJnqpbT2f/7B/x6GA3cuRIbd++XWvXri02/pe//MX1fcuWLVW/fn316NFDe/bsUdOmTcv1XDNmzNCUKVNKjCcnJ7v232vUqJHatGmjbdu2KTU11TUnJiZGsbGx2rRpk44ePeoab926taKiorRmzRqdOnXKNd6hQweFhoYqOTm52BsnPj5efn5+WrRoUbEa+vTpo9OnT2vlypWuMS8vLyUmJio9PV3r1693jfv7+6t79+7av3+/UlJSXOMhISHq2LGjdu/eXexglOrRk+f9M6ierxM90RM90VP17KlBgwa6UDbr7NjqQe677z59/vnnWrNmjZo0aXLeudnZ2apdu7YWL16s3r17a9KkSfriiy+KLfLevXsVHR2trVu3qk2bNiUe41xb7CIjI5Wenq6AgABJ1euvB5N6uvTRZHmaPdOvq3avEz3REz3RU3XtKSsrS0FBQcrIyHBljtJ43KYKy7J0//3367PPPtOqVav+MNRJcgW4+vXrS/otnU+fPl1HjhxRaGioJGnp0qUKCAhQ8+bNz/kYvr6+8vX1LTHu7e0tb2/vYmMOh0MOh6PE3KI3w4WO//5xyzNut9tlt5fclbK08dJqr049eQJeJ3oqrcayjtMTPUn0VFqNZR2vrJ7K8rvK44LdyJEjNXfuXH3++efy9/d37RMXGBgoPz8/7dmzR3PnzlWfPn0UHBysbdu2afTo0erSpYtatWolSerVq5eaN2+uIUOGaObMmUpLS9MjjzyikSNHnjO8AQAAeAKPOyp21qxZysjIULdu3VS/fn3X14cffihJ8vHx0bJly9SrVy/FxsbqoYce0oABA7RgwQLXYzgcDi1cuFAOh0MdOnTQHXfcoaSkpGLnvQMAAPA0HrfF7o92CYyMjNTq1av/8HGioqJK7BAJAADgyTxuix0AAADOjWAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgh0AAIAhCHYAAACGINgBAAAYgmAHAABgCIIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHQAAgCEIdgAAAIYg2AEAABiCYAcAAGAIgp3B1qxZo379+ikiIkI2m03z58933Zefn69x48apZcuWqlWrliIiIpSUlKSDBw+6r2AAAHBRCHYGy87O1hVXXKF///vfJe7LycnR1q1b9eijj2rr1q369NNPtWvXLvXv398NlQIAgIpAsDNYQkKCpk2bphtvvLHEfYGBgVq6dKluvvlmxcTEqH379vrXv/6lLVu2KDU11Q3VAvgzady4sWw2W4mvkSNHurs0oEycTqceffRRNWnSRH5+fmratKmmTp0qy7LcXVql8HJ3AfjzyMjIkM1mU506ddxdCgA327x5s5xOp+v29u3bde2112rQoEFurAoou6eeekqzZs3S22+/rRYtWuibb77RsGHDFBgYqAceeMDd5VU4tthBknTmzBmNGzdOt912mwICAtxdDnBes2bNUqtWrRQQEKCAgAB16NBBX331lbvLMkpISIjCw8NdXwsXLlTTpk3VtWtXd5cGlMm6det0/fXXKzExUY0bN9bAgQPVq1cvbdq0yd2lVQqCHZSfn6+bb75ZlmVp1qxZ7i4H+EMNGzbUk08+qS1btuibb75R9+7ddf3112vHjh3uLs1IeXl5evfdd3XXXXfJZrO5uxyjnO8gN1SMjh07avny5frxxx8lSf/73/+0du1aJSQkuLmyysFHsdVcUajbt2+fVqxYwdY6eIR+/foVuz19+nTNmjVLGzZsUIsWLdxUlbnmz5+vkydP6s4773R3KcYpOsjtrrvu0k033eTucow0fvx4ZWZmKjY2Vg6HQ06nU9OnT9fgwYPdXVqlINhVY0Whbvfu3Vq5cqWCg4PdXRJQZk6nUx999JGys7PVoUMHd5djpDfffFMJCQmKiIhwdynGSUhIMHbL0Z/FvHnz9N5772nu3Llq0aKFUlJSNGrUKEVERGjo0KHuLq/CEewMlpWVpZ9++sl1e+/evUpJSVFQUJDq16+vgQMHauvWrVq4cKGcTqfS0tIkSUFBQfLx8XFX2cAF+e6779ShQwedOXNGtWvX1meffabmzZu7uyzj7Nu3T8uWLdOnn37q7lKAchk7dqzGjx+vW2+9VZLUsmVL7du3TzNmzCDYwbN88803io+Pd90eM2aMJGno0KGaPHmyvvjiC0lS69ati/3cypUr1a1bt6oqEyiXmJgYpaSkKCMjQx9//LGGDh2q1atXE+4q2OzZsxUaGqrExER3lwKUS05Ojuz24ocUOBwOFRYWuqmiykWwM1i3bt3Oe54eU8/hg+rBx8dHl1xyiSSpbdu22rx5s1544QW9+uqrbq7MHIWFhZo9e7aGDh0qLy9+XcAz9evXT9OnT1ejRo3UokULffvtt3r22Wd11113ubu0SsG/VABGKCwsVG5urrvLMMqyZcuUmppq7C9AVA8vvfSSHn30Uf3tb3/TkSNHFBERob/+9a+aNGmSu0urFAQ7AB5nwoQJSkhIUKNGjXTq1CnNnTtXq1at0pIlS9xdmlF69erFln14PH9/fz3//PN6/vnn3V1KlSDYAfA4R44cUVJSkg4dOqTAwEC1atVKS5Ys0bXXXuvu0oAyOd9Bbo0aNXJjZfBU1T7Y/fvf/9bTTz+ttLQ0XXHFFXrppZd09dVXu7ssl8bjv3R3CWX2y5PsZI3K9eabb7q7BKBCnO8gtzlz5ripKniyah3sPvzwQ40ZM0avvPKK4uLi9Pzzz6t3797atWuXQkND3V0eAMBwf3SQW3XlaRs1/kwbNKp1sHv22Wd1zz33aNiwYZKkV155RV9++aXeeustjR8/3s3VAUDZeNovQ+nP9QsRMEG1DXZ5eXnasmWLJkyY4Bqz2+3q2bOn1q9fX2J+bm5usSPuMjIyJEnHjx9Xfn6+6+eLLldy9vlxisYLCgqK/WXmcDhkt9tLHc/Pz1dhbk7FNV1FMjMzz9vT2YpOoVBQUHBB497e3iosLJTT6XSN2Ww2eXl5lTpe2utRNO6Ja3zixInz9vT78fK8985WEa9Tm2krytuuW3z7SPdityvjvff78Yt9nTzxvXzs2DFJf+7/I34//mf492R6T572Xj527Filvk5ZWVmSLuw0ZdU22KWnp8vpdCosLKzYeFhYmH744YcS82fMmKEpU6aUGG/SpEml1eipAp93dwXmC3re3RWYr97z7q6gemCdYYKqeh+fOnVKgYGB551TbYNdWU2YMMG1U6v02zmzjh8/ruDgYNlsNjdWVnaZmZmKjIzU/v37FRAQ4O5yjMU6Vz7WuPKxxlWDda58nrzGlmXp1KlTF3S95mob7OrVqyeHw6HDhw8XGz98+LDCw8NLzPf19ZWvr2+xsTp16lRmiZUuICDA497cnoh1rnysceVjjasG61z5PHWN/2hLXRH7H08xk4+Pj9q2bavly5e7xgoLC7V8+XJ16NDBjZUBAACUT7XdYif9dr6goUOH6qqrrtLVV1+t559/XtnZ2a6jZAEAADxJtQ52t9xyi44ePapJkyYpLS1NrVu31uLFi0scUGEaX19fPfbYYyU+WkbFYp0rH2tc+VjjqsE6V77qssY2izMjAgAAGKHa7mMHAABgGoIdAACAIQh2AAAAhiDYAQAAGIJgBwAAYAiCHSSp2MWGUXHOPuicNYYn4/0LeAaCXTXndDolSXb7b28Fy7L4D7wC2Ww2ZWdnS/r/aywVD3y4OLxfq4bdbtexY8dct3kPV7yi/49RNUx9D3Meu2oqPT1dn376qXbs2KHdu3erbdu2Gjx4sGJjY91dmjF++eUXffjhh1q3bp327Nmja665RjfccIPi4+NVo0YNd5dnHMuyZFlWsQB99n02m80NVZlh+/btevfdd5WcnKyDBw8qLi5OCQkJ6tGjhy699FJJrHFFKvpj5VzvZVy8nJwc5eTkqF69enI6nXI4HO4uqUIR7Kqp66+/Xjt27FCTJk0UGRmpjRs3aufOnWrVqpXGjx+vQYMGGfdmr2rdu3fXsWPHdNVVVyk8PFyrVq3SN998o/r162vs2LEaMWIEa3yRnnzySbVq1Updu3ZVrVq1XONOp1N2u52gUUHi4uLk5eWl3r17KzQ0VIsXL9aSJUtUu3ZtjRgxQo888oh8fX0JdxfhgQceULt27dS/f/9iF3t3Op2y2WyEvAry8ccfa86cOfr2229lWZY6d+6s/v37q3v37qpfv767y6sYFqqd5cuXW8HBwdbPP/9sWZZlnTp1yjp06JC1ZMkSa8iQIVZsbKz1+uuvu7lKz7ZixQorODjYSk9PtyzLsgoLCy3Lsqxdu3ZZDz/8sBUZGWmNHz/enSV6vP/+97+WzWaz2rdvb/Xt29d6/PHHrfXr1xebk5OTY91///3Wvn373FSl51u5cqVVr149Kzs7u9h4bm6u9cILL1gNGza0Bg0aZJ0+fdpNFXq+ovfy5ZdfbrVs2dIaPny49dVXXxWbk5OTYw0bNszasWOHm6r0fKtXr7aaNGliDRw40Prwww+tf/3rX1a3bt0su91uNW3a1HrrrbfcXWKFYItdNfTYY49p3bp1Wrp0aYn70tPT9cwzz+ill17S+vXr1bJlSzdU6Plmzpyp+fPna9WqVfLx8VFhYaFsNptsNpvy8/P15ptv6u9//7sWLVqkTp06ubtcj/T3v/9dGzZs0A033KBt27bp559/VkFBgSIjI9W5c2f16tVLJ06cUIcOHZSRkSF/f393l+yRXn75Zb3xxhtaunSpgoODlZeXJ5vNJm9vb0nSokWLlJSUpDlz5qhv375urtYzTZw4URs3btTw4cO1a9cubdy4Ufv27VPt2rXVvXt33XzzzXI6nYqLi+O9fBEGDRqkunXr6rXXXis2np6erqeeekpvv/22/vGPf2jUqFHuKbCCsG23GurZs6e2bdum5OTkEvfVq1dPU6ZMUVxcnFavXu2G6syQmJioPXv2aP78+ZLk+ljQsix5e3trxIgR6tq1q1atWuXWOj1Zenq6YmJiNGbMGL3xxht64okn1LdvXzmdTs2dO1cjRozQwIED1bt3b34RXoT+/fsrPT1d77//viTJx8dH3t7erv3A+vTpo/j4eK1Zs8adZXq07OxsRUVF6ZZbbtHkyZP17LPP6pFHHlHHjh21bt06JSUlqXv37kpISOC9fBFyc3Pl6+vrup2Xl6eCggLVq1dPTz/9tJKSkvTmm29q//79bqyyArh5iyHcICcnx0pKSrKaN29uPf3001ZKSoqVlZXluj8jI8Nq0KCB9cknn7ixSs9WUFBgjRkzxgoJCbH+9re/WYsXL7aOHTvmuv/w4cNWw4YNrY8//tiNVXq2Q4cOWStXriwxfuzYMWvhwoXW6NGjLZvNZn355ZdVX5whinYhePLJJ63atWtb1113nTVnzhzr4MGDrjm//PKLFRkZac2bN89dZXq8U6dOWRs2bDjn+DfffGM999xzvJcrwLvvvmuFhIRYmzZtKjbudDoty7Kso0ePWk2aNDnna+FJ+Ci2mkpNTdWMGTO0YsUK1atXT1dffbXCw8Nlt9u1YcMGfffdd/rxxx/dXaZHy87O1qxZs/T5558rLy9PUVFRCgoKUkBAgDZt2qSTJ08qJSXF3WV6JOt3O+kXFhaqsLBQDofDNb5gwQLddtttysrKcleZRvn000/1/vvva9++ffLy8lJAQIDq16+vb7/9VrVr19batWvdXaIxfv/+XrBggQYNGqQzZ864sSrPZlmWsrOzdffdd2vp0qXq27ev6ywFderUkSR9+OGHuvvuu3Xq1Cn3FnuRCHbVXEpKit555x1t2LBBlmXpxIkTiouL05gxY9SqVSt3l2eEvXv3asGCBdq0aZNOnDihtLQ0de/eXffee6+io6PdXZ5xrP877cnf/vY3HT9+XPPmzXN3ScbYv3+/1q5dqx07dujAgQP69ddf1bt3b91xxx0KDw93d3lGsixLjz32mA4fPqxXX33V3eV4vKysLM2ZM0dffPGF0tPT5ePjI39/f1mWpQMHDujmm2/WlClT3F3mRSHYVSP5+fn6/vvvtXDhQtWuXVtt27ZVmzZtXKeJ+OGHHxQdHS1vb29OWVBOOTk52rBhg+bNm6c6dero8ssvV5s2bdSiRQtJ0uHDhxUWFubmKj1b0Rp/9NFHCgoKUrNmzXTJJZfosssuU1BQkGue0+nUqVOnXH+No3wKCgokSV5eXsXGf7+/Esrvj05pUlhYqOzsbPavq0AHDx7UmjVrtHPnTu3fv1+5ubkaOXKk2rZt6/Hva4JdNfLwww/r/fffV2hoqI4fP679+/erUaNGuvXWW/X3v/+92C9FlE/RZv7GjRsrPT1d+/fvV2hoqDp16qTRo0friiuucHeJHu9ca1y/fn117txZI0eOVJs2bdxdohE2btyouLi4YmO/PyK2oKCgRODDhTvXGhcUFMhut7tCXmFhIeewu0g//fST/vWvf2nLli2uPwLbt2+vuLg41axZ093lVbyq360P7rBjxw7L39/f+vLLL62DBw9aTqfT+uWXX6xJkyZZDRo0sAICAqy3337b3WV6tB07dli1a9e21q5da+Xk5FiWZVnHjx+3XnzxRatFixaW3W63nnrqKcvpdLp2SkfZXMgaz5w5kzW+SD/88INls9msBg0aWMOHDy+xM3lhYaGVm5trffHFF1ZaWpqbqvRsrHHV2LNnj9WsWTPr6quvth544AGrR48e1uWXX25dccUVVlJSkrV582Z3l1jhCHbVxLRp06wuXbq4bhcUFLi+z8rKsh588EGrZcuW1pEjR9xRnhGeeeYZq1OnTq7bubm5xe5/+umnrSZNmrhODI2yY42rxtSpU60WLVpYkyZNsjp16mQFBgZal112mfXoo49ae/futSzrt6OSbTablZqa6t5iPRRrXDVGjBhh9evXzzpx4oRr7MCBA9bLL79stWnTxvL397feffdd9xVYCdi+W000a9ZMR44cUWpqqiTJ4XCooKBAeXl5qlWrlkaOHCmbzaZPPvnEzZV6riuuuEK//vqr6+hAHx8fFRQU6PTp05KkIUOGKCwsTB988IE7y/RorHHVOHjwoLp376777rtP77//vt577z317dtXn332mVq1aqVOnTopKSlJzZo1U2RkpLvL9UiscdXYu3evrrrqKtWpU0dOp1NOp1MRERG69957tXXrVg0ePFivvvqqcnNzZRmyZxrBrpro2rWrJCkhIUGffPKJcnNz5eXlJR8fH0lyXcibfTnKr2PHjrrkkkt0yy236PXXX9fp06fl5eUlPz8/SVJYWJhOnz5d7DqQKBvWuPI5nU717dtXsbGxCgkJUcOGDZWYmKjHH39cH330kV577TVdcsklWrZsmR566CF3l+uRWOOq07t3b82ZM0c///yzHA6HHA6H8vLylJubK0kaMWKEfv31V23cuNGYgwY5eKIaOXjwoMaMGaOdO3eqYcOGateuneLj4xUVFaWXXnpJb7/9tvbt21fsYuoom9OnT2vixImaP3++atasqbi4OPXv31916tTRm2++qeXLl+vHH39kjS8Ca1y1zrXz/sKFC9W/f39lZWWZufN5FWONK8/PP/+sAQMGKDMzU5MmTdLQoUOL3b9jxw61adNGJ0+eNGadCXbVzJEjR7Ro0SItW7ZM+/bt065du5Senq5u3brp7rvv1u233+7uEj1W0X/Op06d0tq1a7V27Vpt3rxZ33zzjQoKCtSzZ08NHz5ciYmJ7i7VY7HGlc/6v/MAnm/r/ZQpU7Ru3TotWbKkCiszB2tctU6dOqXx48frgw8+UEFBga699lpdd9112r59u1atWqWWLVvqnXfecXeZFYZgVw0cPnxYe/fula+vr/z8/BQdHS273a49e/YoJydHtWrVUr169TjdyUU411/ceXl5Onr0qPz8/HTmzBkFBgayFekisMZV40JOr7Fq1SqFhIS4zs+IsmGNq07RWp85c0bfffed1qxZoxUrVmjLli2Kjo7W4MGDddNNN6l+/fruLrXCEOwM9/rrr2v27NnaunWrvLy8FBMTo2bNmqlHjx7q37+/goOD3V2iUSzLktPpLHZpK1Qs1rhqXMhWJVwc1rjqOZ1O2e122Ww2ZWRkGLk/Lu8mgx07dkzjxo1Tjx499OOPP2rDhg265ZZbdPToUU2dOlXDhg3T3r17JcmYo4Gq2okTJ9SkSRM9/PDD2rFjh2w2m7y8vGSz2eR0OlVYWChJ2rlzp8dff9BdWOOqca51PvskuUX/R+zcuVMnT550Y6WeizWuGgUFBTpy5Mg57zv7D0ITQ50kTlBsshdeeMGKi4s7530rVqyw2rVrZzVv3rzY+X1QNi+88IJls9msVq1aWTabzWrWrJk1c+bMYicU3b9/v9W6dWtrz549bqzUc7HGVYN1rnyscdV47rnnrDp16lj33XeftWbNGis7O7vEnIyMDGvRokVWXl6eGyqsXGyxM5i3t7eysrL0ww8/SJLOnDmjvLw8SVJ8fLz+85//qKCgQEuXLnVnmR5t27Ztuueee7RgwQKtXbtWPXv21EsvvaSIiAh169ZNH3zwgT755BP9+OOPio6Odne5Hok1rhqsc+VjjavG+++/r+bNm2vjxo3q1q2b2rZtq8mTJ2v79u1yOp2SpPfee09TpkxxXR7PJFzkz2CDBg3SrFmz9NJLL+mZZ55RjRo1JP3/nUljY2MVHBysffv2ublSz5Sbm6sWLVrozJkzatSokRo1aqS4uDhNmDBBGzdu1AcffKD7779fx44d0+TJk91drkdijasG61z5WOOqcfToUfn4+Oivf/2r7rjjDu3cuVPvvPOO5syZo2nTpql9+/a644479PLLL6t79+7uLrdyuHuTISpH0bUyP/nkE6thw4ZWQECAdc8991hbt261LMuyDh48aM2dO9eqXbu26/I1KLszZ85YBw4csCzrtzU/W15enrVo0SLLZrNZv/76qzvKMwJrXDVY58rHGle+gwcPWs8++6y1ZMmSYuMFBQXWmjVrrDvvvNMKDAy0bDabtX//fjdVWbnYYmeooh1yExMTFRsbq9WrV+vzzz9X586dZbPZ1KBBA+Xn52v06NFq3Lixe4v1YL6+vrLZbDp27FiJI4y9vb31zTffqHHjxmrQoIGbKvR8rHHVYJ0rH2tc+erXr68RI0a4bluWJZvNJofDoc6dO6tz584KDg7WihUr1LBhQzdWWnkIdgZKT0/Xhx9+qKefflrBwcEKCgpS3bp11bNnT40dO1Y5OTn6+eeflZCQ4LqUGMqmaI3/+c9/KiQkRAEBAYqIiFD//v2VmJgoPz8/FRYWKiwsTC+++KK7y/VIrHHVYJ0rH2tctYouMSipxCmRzpw5o4ULF2rYsGFVXVaV4Tx2Brrrrrv0v//9TwkJCapdu7aOHTumn376SQcOHFBUVJSmTJmi5s2bu7tMj3b2Gvv7++vYsWPauXOn9u/fr0svvVRjxoxRhw4d3F2mR2ONqwbrXPlY46px+vTpYqGutDnz5s3Tbbfd5rpWumkIdoaxLEu1a9fWokWL1LVrV9fYTz/9pP/+97964403dPz4cX388ce6/PLL3VytZyptjffs2aP//ve/ev3115WRkaF58+Zx1vhyYo2rButc+VjjqvPQQw/pmmuuUdu2bRUeHi5fX98Sc06ePKk6depUfXFViNOdGOb7779XdHR0scsq2Ww2XXrppbrrrru0fPly+fr66uOPP3ZjlZ6ttDW+5JJLNGzYMC1fvlxeXl766KOP3FilZ2ONqwbrXPlY46oxd+5cPffcc7r11lsVHx+vCRMmaOXKlTpy5IgKCgokSdnZ2UpKStL27dvdXG3lItgZJjo6WqGhoXrooYe0d+/eEleU8PPz09ChQ7Vw4UI3Vej5WOPKxxpXDda58rHGVWPFihUaMWKEfvjhBw0fPlyfffaZevTooYSEBP3zn//Ut99+q3nz5umrr74y/tMqgp1h/Pz8NG3aNGVmZmrIkCGaO3euDh06pNOnT0v67VxKGzZsUExMjJsr9VysceVjjasG61z5WOPKV1BQoOjoaNWpU0fR0dGaOHGi9u7dq5SUFF111VV68skn1aVLF/31r3/VkCFD3F1upWMfO0N99913mjp1qhYsWKDatWurU6dOCg8P15IlS1SvXj298cYbatWqlbvL9GisceVjjasG61z5WOPKdfLkSR0+fFgxMTHKy8uTt7d3sSNi33vvPQ0ZMkTffvutrrjiCjdWWvkIdoY7cuSIFi5cqPnz58vPz0+XX365Bg4cqGbNmrm7NGOwxpWPNa4arHPlY42rTmFhoSzLksPh0Ouvv64HH3xQOTk57i6r0hHsqpGiS4mh8rDGlY81rhqsc+VjjavOs88+K6fTqbFjx7q7lEpHsAMAAEbLz8+Xw+GoFkGaYAcAAGAI86MrAABANUGwAwAAMATBDgAAwBAEOwAAAEMQ7AAAAAxBsAMAADAEwQ4AAMAQBDsAAABDEOwAAAAM8f8Ayn9nKTMEv+QAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "# Step 2: Transpile\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "\n", + "qc_isa = pm.run(qc)\n", + "\n", + "# Step 3: Run the job on a real quantum computer OR try fake backend\n", + "\n", + "sampler = Sampler(mode = backend)\n", + "pubs = [qc_isa]\n", + "\n", + "# Run the job on real quantum device\n", + "\n", + "job = sampler.run(pubs,shots=1000) \n", + "res = job.result()\n", + "counts = res[0].data.meas.get_counts()\n", + "\n", + "# OR Run the job on the Aer simulator with noise model from real backend\n", + "\n", + "#job = sampler_sim.run([qc_isa])\n", + "#res = job.result()\n", + "#counts = res[0].data.meas.get_counts()\n", + "\n", + "# Step 4: Post-Process\n", + "plot_histogram(counts)" + ] + }, + { + "cell_type": "markdown", + "id": "f3723281-56f2-42ac-afd9-44f6d0fe147b", + "metadata": {}, + "source": [ + "Now, let's Fourier transform this state with `QFTGate`:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "51b45910-624c-40ee-ad56-d9af094490d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 1: Map\n", + "\n", + "qc_qft.compose(QFTGate(qubits),inplace=True)\n", + "qc_qft.measure_all()\n", + "qc_qft.draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "198a4223-96ab-475e-a83c-75596bf569cb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 2: Transpile\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "\n", + "qc_isa = pm.run(qc_qft)\n", + "\n", + "# Step 3: Run the job on a real quantum computer - try fake backend\n", + "\n", + "sampler = Sampler(mode = backend)\n", + "pubs = [qc_isa]\n", + "\n", + "# Run the job on real quantum device\n", + "\n", + "job = sampler.run(pubs,shots=1000) \n", + "res = job.result()\n", + "counts = res[0].data.meas.get_counts()\n", + "\n", + "# OR Run the job on the Aer simulator with noise model from real backend\n", + "\n", + "#job = sampler_sim.run([qc_isa])\n", + "#res = job.result()\n", + "#counts = res[0].data.meas.get_counts()\n", + "\n", + "# Step 4: Post-Process\n", + "plot_histogram(counts)" + ] + }, + { + "cell_type": "markdown", + "id": "89965746-e7d1-409f-a893-5766759a8ce3", + "metadata": {}, + "source": [ + "As you can see, we measure the populations of each state to be more or less equal, give or take some experimental and statistical noise. So, if you take the QFT of a single computational basis state, the result is an equal superposition of all states. If you're familiar with Fourier transforms, this probably doesn't surprise you. One basic principle that can help us build an intuitive connection between a function and its Fourier transform is that the width of a function is inversely proportional to the width of its Fourier transform. So, something that is very localized in time, for example, like a very short pulse, will require a broad range of frequencies to generate that pulse. So that signal will be very broad in Fourier space.\n", + "\n", + "This fact is actually related to quantum uncertainty! Heisenberg's uncertainty principle is typically stated as $\\Delta x \\Delta p \\ge \\hbar / 2 $. So if th uncertainty in $x$ ($\\Delta x$) is small, the uncertainty in momentum ($\\Delta p$) must be big, and vice-versa. It turns out that transforming from the position basis $x$ to the momentum basis $p$ is accomplished through a Fourier transform.\n", + "\n", + "Note: Keep in mind, we're measuring populations in each of the basis states, so we're losing information about the relative phases between the various parts of the superposition. So, while the QFT of any single computational basis state will yield the same even spread in population over all the basis states, the *phases* won't necessarily be the same.\n", + "\n", + "\n", + "\n", + "#### Two computational basis states\n", + "\n", + "Now, let's see what happens when we prepare a superposition of computational basis states. What do you think the Fourier transform will look like in this case? \n", + "\n", + "Let's choose the superposition:\n", + "\n", + "$$|\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |N/2\\rangle) = \\frac{1}{\\sqrt{2}} (|000...0\\rangle + |100...0\\rangle)$$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cd0b237b-b139-451a-8170-69babdc29e56", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 1: Map\n", + "qubits = 4\n", + "N = 2**qubits\n", + "\n", + "\n", + "qc = QuantumCircuit(qubits)\n", + "\n", + "# to make this state, we just need to apply a hadamard to the last qubit\n", + "\n", + "qc.h(qubits-1)\n", + "\n", + "\n", + "qc_qft = qc.copy()\n", + "\n", + "\n", + "\n", + "qc.measure_all()\n", + "\n", + "qc.draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0ad8006b-caaf-4e4c-b222-a9224d3f6af8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# First, let's go through steps 2-4 for the first circuit, qc\n", + "\n", + "# Step 2: Transpile\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "\n", + "qc_isa = pm.run(qc)\n", + "\n", + "# Step 3: Run the job on a real quantum computer - try fake backend\n", + "\n", + "sampler = Sampler(mode = backend)\n", + "pubs = [qc_isa]\n", + "\n", + "# Run the job on real quantum device\n", + "\n", + "job = sampler.run(pubs,shots=1000) \n", + "res = job.result()\n", + "counts = res[0].data.meas.get_counts()\n", + "\n", + "# OR Run the job on the Aer simulator with noise model from real backend\n", + "\n", + "#job = sampler_sim.run([qc_isa])\n", + "#res = job.result()\n", + "#counts = res[0].data.meas.get_counts()\n", + "\n", + "# Step 4: Post-Process\n", + "plot_histogram(counts)\n" + ] + }, + { + "cell_type": "markdown", + "id": "93aaa06c-7de3-4c0f-950c-e48768ca50c5", + "metadata": {}, + "source": [ + "Now, let's Fourier transform this state with `QFTGate`:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "11793bc2-53ea-4c34-aed7-06e1ce630557", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 1: Map \n", + "\n", + "qc_qft.compose(QFTGate(qubits),inplace=True)\n", + "qc_qft.measure_all()\n", + "qc_qft.draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "15b9688a-8c71-457d-87e7-8bfec6f4ee76", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "# Step 2: Transpile\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "target = backend.target\n", + "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", + "\n", + "qc_isa = pm.run(qc_qft)\n", + "\n", + "# Step 3: Run the job on a real quantum computer OR try fake backend\n", + "\n", + "sampler = Sampler(mode = backend)\n", + "pubs = [qc_isa]\n", + "\n", + "# Run the job on real quantum device\n", + "\n", + "job = sampler.run(pubs,shots=1000) \n", + "res = job.result()\n", + "counts = res[0].data.meas.get_counts()\n", + "\n", + "# OR Run the job on the Aer simulator with noise model from real backend\n", + "\n", + "#job = sampler_sim.run([qc_isa])\n", + "#res = job.result()\n", + "#counts = res[0].data.meas.get_counts()\n", + "\n", + "# Step 4: Post-Process\n", + "plot_histogram(counts)" + ] + }, + { + "cell_type": "markdown", + "id": "74008f89-5634-4e52-8061-87976888c39f", + "metadata": {}, + "source": [ + "This one might be a bit more surprising. It looks like the QFT of the state $|\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |N/2\\rangle)$ is a superposition of all of the even basis states. But if we think back to our visualization of each basis state $|\\phi_y\\rangle$, and how the phase of each component winds around $2\\pi$ $y$ times, then the reason we get this result might become clear.\n", + "\n", + "#### Check your understanding\n", + "Read the question(s) below, think about your answer, then click the triangle to reveal the solution.\n", + "\n", + "
\n", + "\n", + "\n", + "Using the hint above, explain why the result we got for the QFT of $|\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |N/2\\rangle)$ is expected. \n", + "\n", + "\n", + "\n", + "__Answer:__\n", + "\n", + "The original state has a relative phase of 0 (or an integer multiple of $2\\pi$) between the two parts of the superposition. So, we know this state has Fourier components whose phases also match up in that way: i.e. the ones that have 0 phase shift between the |0000> term and the |1000> term. Each Fourier basis state $|\\phi_y\\rangle$ is composed of terms whose phase accumulates at a rate of $2\\pi y/N$, meaning when ordered in the usual way, each term in the superposition has a phase of $2\\pi y/N$ greater than the term that came before. So, at the halfway point $N/2$, we want the phase $2\\pi y/N * N/2$ to be an integer multiple of $2\\pi$. This happens when $y$ is even. \n", + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + "What computational state superposition would correspond to a QFT with peaks on every odd binary number? \n", + "\n", + "\n", + "\n", + "__Answer:__\n", + "\n", + "If you took the QFT of the state $\\psi = |0\\rangle - |N/2\\rangle$, then you would see peaks on every odd binary numbered state.\n", + "\n", + "
\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "af84bf95-c211-4a58-a851-1e827a42fcdb", + "metadata": {}, + "source": [ + "## Breaking down the QFT Algorithm\n", + "\n", + "Now that we've gained more intuition into the relationship between qubit states in the computational basis and the Fourier basis, let's dig into the QFT algorithm itself. In other words, what gates do we actually implement on the quantum computer to achieve this transform? \n", + "\n", + "Let's start small, with a single qubit. So, that means we'll have 2 basis states. QFT$_2$ transforms computational basis states $|0\\rangle$ and $|1\\rangle$ into Fourier basis states $\\phi_0$ and $\\phi_1$:\n", + "\n", + "$|\\phi_0\\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle + |1\\rangle)$\n", + "\n", + "$|\\phi_1\\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle - |1\\rangle)$\n", + "\n", + "\n", + "#### Check your understanding\n", + "Read the question(s) below, think about your answer, then click the triangle to reveal the solution.\n", + "\n", + "
\n", + "\n", + "\n", + "Use the equation for the QFT in the previous section to verify these two Fourier basis states above.\n", + "\n", + "\n", + " \n", + "__Answer:__\n", + "\n", + "The general QFT formula is:\n", + "\n", + "$$ | \\phi_y \\rangle = \\frac{1}{\\sqrt{N}}\\sum_{x=0}^{N-1}\\omega_N^{y x} \\vert x \\rangle$$\n", + "\n", + "For a single qubit ($n=1$), $N=2^n=2$, and $\\omega_N^{xy} = e^{2\\pi i \\frac {y x}{2}}$. So, we have\n", + "\n", + "$ | \\phi_0 \\rangle = \\frac{1}{\\sqrt{2}}(e^{2\\pi i \\frac {0 \\times 0}{2}}|0\\rangle + e^{2\\pi i \\frac {0 \\times 1}{2}}|1\\rangle) = \\frac{1}{\\sqrt{2}}(|0\\rangle + |1\\rangle)$\n", + "\n", + "$ | \\phi_1 \\rangle = \\frac{1}{\\sqrt{2}}(e^{2\\pi i \\frac {1 \\times 0}{2}}|0\\rangle + e^{2\\pi i \\frac {1 \\times 1}{2}}|1\\rangle) = \\frac{1}{\\sqrt{2}}(|0\\rangle - |1\\rangle)$\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "Take a look at those two equations. You might already know of a quantum gate that can be used to implement this transform. That is, there is a gate that transforms the computational basis states $|0\\rangle$ and $|1\\rangle$ to the respective Fourier basis states $|\\phi_0\\rangle$ and $|\\phi_1\\rangle$. It's a Hadamard gate! This becomes even more clear if we introduce a matrix representation of the QFT$_N$ operation:\n", + "\n", + "\n", + "$$ \\text{QFT}_N = \\frac{1}{\\sqrt{N}} \\sum_{x=0}^{N-1} \\sum_{y=0}^{N-1} \\omega_N^{xy} \\vert x \\rangle \\langle y \\vert$$\n", + "\n", + "If you're not familiar with this notation for expressing a quantum operator, that's okay! It is a way to represent an $N \\times N$ matrix, where $x$ and $y$ index the columns and rows of the matrix, from $0$ to $N-1$, and $\\omega_N^{xy}$ is the value of that particular entry. So, the entry in the 0th column and 2nd row, for example, would just be $\\omega_N^{0,2} = e^{2 \\pi i \\frac{0 \\times 2}{N}} = 1$. \n", + "\n", + "In this representation, each of the computational basis states is associated with one of the basis vectors:\n", + "\n", + "$$|0\\rangle = \n", + "\\begin{pmatrix}\n", + "1 \\\\ 0 \\\\ \\vdots \\\\ 0\n", + "\\end{pmatrix},\n", + "|1\\rangle = \n", + "\\begin{pmatrix}\n", + "0 \\\\ 1 \\\\ \\vdots \\\\ 0\n", + "\\end{pmatrix},\n", + "|N-1\\rangle = \n", + "\\begin{pmatrix}\n", + "0 \\\\ 0 \\\\ \\vdots \\\\ 1\n", + "\\end{pmatrix}.\n", + "$$\n", + "\n", + "If you'd like to learn about this representation in more depth, see John Watrous's lesson on multiple systems in the [Basics of Quantum Information](/learning/courses/basics-of-quantum-information/multiple-systems) course.\n", + "\n", + "Lets try to construct the matrix for QFT$_4$. Using the above formula, we find that\n", + "\n", + "$\\text{QFT}_4 = \\frac{1}{2} \n", + "\\begin{pmatrix}\n", + " 1 & 1 & 1 & 1 \\\\\n", + " 1 & i & -1 & -i \\\\\n", + " 1 & -1 & 1 & -1 \\\\\n", + " 1 & -i & -1 & i \\\\\n", + "\\end{pmatrix}\n", + "$\n", + "\n", + "To implement this matrix on a quantum computer, we'll need to figure out which combination of gates applied to which qubits will give us a unitary transformation that matches the matrix above. We already know one of the gates that will be needed: the Hadamard. Another gate we'll need is the controlled-phase gate, which applies a relative phase $\\alpha$ to the target qubit's state, as long as the control qubit is in the state $|1\\rangle$. In matrix form this looks like:\n", + "\n", + "$\\text{CP}_\\alpha = \n", + "\\begin{pmatrix}\n", + " 1 & 0 & 0 & 0 \\\\\n", + " 0 & 1 & 0 & 0 \\\\\n", + " 0 & 0 & 1 & 0 \\\\\n", + " 0 & 0 & 0 & e^{i\\alpha} \\\\\n", + "\\end{pmatrix}\n", + "$\n", + "\n", + "Since only the state $|11\\rangle$ is changed, it actually doesn't matter which qubit is considered the \"control\" and which is the \"target.\" The result will be the same either way.\n", + "\n", + "Finally, we'll need some SWAP gates too. A SWAP gate swaps the states of two qubits. It looks like:\n", + "\n", + "$\\text{SWAP}_\\alpha = \n", + "\\begin{pmatrix}\n", + " 1 & 0 & 0 & 0 \\\\\n", + " 0 & 0 & 1 & 0 \\\\\n", + " 0 & 1 & 0 & 0 \\\\\n", + " 0 & 0 & 0 & 1 \\\\\n", + "\\end{pmatrix}\n", + "$\n", + "\n", + "The procedure to construct a QFT$_{2^m}$ circuit on $m$ qubits is iterative — you first apply QFT$_{2^{m-1}}$ to qubits $1$ through $m-1$, then add some gates between qubit $0$ and the other $m-1$ qubits. But to apply QFT$_{2^{m-1}}$, you first need to apply QFT$_{2^{m-2}}$ to qubits 2 through m-1, then add some gates between qubit 1 and the remaining qubits $2$ through $m-1$. It's like a Russian nesting doll: each doll adds a factor of two in the dimension of the QFT circuit, with the smallest doll at the very center, being QFT$_2$, or the Hadamard gate. \n", + "\n", + "To put a doll inside the next biggest size doll, hence increasing the dimension of the QFT by a factor of two, you always follow the same procedure:\n", + "\n", + "1. First, apply QFT$_{2^{m-1}}$ to the bottom-most $m-1$ qubits. This is your \"smaller doll\" of the Russian nesting doll set that you will soon put inside the next-biggest doll.\n", + "2. Use the next qubit up as a control, and apply controlled phase gates to each of the bottom $m-1$ qubits, with phases to the standard basis states of each of the remaining $m-1$ qubits.\n", + "3. Perform a Hadamard on that same top-most qubit that was used as the control in the phase gates.\n", + "4. Use SWAP gates to permute the order of the qubits so that the least significant (top) bit becomes the most significant (bottom) bit, and all others shift to the up by one.\n", + "\n", + "\n", + "We've already been using the `QFTGate` function from the Qiskit circuit library, but now let's take a look inside of some of these QFT gates to verify the above procedure. We can do this with `decompose()`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6de41e8b-2900-4600-bd35-96df80b1b409", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAABuCAYAAACk2MjUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAEgElEQVR4nO3dz0vbdxzH8VfSssYf8VBdl4mu1dmw2poIisPDGDo9uOJp0EspPbijWJiYP6CXLtBT6cXjTpKeBjNXWRHZIBIEcVJBiGj1y/iiF611RL87bbA27TRav+98eT6Ofj/x8z48+X4S9Yshz/M8AT4L+z0AIBEijCBEmECIMIEQYQIhwgRChAmECBMIESYQIkwgRJhAiDCBEGECIcIEQoQJhAgTCBEmECJMIESYQIgwgRBhAiHCBEKECYQIEwgRJhAiTCBEmECIMIEQYQIhwgRChAmECBMIESYQIkwgRJhAiDCBEGHCRb8HCDLP86SDA7/HOJlLlxQKhc59W0L8kA4OVLxz3+8pTuTis5+kSOTc9+VohgmECBMIESYQIkwgRJhAiDCBEGECIcIEQoQJhAgTCBEmECJMIESYELgQXddVKpVSW1ubIpGImpub9eDBA+3t7WlkZEShUEhPnz71e0y8IVB/BrawsKChoSE5jqOamhq1t7drc3NTT5480erqqra3tyVJnZ2d/g56Qs/dPzX426/6sT2hHz7/ouSaj355pm+vfKqfv/zqnKc7G4G5I7quq+HhYTmOo/HxcW1tbSmfz8txHKXTaWWzWeVyOYVCISUSCb/HxRsCE+LY2Jg2NjY0Ojqqx48fKxqN/nstlUopmUyqWCzq2rVrqqur83FSlBKIEJeXl5XJZNTQ0KBHjx6VXNPV1SVJSiaT5zkajikQ7xGnpqZ0dHSku3fvqra2tuSaqqoqSZUd4qvDQ7mV9gzMMQUixJmZGUlSX1/fO9dsbGxIquwQH75Y0sMXS36P8UEEIsS1tTVJ0tWrV0teLxaLmpubk3S6ELu7u+U4zrHXV4XD+qOzt+z93vT9Z636rrG55LWh35+fyR7xeFz7R0dlvTYWi2l+fr6s1wYixL29PUnS/v5+yeuZTEau6yoajaqlpaXsfRzH0cuXL4+9vvrCBamz7O3e0lZbq28+/uTsvmEJm5ubenV4+EH3KCUQIcZiMe3s7Cifz6u39793oK2tLU1MTEiSEonEqZ7ZjcViJ1pfFa68z4KNjY2nuiOWKxAhDgwMaHl5Wel0WoODg4rH45KkXC6ne/fuyXVdSaf/QfZJjx3v9euKe655ZWVFIZ5rLk8qlVJ9fb3W19d18+ZNdXR06Pr16+rp6VFra6v6+/slVfYHlaALRIhNTU2anZ3V7du3FYlEVCgUdPnyZU1OTiqbzWplZUUSIVoWiKNZkm7cuKHp6em3vr67u6tCoaBwOKxbt275MBmOIzAhvsvS0pI8z1M8Hld1dbXf45Tl64Yr+mv4znvX/N916wJxNL/P4uKiJI5l6wgRJhAiTAj8e8R/fg8N2wJ/R0RlIESYQIgwgRBhAiHCBEKECYQIEwgRJhAiTCBEmECIMCHkeZ7n9xBBxT+FPD5ChAkczTCBEGECIcIEQoQJhAgTCBEmECJMIESYQIgwgRBhAiHCBEKECYQIEwgRJhAiTCBEmECIMIEQYQIhwgRChAmECBMIESYQIkwgRJhAiDDhb1+BCUFmootuAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc = QuantumCircuit(1)\n", + "qc.compose(QFTGate(1),inplace=True)\n", + "qc.decompose().draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "066a1c6b-864e-4cf3-b9f1-2751b9b00998", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc = QuantumCircuit(2)\n", + "qc.compose(QFTGate(2),inplace=True)\n", + "qc.decompose().draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "dffb70da-0107-4aeb-b433-20f4b82f6abf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc = QuantumCircuit(3)\n", + "qc.compose(QFTGate(3),inplace=True)\n", + "qc.decompose().draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b3375193-b230-4dda-a676-ae350c3a9b93", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc = QuantumCircuit(4)\n", + "qc.compose(QFTGate(4),inplace=True)\n", + "qc.decompose().draw('mpl')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0f29ce85-e9a8-4445-b3ac-5625bdca9c8a", + "metadata": {}, + "source": [ + "So, hopefully from the first four QFTs you can start to see how each one is nested inside the next largest one. You may have noticed, though, that some of the phase gates are not exactly as prescribed in the procedure we outlined above, and the SWAPs don't appear after each subroutine, but are rather only at the very end of the full QFT. This is just to save us unnecessary gates, which would cause the circuit to take longer and be more error-prone. Instead of implementing the SWAP after each nested doll, instead, the circuit keeps track of where each qubit state *should* be and adjusts the qubits to which it's applying the phase gates accordingly. Then, a final set of SWAPs at the end puts everything in its proper place.\n", + "\n", + "## Application of the QFT: Phase Estimation\n", + "\n", + "Let's see how the QFT can be used to solve a useful problem in quantum computing. Calculating the inverse quantum Fourier transform is a necessary step in an algorithm known as Quantum Phase Estimation (QPE), which is itself a subroutine in many other algorithms, including the \"crown jewel\" of quantum algorithms, Shor's factoring algorithm.\n", + "\n", + "The goal of QPE is to estimate the eigenvalues of a unitary operator. Unitary operators are ubiquitous in quantum computing, and often, finding the eigenvalues of their associated eigenvectors is a necessary step in a larger algorithm. Depending on the problem, an eigenvalue can represent an energy of a Hamiltonian in a simulation-type problem, can help us find prime factors of a number in Shor's algorithm, or can contain other essential information. QPE is one of the most important and widely used subroutines in quantum computing.\n", + "\n", + "So, what does this have to do with a quantum Fourier transform? Well, as you may recall, any eigenvalue $\\lambda$ of a unitary operator has a magnitude $|\\lambda| = 1$. So we can write each eigenvalue as a complex number with magnitude one:\n", + "\n", + "$\\lambda = e^{2\\pi i \\theta}$\n", + "\n", + "where $\\theta$ is a real number between 0 and 1. If you would like more information on unitary matrices, see John Watrous' [lesson on the subject](/learning/courses/basics-of-quantum-information/multiple-systems) in Basics of Quantum Information.\n", + "\n", + "Note that $\\lambda$ is *periodic* in $\\theta$. Already, this might suggest to you that a QFT could be involved, since we saw how useful QFTs are for analyzing periodic functions. Below, we'll walk through the algorithm and see precisely how the QFT comes into play.\n", + "\n", + "\n", + "### How QPE works:\n", + "\n", + "First, we'll start with the simplest QPE algorithm, which roughly estimates the phase to a single binary digit of precision. In other words, this algorithm can distinguish between $\\theta = 0 $ and $\\theta = 1/2$, but can't do better than that. Here's the circuit diagram:\n", + "\n", + "![Circuit diagram of the QPE algorithm for a single data qubit. A Hadamard is applied to the data qubit. Next, the algorithm uses another helper qubit, on which a controlled-U gate is applied, with the data qubit as the control. After another Hadamard on qubit 0, the qubits are measured.](/learning/images/modules/computer-science/qft/QPE1qubit.avif)\n", + "\n", + "So, the qubits are prepared in the state $|\\pi_0\\rangle = |\\psi\\rangle|0\\rangle$, where qubit $0$ is in the state $|0\\rangle$ and the remaining qubits are in the state $|\\psi\\rangle$, which is an eigenstate of $U$. After the first Hadamard, the qubit state becomes:\n", + "\n", + "$|\\pi_1\\rangle = \\frac{1}{\\sqrt{2}}|\\psi\\rangle (|0\\rangle + |1\\rangle)$\n", + "\n", + "The next gate is a \"controlled-$U$\" gate. This applies the unitary operation $U$ to the bottom qubits that are in the state $|\\psi\\rangle$ if qubit 0 is in the state $|1\\rangle$, but does nothing to $|\\psi\\rangle$ if qubit 0 is in the state $|0\\rangle$. This transforms the qubits to the state:\n", + "\n", + "\n", + "$|\\pi_2\\rangle = \\frac{1}{\\sqrt{2}}( |\\psi\\rangle|0\\rangle + e^{2\\pi i \\theta}|\\psi\\rangle|1\\rangle)$\n", + " $ = \\frac{1}{\\sqrt{2}}|\\psi\\rangle (|0\\rangle + e^{2\\pi i \\theta}|1\\rangle) $\n", + "\n", + "Something weird just happened: the controlled-$U$ gate only uses qubit $0$ as a control qubit, so one might think that this gate wouldn't change qubit 0's state at all. But somehow, it does! Even though the operation was applied to the lower qubits, the overall effect of the gate is to change the phase of qubit $0$. This is known as the \"phase kickback mechanism,\" and is used in many quantum algorithms, including Deutsch-Josza and Grover's algorithms. If you want to learn more about the phase-kickback mechanism, see John Watrous' lesson on [Quantum query algorithms](https://learning.quantum.ibm.com/course/fundamentals-of-quantum-algorithms/quantum-query-algorithms#further-remarks-on-the-phase-kickback) in Fundamentals of Quantum Algorithms.\n", + "\n", + "After the phase-kickback, we apply one more Hadamard to qubit $0$, which results in the state:\n", + "\n", + "$|\\pi_3\\rangle = |\\psi\\rangle ( \\frac{1+e^{2\\pi i \\theta}}{2} |0\\rangle + \\frac{1 - e^{2\\pi i \\theta}}{2}|1\\rangle) = |\\psi\\rangle ( \\cos(\\pi\\theta) |0\\rangle - i \\sin(\\pi\\theta)|1\\rangle)$\n", + "\n", + "So, when we measure qubit $0$ at the end, we will measure $|0\\rangle$ with 100% certainty if $\\theta = 0$ and we will measure $|1\\rangle$ with 100% certainty if $\\theta = \\frac{1}{2}$ (and if our quantum computer is perfect, with no noise). If $\\theta$ is something other than this, the final measurement is only probabilistic and only tells us so much.\n", + "\n", + "### QPE with more precision: more qubits\n", + "\n", + "We can extend this simple concept to a more complicated algorithm with arbitrary precision. If instead of just using qubit $0$ to measure the phase, we use $m$ qubits $0$ through $m-1$, then we will be able to estimate the phase with $m$ bits of precision. Let's see how this works:\n", + "\n", + "![Circuit diagram of the QPE algorithm for a multiple qubits. Hadamards are applied to the data qubits 0 through m-1. Then a series of controlled-U gates are applied to the m helper qubits. Finally, an inverse QFT is applied to the qubits and they are measured.](/learning/images/modules/computer-science/qft/QPE_withpi.avif)\n", + "\n", + "\n", + "\n", + "This more precise QPE circuit starts out the same as the single bit version: Hadamards are applied to the first $m$ qubits, and the remaining qubits are prepared in the state $|\\psi\\rangle$, creating the state: \n", + "\n", + "$$|\\pi_1\\rangle = \\frac{1}{2^{m/2}}|\\psi\\rangle(|0\\rangle+|1\\rangle)(|0\\rangle+|1\\rangle)...(|0\\rangle+|1\\rangle)$$\n", + "\n", + "Now, the controlled-unitaries are applied. Qubit $0$ is the control for the same unitary $U$ as before. But now, qubit $1$ is the control for the unitary $U^2$, which is just $U$ applied twice. So, the eigenvalue of $U^2$ is $e^{2*2\\pi i \\theta}$. In general each qubit $k$ from 0 through $m-1$ will be the control for the unitary $U^{2^k}$. That means each of these qubits will experience a phase kickback of $e^{2^k*2\\pi i \\theta}$. This results in the state:\n", + "\n", + "$$|\\pi_2\\rangle = |\\psi\\rangle \\otimes \\frac{1}{2^{m/2}} (|0\\rangle+e^{2^{m-1}2\\pi i \\theta}|1\\rangle)(|0\\rangle+e^{2^{m-2}2\\pi i \\theta}|1\\rangle)...(|0\\rangle+e^{2\\pi i \\theta}|1\\rangle)$$\n", + "\n", + "This can be rewritten as a sum over the computational basis states:\n", + "\n", + "$$|\\pi_2\\rangle = |\\psi\\rangle \\otimes \\frac{1}{2^{m/2}} \\sum_{k=0}^{2^{m}-1} e^{2\\pi i k \\theta} |k\\rangle $$\n", + "\n", + "Does the sum look familiar? It's a QFT! Recall the equation for a quantum Fourier transform:\n", + "\n", + "$$ \\text{QFT}_{2^m}| y \\rangle = \\frac{1}{\\sqrt{2^m}}\\sum_{x=0}^{2^m-1}\\omega_{2^m}^{y x} \\vert x \\rangle$$\n", + "\n", + "So, if the phase $ \\theta = y/2^m $ for some integer $y$ between $0$ and $2^m-1$, then taking the inverse QFT of this state will result in the state: \n", + "\n", + "$$|\\pi_3\\rangle = |\\psi\\rangle \\otimes |y\\rangle $$\n", + "\n", + "and from $|y\\rangle$, we can deduce $\\theta$.\n", + "\n", + "If $\\theta/2^m$ is *not* an integer multiple, however, then taking the inverse QFT will only *approximate* $\\theta$. How well it approximates $\\theta$ will be probabilistic, meaning we won't always get the best approximation, but it will be pretty close, and the more qubits $m$ you use, the better the approximation you will get. To learn about how to quantify this approximation of $\\theta$, check out John Watrous' lesson on [Phase estimation and factoring](learning/courses/fundamentals-of-quantum-algorithms/phase-estimation-and-factoring) in Fundamentals of Quantum Algorithms. \n", + "\n", + "\n", + "### Conclusion\n", + "\n", + "Hopefully this module gave you a sense for what a QFT is, how it's implemented on a quantum computer, and how useful it can be in solving problems. We gave you a taste for its usefulness when we saw how it can be used in quantum phase estimation to learn about the eigenvalues of a unitary matrix. \n" + ] + }, + { + "cell_type": "markdown", + "id": "33b2c0e7-b48a-4426-8472-ad9a52bf48ea", + "metadata": {}, + "source": [ + "### Critical Concepts\n", + "\n", + "- The Quantum Fourier Transform is the quantum analog to the Discrete Fourier Transform.\n", + "- The QFT is an example of a basis transformation.\n", + "- The Quantum Phase Estimation procedure relies on the phase kickback mechanism from the controlled-unitary operations, as well as an inverse QFT.\n", + "- QFT and QPE are both widely used subroutines in numerous quantum algorithms\n", + "\n", + "## Questions\n", + "\n", + "### True/False\n", + "\n", + "1. T/F The Quantum Fourier Transform is the quantum analogue of the classical discrete Fourier transform (DFT).\n", + "2. T/F QFT can be implemented using only Hadamard and CNOT gates.\n", + "3. T/F QFT is a key component of Shor’s algorithm.\n", + "4. T/F The output of Quantum Phase Estimation is a quantum state representing the eigenvector of the operator.\n", + "5. T/F QPE requires the use of the inverse Quantum Fourier Transform (QFT†).\n", + "6. T/F In QPE, if the phase $\\phi$ is exactly representable with $n$ bits, the algorithm gives the correct result with probability 1. \n", + "\n", + "### Short Answers\n", + "1. How many qubits are needed to perform a QFT on a system with $2^n$ data points?\n", + "2. Can the QFT be used on a state that is not a computational basis state? If so, what happens?\n", + "3. How does the number of control qubits used in QPE affect the resolution of the resulting phase estimate?\n", + "\n", + "\n", + "### Problems:\n", + "\n", + "1. Use matrix multiplication to verify that the steps in the QFT algorithm indeed result in the $\\text{QFT}_4$ matrix:\n", + " \n", + "$$\n", + "\\text{QFT}_4 = \\frac{1}{2} \n", + "\\begin{pmatrix}\n", + " 1 & 1 & 1 & 1 \\\\\n", + " 1 & i & -1 & -i \\\\\n", + " 1 & -1 & 1 & -1 \\\\\n", + " 1 & -i & -1 & i \\\\\n", + "\\end{pmatrix}\n", + "$$\n", + "\n", + "(You don't have to do this by hand!)\n", + "\n", + "\n", + "\n", + "### Challenge problems: \n", + "\n", + "1. Make a 4-qubit state that is an equal superposition of all odd computational bases: $|\\psi\\rangle = |0001\\rangle + |0011\\rangle + |0101\\rangle + |0111\\rangle +|1001\\rangle +|1011\\rangle +|1101\\rangle +|1111\\rangle$. Then perform a QFT on the state. What is the resulting state? Explain why your result makes sense, using your knowledge of Fourier transforms.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "313754e4-aaa4-4210-aae5-0079cb8ad9fb", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/public/learning/images/modules/computer-science/qft/Cchord.avif b/public/learning/images/modules/computer-science/qft/Cchord.avif new file mode 100644 index 0000000000000000000000000000000000000000..0a6dce8e47225033d57600ebc21f2775bf3d78bd GIT binary patch literal 46743 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

EK;KkmPxw(L0lFi+I1np8$|&9 z*@`qaF04{^XQVcz<41h zz(6X;M`*1{5A$BKyz_t$_OujT511r9KqPvb5z~lX24Zz_=oEHoa_QCI7SQ2=>SF{c z1EF&7&f|fd2fgjt;Ww@MO!@2Zq~(mm_a7byhx^RCd@ z%g@6`)+|e>KY)wrR=7Q(sykSBXcCAJR<-LS4zbzQP#o(qefgCToi(Oy(pxk zfKLf*u*w|l;w{v&xaVnC_svLs$JiS@c&PE%8kTy-sWTz9D#FP2f%t>@qv#OVyjzB9 zN`aQOdSU&JF*t>0H1>PPJVdW$z_lre-KWEZhG2l5nmTc z`r8`XwDKO__OwD=JX}2VQW&(fv=ZP3ATeD9r9bLmOOoEn*Vj{wn>!#NfGdEX%fs7| zn^#m+l$(c-n~#qZl;HFUa`&|k|G#?v_4psn+y82U>&pKR)&F$;ud0EMy|=uF8|c$l>OY15?f1W(e-tII_Ed@e Wrxd^Ie9eM|mco$W{%6pnF#aDDf1y?Y literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/Cnote.avif b/public/learning/images/modules/computer-science/qft/Cnote.avif new file mode 100644 index 0000000000000000000000000000000000000000..cacb56d813fe1193efb898182326b679627fd244 GIT binary patch literal 52437 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/Cnotefreq.avif b/public/learning/images/modules/computer-science/qft/Cnotefreq.avif new file mode 100644 index 0000000000000000000000000000000000000000..ff998dcddef4f9e2967d7b16621c9ed1ac7504b7 GIT binary patch literal 13614 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/QPE_withpi.avif b/public/learning/images/modules/computer-science/qft/QPE_withpi.avif new file mode 100644 index 0000000000000000000000000000000000000000..724ab572b5b0a78257e50d31757fd7056624ed6b GIT binary patch literal 9025 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 bPCECY`k#?F80LKz9A{0Wy42A<(?tFs0Ey2O literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/phi0.avif b/public/learning/images/modules/computer-science/qft/phi0.avif new file mode 100644 index 0000000000000000000000000000000000000000..df9d244824e2c085e83172e09450619fe23aa064 GIT binary patch literal 24784 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/phi1.avif b/public/learning/images/modules/computer-science/qft/phi1.avif new file mode 100644 index 0000000000000000000000000000000000000000..e22da1e6b4c6c591f9d8ddce09cf9d4294f3bfd3 GIT binary patch literal 25040 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/phi2.avif b/public/learning/images/modules/computer-science/qft/phi2.avif new file mode 100644 index 0000000000000000000000000000000000000000..0e96951b8feee272ae5836b6acc8a84affdc0879 GIT binary patch literal 26024 zcmb@sRa6|!8a6t^;O-XOEx5aTaCdiicL*8?PLSXl+!Nd_1Pks2cL^?M$R~TBea^*y z@%LKY_0&_ZS2tZn4*&oluyFHsGWM{x0DupBYYUcFY;SE0?xVHYo4Xmm^5BEi%FNE? zF9-lQS)023ga2ufovhvL|8#)htCqE$qv>l;To?cecx3=+>wmQXfHFS-;*~Ka_=f>- z0YHBk)qj~}u->c8?mrB$8{GA@ws!av>Yq_8aL4?QDX<4)4`!BEjsK9~k^d!uuYM%F z{z{kbZ*}0SF?(x!bAYjvlbyAxv75D{1CxuH1-+NO-K$AdKWir!CvdA_?PTf*CJ>E1 zSj2*15y22;%+%4&#mU7H92QE~s{sg9ur&ua7ZoW{5-n{V5}18(3NQdz05t%@*wocY zL`g~h)#^X(EB?=MJ^NR}({EpG{fGZQLTF~@uHdo*mB7*_X0E2-2>~_$0FYUxPA=dX zgMQ`7J>8sM@#_p?x_|=&)nJ^%m~(b(9<5&%G+0P`ds zrj}qE$Y)^8>|kc?0M4HTj0NrO9nHYl2#jgKGEQLpYMIV8`Otu1f?%;a;IjF!_L@O6*6>y6QuG_q=queV7Pcrbx!9+n3 zjM2gP)*77MUl;=3%3WF=jKT5{1g5TH;93H(!I;_1SX>T_3BXv=!A{|IzF&D03u{Rk zFh&JqFKag$H892n<4AK?3Dv)4a$Ou%{`LjYWZ@zv@;5(Z{MYmM>TA{AR{fQKwSQq{ zF7vm25VDVznkJZs2LM169@ZKPV2ljLjIOq-uknCm0P*`+iM{fFWL(@;UgM_#^D5>J zQlelCwh!{KaFKk?{Z&5N-W81gKAag5!kru`!la0%LGIkO=^JfEYj=Kmu?F zpC$lDfDOQU{HXZ|-1}=p5?~B)0ayae0dN0i{?X90kCQ-M0XXKcgOhG;9GoU=Q{HIe;Cw?+(W1V4Z)wX#jqK8S8)h|9CeB+cX8o zYX?4G$N&HNf7t&>ih%Q#|6AAnACDv`|L8+YK#N05LrX%_LgGUTLh?b%gRjEilNFL1 zlINd1{v!{y12qY?3H1|d9csbQI>hCFYV;1U4$kPW8k&Ra`(L$yqypRIfE0xk09yxJ zhQx-%2fT%32m29$6astZ0JCC$XZTu`e`e&rbNV*}z<*}rZ#g(-I0!f#IAJ)N|J6jM zL+1D=-#@kf?@Im^tI5Ch{wIR}umAsySOd(!amxKW8-GUtiUiez20`7RVNe^W89)N+ z1hs(1K<%&iZ~u~iX4mpxZz_M{u?5eI^}jOz8^N4J#=(@4frOQrl>_{q1;1ZjWdMLnlLdIN44Bpq2~#__zLtqu~a>o)G|mp;l9O7mvT}LB2Ln;J*?m;3o|aKm;HM(17z{ z1#klR0KxzXfGj`}pa#$e7=Z6rEAV~p0`LU*0fGS$fEYjmAO-LV@EK45CHy7v zHb6IE05A%e0Q>|jf$yGez#-raa1D3>0)a3O=Xn~m4mtweK|(`fK$1Yd1>eEakm``8kj{_+kg<@T zAWI>eAp0PvAvYk;AfKU-pa`Jop?INWptPVYp**1?pi-fVp&Ft3!Ozk*)HO6TG&VFf zG#B_;)P}Z!_Jxjx&W5gr?t-3#-h%!O0|SExLk}YWqX=UR;|3D}lL7MurW0lgW*g=f z76FzRmK9bKRtMGrHUu^mwj8ztb_#YE_5ltRjuMU+P7%%w&KoWst`P1k+z+^IxCeMN zcxre7cr|z%_+a>S_$v5*_+|J@1Ox;!1Rexs1Z#vKgmi=&gdv0tggZoZL^?zkj;<-ku#B-kf)GOP~cD~ zQAAJ-P<&8QQR-2Cpd6vXp;DoWp&FwGpk|`BqRyfIM#Dg3K~qGtM~g)(M;k`lLx(}9 zLYF`{Lk~kQK<`E0!T@2AV~AmxVuWH8V)SEdV?tw6W6EIKV8&opVvb{;VWDHOV`*S{ zVP#^qW36L@u&JaNpnx?J%R!X^?XvLQ+)>LA)D#vm3XwkA#{?j$}S!6FeMu_H+*=_5HKB_Ne1 zbtlau9VdMtqb5@)3n8l}TOo%h=O(uxPbTjnKcgU~ct_z!Q9-dt2}j9IX+@bvIY@a! zMNOqi^`5GkYL6P1T87$(x`KL{28l+9#+fFcW`-7;mYdd=Hk)>W4uXz@&WbLR?gu>t zJtw_2eK!3h0~7-fg9Af8!`xfMw<2#n-d4QbV8mvWXAEI%W;|h{VA5gw$TZ0G%*?@T z$6Uy~#DdNu%M!x!mF0q!j@6VklXZp-iA|C%kgbL7oSmNCoIQtqo&$s99mji)9*!qY zE>0KDD$ac_3N9nAEUr0jOl~FaSneSnC>~LsK%O?9J6=v+H{LqlQ@*!+wtVG$d;HY= z=KO{HTLNSP#sYZ)>w+YLMuNG5>q4YL#zOf*o5JM6X2Qk7yCSqAHX>g{PDGhST|^s2 zZ^U@T{KdM&LE=*4(c3`<)lAK&&d$Vn97vN zoXK*@`pfpoAh9`28Ymii8f6+cn&O&?n(JCjTK-z2 z+W6Ym+ATUTIvP5~I=^)#bW?P<^*Hn*^k(&`^}Y0m4e$-@4B8D*42=!zji8J)jmnK4 zjTMdajencSm}HrpnTnaFnI4)6nVWQG>(J*&zv|z<|5}( z>! z{et~A{6+lp0)PP~0X>1_fnkB$K~h1b!SKPh!QVreLlQ%-LN!Cbh7pDZg>8jPg;zu% zN4P}Hz2|%XITA9`I&wUUEh;1GIod3GB!)RAHRdtaGmg&~vFV|m> z+hIFMJE^)$7sh{Cp0Gwr^2UWXIf|5=Pu_j7qORk zmnB#1S3SR#ey?8JUq9SL-{Ret-f`az-fQ0PK6pODJf=UjmCh{WAu99pN^1_Y!-h-CZ1b?VZdm|6D|QO|4CxcwN0+-OTM>dBHN)cGku&-n_2>LzP7^k(1Ik+}|4rH*l-K)%>+9I2RxA@>J z|GW44&lYgqRVVDtjNQ-y@bLI_9#xm!KqTle*7AHHIshV?CQtaP6A5eB2da{O-jEA> z=*!w5{P|nt%cSp6TX8b$kVs0ZM9w>bwYeDnUo3-Rn+(=k7;GIuN))6*zq_FUf^zJ4 zwdXHpV%|gF8hcu4TB;3&L%xsWFlH77w7F%45nKeEkv~aamv^N8R&}^p{N7D=XabEm zDi%l?`Ze>#pj3$o_vWqIG)>$_D5U6(HRW_)uZ`1t(4f}Xx3Z6WlT==N6XEoYUtj!A znDpgf+1tZL-t~>9%w}R*lvlO!R$`_OJjaRKuu9TCbc+cl^7Git+x8xnzdU{s*p`8f zSSqU>4r8&pqFQ_rB?--k`Ovs%Tz|?JrbUq7axh#o)MK>v(FUlf{X|RYOE3~PjD%&Z z{5!;7Xs3Zweqc46@dG4gL@XM4h&W9EQ)!t>rEt{va()%-@Py;STVx^A(&6LBN}qu2 zQHK^&_+SpN$V_Lp>ST$i)25YYm}tTxl>^BoYYmIF<}Vbdal=d!j%7h!vnYGF#%ede z=R2Bpi^5z}7X;H6n=*bT3}0^T#9);Bvsw&MJsGTi5eRD<->_NxA)aT*6&g@MJ{c_P zGN3xcHK2RmtR`d4b$#R4ZXGMi^qWHge<7Z-9XIx%AmF1mq2$xu0P4A?Gjo89jhbbG z`Dk{q<+)GH%%eWALzp2vt>A7TKUS*}#>V5&?C!nMks1EYXiHh@>PhO<#ZoNVyUsNm zk>ipTzZM*t(>NISJbkq9Zga;H^(QJWy>}NpuEZi6R4fPb5o=subzn>$H2@HUGZbTT zK93(LwxOgQQJc&8O{>-IYIn*-zdgV;I}CY@0_kKlzg>Je98f@yg>P#8{9Ae}dTgG< zEdan(KGm16bGu@Ij}e%@B&MXRj+J?(vxMoeAJir?crq#Jzm!|Cs{onzb#xx;i+ut= zi@Y%w;26uW^T~?VBu)qZQ%I}KA_DgO9*Q`o2S@d$c7pcOnq!q7U$`oZeB&lIi}FU? z0fwxp>Pd2MA6|OS2R8@4Ps6xHTJDI{yWjM3`;Qr+v)L^1y~Kb;jQ%LBxZzf2*K?4{ z@&e{X{4ABgi2dSLz@j%CBiwB`kB=dyIic?%#3*V*LR!Dw9upL;kR4p$cn=!y(6$<2=OCGQogyKo%5q~HEx-5}p#eG`))ym=tF>}$)r zxbI5E)*Z}ILoh&JA}tp@&3Y4VP?^=5oUmd``pw0NI`sa|Qw&!Voq_Xy{{BUJQW zh{AZqJZxFL%a&KuSI0iI4hBV=nz#@$ zDB^!uBY@f=F_Dn(cLX(JTb*3z;w5;Q~1|?BceWqAA;uE&;b9Gh|ISVprzv zX~wnJv0}B0!jWpxuF-J3rO<~fdYsG7T0_(2$4pprUAZUYuZm@7lvKYF9~a39z5Q>+ zdg;%q(_vI0Rbg}QXS(P-YvK(I>aws|FDAB6!?&AHQQ8|Xcw56xgcna1w78N!mYe3-_KDQiv(h&u(~XvNXU7b4|1`Zj z097V$$|R&*=%U>?RIUIoh1?o~y(CM(Z$@%4i6y&g_&H0^&uEvl1{J;p(Sz-#_!lasvp-151xC)I+A^qZ?gy+pC5TP+EM3AoNBqN~ z09?1n&9Qt~oD~L>kA<{4lyc-&{mrR;Iix+U%J_yh8D1gAV^GF!BOJF(pYiU+wfaUN zv9m~MYN|>O&z%oQAz7idn-!1}!eSEqEwa{2&mL3cT=;Qam6Wv9X!-tbxc+OQ3C?mS z-9+C#mICMePERXY-OWh~Hybhkq4c1jRs~h#k!f6iogl-^kT}UXHaTK4lOMFNr-)dn z!;WZ9V8d_HOdy43Z{GRPT>7@ad5=m42pYfv(frWSzRbQ?%DX6*Xm*V~>ztB}(}=q+ICs${D+x)7XPfL^6#$~9_m@3M>y!Qf z?fI~McmZju05xJ`*|lIxe5sfJ;o_Zj7B)!?yrMj9p)};(c||XA=nYIe?g<=Op;MZa z?b!?L8wcHs1}-RCrFYHr0g64lfPN72xSNcbR;QvAk4l*{Yf!Y7r;w?AjHdG0V>jc- z`~KgXW4*Mnyo_$15r0O{^!O1H=nx{~;E3xWo zzR!U?LX?Totx%?IsYb;QvO#1mG3IZweiTNs7+R{wF(DIZ%(@jn`pq7I$_^TT zcxiC^Q{g{ne8P)o?d9GwY*gu6hb=#-2;1%xS0-EkND6#e)OHeIP7QL9X_euSo^R@r z&K1?hqGDuSU?AS!{hBmUp--UJUVkFlYI<$^c9b%ZOq=zgFLj=>7|~vL$F9*bm)2|b z)F3*jPxJ!ERr^X%=J?Fmd`Ik3VZ*>i-?5)i%;@IVwGZY+VcYKyXC;e{8JL=l9%R)e z-*WAIKKngZK)zQGfMOM5q^Fyp<2VcH`h1=pKS&6IwkHplTBOX?&QR$X$)Aq!9gRuA z^zK8{(#Dfp%#|D)Gv{NIbzj0BSHy0!zBl(pz|%ubro?C=jZ=j=dbr#QKq;4d-#e<7 zs7+>`>5WPp+LYLdZX1m7V&a7vvP!+dE|x#+Gg>H{D8(+DyDCoi>M^3PIGa46YQpd6z@4!pQ>?UD?6 zl|YTfD-qaFt;g ziaVLR;BYgtdqBYP^nI&z)7_!U2X;);^7Z3sh9vV%S{;-B93i4~WG3WA{SVNVAKgtX?H0APC7`*7iQ>S*R_$ z-+Q83jVMC83iVQIcax?a@4=p!g{#i72p)(L`&0I=+OlWkQROTLxWi`Xw%l=88& zMM&>nuYPp#d8lrq1Ljr^|E_y!`F@~0d zME4D8at)6jrI%}N<+4xcP67qb7((<6ShEXPOA!3&CUS4TrrNVKKvi}X@)gIGPXzY9 z7n^DnMDDPopxzgnKB$aIu3|^Q8WFGC)^xZuu`Y=@QSKjiK?UkyGIZVu%PNcHIAYSG znl~9DOF&*z=w$cO7GleJJ3Q#O1oZ7q@1bV&IP2yj0D_;@E}WPsO1_b93fNN!{Y;&F z$3D(CrA>cjNenl=06XjW-CqqQ&a3lm;X&U2>vt#N9%1Kp$XS!f>*8z~m@}0S!UI_3 zIG#@lIAie@aOlp`mY%9J%w!#0b5Bg{WenA)Rm2(@=Eo|1Bm$nu^~UX|^w@pDKHQj= zvo-F&;%ZuY*nMl?>miDhUzW)b-c7l|LxRo-;Yr~+?C17SJN;7OwM?WPgcQO_&u8AR zo}j*Ii+g;lakG_qr{ISsCanibcONqBVH_U2|7DCmtyH!zm0SpO1w&-E&vE?{iL5j% zFvD=Ha>xb5&=-1{gvm}k{>14h#v)t1i62@KN6L@qazyGM-B@B6K90&NgI8(jwwNO| zMuki~0PIkxdfrK=2My8?sXKD(%R|0}M+EjtRogZOKV{Z*FEXhYkDQEwT=VolG<LnU6!lWL# zTABle1d^J8t--ap&LC}B+&I;n?BM2`D79mbU)XQf15M#%Vp8rO!=cL`nHz(FnPDbs zvJO>VtwR-k@AnQLy6ZKlU3%tqq?Kiq{iN+=Vnu{^B%RvDAzc|tSjS>v+m7>fWPrq2 zj(xb>y+X;{VTg*JVMWr+o3Z!xV#yTqt&EXZ#W%V%xshW?x?|b)CL6=2-@d?RdVu7g z==6Qhklsl%kmroCCGY)oxV!k|YKM;M3l-(G#ZdYUR706tD6Ecqna~J{R{IOz*5o!; zW}cGXb`Qx|!@~kIi|_4TWeOSAfWVIc)smOs-xhLISPdU7y1^oFM`~cgg6*BYY?t8soApm_Z}JW4f~|@ujLAK3>0+1O=uD zr(Om$r#IIbvT#*r#hLUgjSOduf0Nkpr*su%IKzmxx>S3^|?I$|PQL*CO0)%qM1 z{$U8Tvb*HcU4e@!5>{*SN>{lma7dp3ax(@l?h*7@Ejfg8iQMlvm#CYC;?eRQ^ZiQV$3@Vi?7RG zGFd6p>~7WYhvrOmqxg1&Df9JdLLfiCjfmvETsj*Mv9g|D^i=yYY%)PJqM)h_#-3ut zsHmX+STCyEG^*SgWKq(c*b$xa2T+N8+`2fzM=C$h0js=kL|uhcmjx>U`?5`D6C!~%uKT7YCR(HG9fjpda?Z_=!nARqaK{X?SB*FpX(H&6-@e#_5yn~L;8SDMZHNm^CoOIa|ZGN3SW9AZtXsG7dN_K8*jkEe;{FX)Z zmQn)`<9?F1q#2QW8;|c#eMM3EGOn<>{wj;`stt;w#biny{p+Vnoc*UEIg#ULtr5v* z@5Dud2w6yWa9T_6X@3stM=1-mXOVtP6~ARKv*hhRg-vOFJh)IbncVaQ*_qEb2pItcp22^*vr(?upa~M zMk*3Wu#zE*e?;ACim=cXjpeOxH-%4R2jW@R|I{(y9K@jZ7xfsWvpr+xgY~6v`<*d| zYVqT)MMhX4C0s^5PRG1!@RleTCJvsjzE93|ON&{uHw8^9ZFit#YFBY76pqICj;`y7 zP4nR%Z?#==io`4-!(oreg%dd+_PJ3Q5b4c5FAX9W_7rKtmKzy}6s&j>mK=j%Qj?&7 z(MO&3pIex(pT{MVx=0qN7;{!gZN@gq@1OSYw|Sz*|_kn6vCtMu{_5syAc~QH>ge5sec<|vlx*? z_g#FQFLPbD>I*i?(FxpQ;I}YIR9Y3sZZ3sry01|!DIzZn{(-*r@L60RZ_yCSNXM3F zKO+%%X*?c{M)uvJU3&+v zdCe42u8H1AnKm`(+xdJ^BX*Tb35-Iia!@!1T2K(yG7$0P|ET!$a=7b#(lUvm#L7&U6uscMcc^muom-GwGTj(}}s z5xERar1Hiia<^p8fPpe(4Utx8!J&bD*j5E5JS20@Bi|ondlGa%R8{WWT6o|K6Y^QC zpQ!zt7hM03lgjGk1>a!rPY{-7Ctvxl#=~2GUb9=_sK0xc{9P)A*N%Sm=}cxN+K~PO zHZMK*%V|NM|CtvaMm62+8y)yG7U&k3Nalf2t}Tlz`6vDGAF)!)$2fDA09bBCPq#(G zWZL`XJAsb%W4|D4TfS-+*Ge`a`3;nrh=?D|i2Zpsxi9-is=K_CWL%T)9`ctlf+D3I z6-`;%kzo|?-^<_2|(NDjbVd&DJVJngoAyO&O1$|#KDBS%pU?BRDr4!L))iy{^ z+mYSFvtSdo!kRPZ4v~@;9>stB;v;!KX>GYN26K3&TVRsu5?Qf=`(kNavR2*4DE>h1 z479&E_`Sj5IP+H`<7*MfkNLQ437bi?VMq3_g{2woCD zdyY1OUn#UOb7fA1{2Uvn;y3%jl6_j9<7#7|LC`Rsnx`a)cM`c9Ht>cb3>9`>_Gt45 zi(S!k{cy0NQ2Vf_gE7n0WG%O5DU)*YSzO>6_P}>sSI74oZEQz{*&}2|Z>kw?@Y~l{ zzZAg6m=NO;k2*Mc>Gv$#d#pi4yZpwp@$hK7hC@w{Fu;GfFO&1xkGlwTaOgRQG^kTDhQW(Txi6*Bp&p^@MzBn7+3vB|>Dh@h*b zANpaTBpt@{0N68Z)tsH=CuiGr-%3x5L#GFqb+G%3H$_R!FPWR-0gB3nAM94W{kW7a#$eCqn*d+dW z`FN4_<$m>D`RR%{;aUIDp}7r42DuSip)w5>xbRx@P!TJ4nBJEZqXmp zgA4gW*QlAjUd`9ot`62E)dkhx&TNX=M1ld|taUnR_r*3j**?Q(EAp!75+I)*mdBVx z*eECU(ny`-oOG#|tUpzS-fz(-Kt#573rMF#jnnNMB}G6F_~+s`D9X8)*j2zN(=^_k z7R{tne$qKLt&{E>f2?`$y@-~8AzB2Q3xMAvU4;}>!kDuXG%ZoVqy&@SzU==GniWvKf=SKL{Eh60f*%*ska9x;|#iX`Hb4X#zqjQJJG@ij4x<)V{>Q;{4t$4KI|qzOBA{- zwp3?Q$!#XMs^&S;bb=rRW@kU{ZDc-ag&S*^Svmdw@^ba)DyA7bz!K!37NKN|oWz1f zz$xlSK3^FcLx&!$w-q}CopV8yNkrJ};E~5NI%d>+?GL%!;S%maa{T_bL^V{#5LG=s zCo$r~Hw7CQ80R^OhN7T^vI!_Y_S7HVGTC(Ey0EIOG!g1jhn9p^(roXv_=`;;g)|yt zP@_Js5d=Pe$cwXhgntkbm?01q5LF;{Uy;s0&3od}>znc?$?!NeRm5kh&xmQfut(w4 zh+L92O|(CXc%+@3&231VNp93FQL6Pbz2{F>CB6IFS5Nt=;w`nNbnz|R%bLzdq!7ys z0LQ^$QbWO&$9I>NtjlR^nR~dDI=V&PSg~x_L&~l-KELoH>(yk5xhr*7Hmk9zD{PwY z7#=H*8DCh#8e*|o&zDz(+B|m-m++n18aon^GvTeX?0|aQir!DKvotY$F08+AKw*vO z78+H>#S6hTNC^TDpOE`d^|0ZgJ%r3vy-cOqYqeWaDM-9GKD%Qz`9j2);$(GE&3lDe z+QKT=6l4fEpzh#tN$Fn7?5g)sW_RQ$Wz07Sd8kG3tI|-ItFO$RR>$=Uex6cD*bC0e zOfctH48^ewdHUE?mBDXn2-^qS9`feKAkeU8bt zSrelf9m0lEsM-C}i0d}Oba7J@Sj~wa%ed+yuFV1sqQX5X^2O3ENyLnp^uqS@3MTz& zY|S*)tiazg9@oU zTKy{#@$Os4y5)u5!r>^{TYHQ-xDE3!R(tvhO?gP^?BRZz>7X8&_a48h8UB{)$-JiS zW699{M!2|97%j4i>L(o5nBs>xlI0Dy`JH#qwI|`tFhRP&miFkPOx5L+y&V}O+`J7_ zgfCTAX*yi04+H*+IcZ3e${1O6Ug4i|YDy%UD^H6j74vczzIA*~cmq{KPd7^iGH!f^ z7Gj|jC~nsz;GL|gP=uyU=P!M1h&Bnc1OM6>u_}q5<10)R7go7M5YUmFOhxsoI=yROnjzdE+ujY`Z8IQGdC1zla33Or z>oYxsN7m=4@|iISv`lY3B#q5WxegO@mkde4-$6J7WoUCzJfNuUOiut-_%MueshMdRI7IB#g`x72AK=J_037&@yrx$oUK`9J0x|>hvDUPbR>DM z!^a{?MWpIg-;K=Ne4vaxbe9{a9m*#dDu^?x=rywDm*k+wzO;k(E zYB7kYoaU3Fps0qo4hV0m-;-+V9ttVBuWr=8MEid6Ss+j)wqEw`vlMm7A=FbmR`$>Q zl5g*s|l!8fIy z8CYL92b?F?5M7IuFfo%CiwKwn9b%a^?(p`Vcn@V~bb*}+i{or@hSNS{$4m;`)n}`; z?k@Ync`yl1_Sbs0@T86pbm2tLR)X*8luj4aWVY*bLd_5N>vp2U0|UNKx{}{A1&M4; zK`jN%&ZBeX<@HqTju;_oBL2F{pTKyO6LYhxlO~5P7Wd49_e3|<8;^VUo=>~Q``Md( z=DLziBqih%#>laV9$b|6l)!b*tVv=SwXUP~aJj`MqUWzT%-QXE+Iu$EEoJ54nhjnm ztFk9`slHIVCSk`yfd7d7QRfT`&Q0r}3&}>o$ghAOav3OY`J7R@(D(Y}dX+X7u_yx| zUk++dKBBC-wu^(IQp@ixjw;h>8b{hx@DQ15Y1${cxZyU`tTPC#8g1@5q>o8&NJpiA z1riUA{rozeHt|^{@5%f&|2YG)ZDYxp*zIz~{bGU}042H&pq zeN6~csq$Jg6RTk}PcqQaxw z0|9&8Fj>ZS*^`H9I3X9#ja9=X@pzIY&-8k#&?WE1Nl1Quf zvDMrL9C=%UlnPnxhzw8DnPmy>PmK1S>nZE5Lo(A~3uF~HGaY`sN5}4*n>>#X#P1OUO7c6bh09?~EUl^7 z7;|)UI9(xsl+e$`_!-2;>C<@gB|G^Bt6>-eMHSs>7DMlYBF7sRLKnldkwej&-cgh_ zSvu{bH`~Tstpcl)vYNB)eyK2vn7qK=1gcJ6~;{OCrO zQ?Uqvg_jPC2YUq*BJa?dINLnZymv;5hwHnn0G(Y|4(A!3D{&CRJPgz4@c4qUpDB3` zJ|6PtBL7Ua5+Py6Ln=&u8!f%Z65X&xZ1v5F%EKKJ?ft?EOC1ees4Sg>SKYhRvN)V* zQM-QoE4BhOHAa}OI~*2C=G&IDwFti{e)L&`ESwLQYaUfO`hhm^dqf7~+>UDNMD<(@ zzqpVVxdgC^!q4ub9Ex(E~|KkJ!lOI2`$!7@4<#jZ0o$FS&fj2Yr`dd z*FO5d9IxP@&d8igElOgX#-mXdXwoQcl9tVFxcw!$=gtDQH zxsy;uhv7VolbI*;`-6{dtC|1YSG>c^3rMxr6 zy4vQpbtU7vj{NZ&%J~ghA+@-UrW)1@|HNC z1`&TQ|H3rx=criBJ%<^#nN!H?s6J4o`w8tA;dDr!*u8WGFca?gc34(SQ9$u6NsYxf zI~w0loW?exq--P#8r`|gYq_LF3Rj|4&7yChKQsB9t%en|_mh^Ax=k9@O}UsDscMxC zX)N$LBQkldwN@!n&Hn&_T8XfP7g?#==y+ZdCmHA@GsZpoOdOJOQft?EN6`O0I>sXsK2EvY;6*9Nm4_PB8YCL3vx~&FKbFDv6hmw%>U1qZIfjdf({fxYyr&?kzkgJf!+5w49f8QTbG^8LK#4=ZLmZC~5B-Jd^YoWb!;@AeY`c@e7lVnq ztB&5!mWt>vp2;Mrm?|GIuAtOflem0*J=B)M>Fca3OfyS(tQ04AH~L&U{Wi3?m?I<| z5_W_LWz-Ex3&PZ$-BsvB<8%>a>2zck*vm!tKb=+FSR0q%d-Uy`}h6%OlDlfNAMU9^^>TM+9mhn&o9l+u4hx%lp(z5k+aEE>Zd(Q{*NTjDUmVzC8wIV zyBr_xPzznj9xjujrsjrwqJqTvklbo(;nSav-}zoy8?`BcLWL0!+EmR`kdn_~+{8dtYZJ$3dXgUyOAtryA0_!oOHuLS~7kWPW1sUpABilu+tgBq=_p z{o;t#7}NJ=^09g1BWPjwbu^QV{3Q8;U5=T2{af*6Az7s8CJ%4lJ6Rqbeq}yQlL)It}1Xxb99srN0?6s`vBhSQ$+Ad$+EpK3po-iq&Ix@!U1223eX$ zt>hFvh&P{cKrrqe_+3rx(LUBP0M_Ilk%7bhyenTl64@Oq11R&sTYd$vaa^RM?Gb`L zN<&XbhAF3=Cj0CMtZxyYl;+YAzpk3~6i-4A1>9`gm!d@QzO| zU=@Xg-S3HErDG$V=?P&F-g=%Q_)Y4_?+PEo@dNb@lv^eVuiu$Lll^?RoU2J$!UE*@ zz$W~=A@5#e&_cnf z)iZu~oU+X5?5Qqx%=l0BVeC|k3Pezkdp~Q%);>z9F)-5RdPdYSpg%(QE)6C%zmpVGm92-MU)tvE2zQ zjy;#sE>k{p2R4tw>bt2N;*N?${9N1O6+_<}V4hpO%GKmY_1t#4S>I>H9^;bx_BCsF zO>)8k=}n@qQ-}m!#v#&gYJXj%s=&JU@H)4;qGI1crs7PRr?zp3s&~c9Msl8f<^X2@ z+G#G>8vb3{6bhf+sk$G&03QU|+*5qW5G?F}oF9g&*s7qh(G!Wkwn|KKTOg86bG`|dsU?Cv3|_eqaLFEeLw z#yJIN3(S=|@~O3*oK|TJgg?0hoCb$1GW<9C;9BfSykZ~ompyI`&=gOJ9Ip*Gd`@&g z60$35#`m0kLyvdVro=-iem+!*=}Vd?7$|Et^}^)?RLL^}*sp=4!J{{3MRU)*Lx8Mt$zbs@flF)K#1wT#@_9yZ8uKbr4cQKSd$x z-#ZCURmG<8&QrGBuLj2&S<~I)!*mR4#M{XKKV^MoR9(%oEp9guXl)uYzmRdbdHytL{gr4Wh|<`A?x zEmZa82^0oN7tI3hJ7;+G9aufNu*RgUnEm+jlJ-xe)+%_ittjoE=~p3E$&PL%Em7k8 z(t4TV;19V#E$3tyt4a7W=Hn;`_+4{xW*Ad8q|7wk6T+vTjZh#m$YDH|l)Ha1LA2X9 zttSVi?-%eSZ+cqA*C!f?bP>)S>LbuUrB?Ow0xvhqh5j@n@ zth&R=U7fx(?);jPk`i7>-XT_3&+1K;4BsU64Jj(wN0M5y8r3hI2TO7HaC?>0Nc$8!hv;R7N6Kza89-?%y`;D5v@)1V3= z4sBkLYmP&Rt(xq)eP~%^Z1C%2=Z9IN@x3V@o{5?~qJYh3a`lnQGNM*O)hXiHD*(5c z+CPVk)T!C@`Nt4{bkQ-yj&ba@{c5Jc<5)DvzDMkPOs*g)CEwHwFBaL{h<;#x!9Uxs z0*LhVv{$R?L?0*clsZWKBvJ=!-W36FNIsG4Xo^4FFlw~g@A3TTGTmjz$yZUNw@jPw zZB4Ki1T{8fj@Qmb;UZX9&4Lid<&+bi5r>nv8}#adZ1z`%^Ax$<_fcVVtgDdL4n! zn*>LI#yLX|Vj=|#J3q2RTNm?oZED`e!2a$rk5dUZ-_GDpMLYh;0-^Z3tz~nCJ(@YB zuI{{D{k+@f6}9nmaf7js`XE<>6zz(GLd~Z_8=7AnvTV( z$wsNO>Z}53&on5twAhP2zNmjv)Mf1Z0bqJjIiq42H}it@4ho!$91}P{wR|BQJBBVg z?Y8vb$8$Tl8!t1s0t{i4;4+$g&zK^cjzrU*KKQfC9aQdimZ~sT+~Wk*4pD%F+JX)u z=%c6kCIq=#GZ*cSYW~DyWgCL_GjciU!@RQKeNBIg#wf|B>`@F_spXV2i&^We7iigM zbZJ0KxIz*r!5!LQh03%bbAW_6hAl)&$}RBoF9Kf6nsdI+6oQ3b>QsVLyCJHo383SA zZl6O7p4#;9zH|4JLHw+TZy%UT?tC^D+6hq3DU9O)P1}dzfMHQHiqCZU9R;CZX^T$S z4zq*jr;MGdHoAjZQdGAHd^cv1cX)}cK;O)>5E~z9#O*?ny8Zdo%7!0Fyk>#M;+2Vu zmO|M99bRwWV}s$`#Ag+qk9`oW^8Qt-=aVej?S((UhB$=}UIX17%<~ zUaRxlP^Dj2I1j)fY>no6h=m7NZmoM%Ni?+nQ)NkwKKv|zhVJm(SoHbr!Zap{un$qm z2V3jqfVVQhQRgJCG`^y*^H@caZM~4){oD*{cv{$c9|>Nx`D(a>a|xXRw27r82p2f-6;L|^n{J?!#=yIU`NJ;YjRFqc&{h3Fy)v_qA~gToW0k;h2%}Ytj6F zwA4dyAhIr-beFpD=$2s*Wk@Q|o=G8N)wpR@_vR1j>ZSO(j+##|>1nmnoK=uYDmciv zZMAWcE;@Y$t5LdUII(*MKrVay_#V>kyzM3ubX2d)DH@oi6^<@WE6x~KyO0H2?|NVnGrSWLVo zrS1o*Eb_%fvT;gWM~(;d`+pN7+oFP*RMAcJ)o%3@15aAW%S&ubOaHy5bIZbDz@H6w>&P;#Fi=z$T za1W31B_z{S*e+F06%j$Q;n8L{^evPYj6co(;4&ieWqbdc(TVj?UT%1=h|3rBhEJJS zIce}Q_12p_KfukOmqchM5J;D(_!n%^2*rVd!{09LbEcn zzr&_m>{#XLh9LA0u6oGY)U>vCQb5D}DmNeKWW`krPiN$IXQ~wL`y;(;x0&QTwpPiU z*%q1wh3s>LNJFkXdt2!pi7Jtdxp3hlm+02<{74+=VSpV$)ID>0Hw?;jk5&g&eUK6j zd4Y;PqrUJr`cQMz9+c4yvSy|U`GhhqfiqBR%B#f@9gAu1R4FDa)%zPOynS(OHFoN) zT_8erG4;WwILg?;ZS~sRR+d-5rGSY;!U)Z&Ek2BQ8Fv^_oi!Y4wJZx19KU*3no||; z>}_E}B34?Lw*4H11XPOr=B5oP1ME~x)JI1dm%Dbmf#0YV1ZP(306%n(*H4rdiPg_2 z6`K)oOL^Fm3nW!ULvVo(C1Q}#k%EI(HDs#zc;S(fn4(;UGJrLAma>%Iuar)h!1_D4 zJKJWCg7tzef4=3Fy(tl9NJQB6y;l>#c4M*;b!_|a92-H16#Q0a)&#FweHc4Rd1%di zPA)HyrgjfH9>FL{UJ^S%*|b1>R*=R1f_;2v#89CTk7&&MZLNi&`KGn=s$@db^+!ZU zf0%RUoXep)SYE~X9&Kipv1%-*+c>zL_ymYsS3UxyG{nPDe3)<+gEHdFVPZ;F4F{K- zUif5Yb;>bZ_8>5(Nw$rutcN6m?JNsn8(EKzv+k?dL$`l_$`(L%Zc|l%nJkp04Aax7 zvu(UsFtEz`fJiVNo6M>?mb~cG-SktfvqT0ghx)WCu)ogCv=`(cdC;>T4BL6^SE%D5 zU3qOMIHiNG`R6x7gyS-GiS(nEcxxrwP^A^}Yx#mUHYxlcl_f}|Y-{AeGUIcFnIKHS zswLLI=*OfWF%-2SI!zj13I8HCGBG5r$JUs{VZj|U))S)6vF@PuUC`$`BBg@)S{cj} zvEZW~g83igM&T7eX7A=9Xe7JPYkMGG(sDq^*uo}O1oH-TZEC~^x;?OiZy7XyeotmB@Cv%=*M)iX z2a3b!-P9!WP7_(Sw9T_H(9#)X)CE->_@n(9jHW8{!!i_%bhXdfg{hEOG6{NK(@)fH zv363wbt$2td@At0D}!uVrL|s+-pqH09R^zFL-^1pis<=88BV&*VeD)kk20y2^Z3J= zYNMU2+(FZ(1zd5qTpBV_4#f;V42Ccb*&PQjNY9a|_Y3?aXI%BWud3s1f*w*Txh7&8 zJk{y~U-Mr-;_-gzC`{tRG*r=MF*ea^iCaJ8GR&S?9H7>$`tg#w@kb0yI@`KNAz~0@ z5IG!bzKPS;6cvP?<8o~icRq#(;i^bz z&O1UKhMB+rEvUsUBWguE;{xP{A`2KVmMyQ7)QwsvaewVJF?678G&9l;7%Fhh#UYRh zT)jCdAE^R~M~r_N82y^2`3f1e?EhBBx3MC0djQcfXm-z8XF_tHu-uf-%U?Rr8X2+M zlzM_St$w&3E>xa?zBJcG@_hq0KqI$|`4*p_JF>74u_UoN?MWJe#g3@2(?uN(UfcIpvByW&uENCG+@3yQ^qpL& zUsjoYrcpR73!#2W9FOPrcH?`Z7Lxs?K~I8Fj;f{^LsD~PqfRhbi?!=HcxNd~Kc?V( zOtch1#Ovf>1>${H!lIO<_zOv|edT#z@@QJsH(N?c$WWm_&-}X-HccB!@3Zm4tcwGm zY30JMM%)FKnv@ZtU4L+Np+${vS)rV7AwO#TykImA3FARccK{DGS{1gQGk{};7A@S> z`400gliVIa>_Dwd*<(G5|?DrS1Mf8il$GlV0w0OQ7eu{UlKnE|&Ws2e<7N%Ct zxGjKRZH|Du6}@5ZopO~Cl89f9v!pY=535Wr7Rkv>heARktly+3rZ-;a8@&4d8jXd7 zY~a1=Lf?oKYQb;{)?{zyOahdn(`XVfwL=4X3D;u{8B$AVrmH}olg@bx2w89q< z*iqBP-1ZG{j9M&S;`5IIe|`atFe%n%9~e#a;Fl@^(n8Mq9ahlbq4x4^LQCu_7zOS% zkzm0vvKLY2Zu7&85vd@k>p`zMsS4Vur_MREl+!D=n^hA(eHR7)Qlkc z3CKR#pvvQ|AU6jFDTLfVpcG<6%l&cpy2b^LNyrL-!|Gqm?fxpfNVOH`}oU7>O#u62|dzS`&?tNeiCJ{3{gOBPS^NcIG35lyvX$7o}U(V@{T~+4&(7yF#?MPlt zp7wC+mbe)xt{BU|f~uz0XYj`=G+bA3qHb0f9c`a@C!uDtH-8!}YB|kFdaSe2H1Y`6 zHb4ts_GZqxbapB|A=5iddI^<_xWbi@IFC$j6aDG2bfa zpWSk9=5CS7A~N4N5F%m8zp;n!GT)7O6zDh=pxGOf*P+>h1?y6j*OWjz!hu2D(d8ps zK{yhe4tj->2#*B%f2O){pDj2D0K!)J^RmwCUGy2wUwLE(x2PI7Yv)q>CM-X|kw|T$ zVryJb!5AXdfcI3+hzNMw0)H*)CK4VSIlPdVLDQ?v+^9pj$x^U{sTJi^I>xolzb1gO zbkU8&)*Ymjky{+q=;yGsN4+#CzM2m#l}50vaZ5`WKAWRjd~&B@>tD`6p<}|rE*;i} zsxvLb=c^V1S^MtX?J6vkp(Y;k4-ZwCVd{bIXS11ywNBD{7+@$Z!V*)d(_B-#(t8Ql_9dk*Ddwi?B7i{-^K@z> ztHeQ=v<`_#&I%${=a&!9{aH<(3H$!bW_s8RZlSUT#jp9ZfWR+4tO!ymyCv9|)Y^AU z#8s)CRRvOTTDKQSdz{#<6X7v=GhEOXtEUwnph7z+~UO`zqF)$d7cUlYXk&1`lB zbE}x5l{55r;Ou@9YQpsqqAVGePncJ-o`}l{wer!a?|2+$5!~U<$3rL2<5EntcBp~{ zW#||Sn61w&s$exZFn*v=hH_e)JATSX)2=Juqrju#=+=$3_U0$tcAvYcGpd>waL{h> zF|f;oMX^1SkTZqJh|f-0Xqa6G z^tKy$%#FtcYd1Vv`i)<4$XNaS9E=$|wgYRW#!O-yHURJJvnw^&(}o;+2F8nQ-Tc-!;YqW2@L3)!z4(w=p;T39eY8B zHLySU`pkI=VXM0_m94LIcTPIRd2U)P4t0}lz1aMz{1ToGr@4{DVAwzP;zqJm&PxP3 zJM!Br1MaGK`qfZ%%+00QtMC{##gFDOrqY5_2P4`Hb3M^hJ^Z*pXk;jcWXyty!GjPM zZDoZ-=rr;gX3>+##-^gZL4n_9aHkcdOqP9wuF&icN_F-mddcw z6o$c&zXjcP6n0y26<-SkH}usEZ8=LI>(bQjWoOC8t&oMFJ<7=7Z*cVN<`o+aed~0A zUZ*ujmypTq0Tu{hw_;G0X;$(6yDpweyebC8QxGnCgkM;tEdgP-NL|8&WA%o`#3M^8 zIbgSIF}|vC!`}rX+_*T@zS(vB&96+1-x)E-5{BejTAW4=3B@PwWpN*1130n1>IoTn z7^KbqnO#-cE@COX^o#>LNU=r=Rfwm@!8E0u8M@1S94T!lj4l^b@8O{3gp(tgx$e}- zPo6MF%`HNyc(S$v@DgbtRI*TDEJ3ABc|>LqW~g(k1@0gl{FaA#4s|JPmoNo|rX<$| zTgDA*2;Z{;qTw6rT25QUWMXH1s!LiVZmb825s0pAnUi0jO25Vvf#L%lW6fIwK3y66 z+wsWzc%~v;c?!7hI&xf2(Vx4pCvp~eM27u}9*5wioBDQ}CV7Z}FIGB_sr<}DU}QD5 zIiP{aFkQYiOqs05nEXK!$DhkcU0drEdr;8NF6-M+b+JU5BD?@$foZz3xHzm{>7Q?k^Hu%1QVrE4Nx$#u9TlF5{_-EC-#GsOzlxnfUjS?U_8*ZF%i zvlT<9y)xCEpG8=Xj{-SpgwT)UwV(FyZNE0Un3(b%^Q&=~MY*%HV@+mKf|;)_;d}VA z?V0ESRlSTqxS6@oU@<{8oH}9Of{#*)$`_Ue#{AwfyFWtt>~K~(_7+eNwxkKg>1f!l_Q#ltm!}Y%`!S? zcq|R%z*Xu@yd6P4CmEkgz#h%weVe|0SiJ=x5H|+e;_1l$5ueWpan{x6%)*e+`gTw4 zfb~IQ#b*l&?8-7}rF<-IR$-;Zq9Ee-!(Dmdxe5ls@#H$~dxJb< zj&l~-U}uha^ugg_q)IGy9uHgQt0x~c zarws#Y}=m8efcM`vbXqzNzwaQ-Di|z{+!qA6$7#f7F(pf!jQ*fSDyyruQ3v>8y|vg zD$$AHb@+;zJwCl?yhzG^1@Dd~g9>f)+3atmp%JpC66c(fF)pa1djbu13E@m%q>F+g zS7vjg9sz?hH?pzxfUm+umwcD%gxVWf$vLQvz^P%xK?+=Ef?cXMM~p5fO{SZ`+%&PS z^e)^<56tdCT$k9Fk`R+_I`!Cm-olmh4$4J>KxAhn?!7San%s(9ArGL|i|=P1DXEbT zLVcGPT(NT+I*+Q6pwR|lsiT?BOnTrbLsd-AGe;l>qB_cYV3fI4#15Dgpbjyr#}h|P zE!JlU${7#PnseFGt4UNf{O(bhD+n9)g_*@}^Gka>6?fSEw~?^uht6dTeiXZp4Svs8 zVHt4lE>nXliFSi3sH9|7$IcvO4skd%>8=&Ylfip@G}tKw=xBi8ueYQFQnqk( zs<{+&s&r|u#j4EeBj@3wvzw`|XV;dbNkaAtTb0@<8!=2cd&%y9+(23q$ z0Djlf+T|!$k1PqFBVGQw$xz5Pf=+m1R+$&Ez{mo9RK&%7r)h-ym%fC80tCamg#ZBq zN$^gj{VzI9VMxON?4=;-{-LOZ{Hul$ZuyU*#XEH)#9xB_zbpRz`D_2{4V@VFE+X*{ zWj=&QKGeUX;XwJ&|K9&YR|z4eCjRNK#({d>tFXYdl%~XPbE8NmVYkIVq$O0`q#tC&cep} zpWN?I;NMdLWlIk;n=caYavpZh?=^(^_}PH}#Q%Su|E>66NUi@xvh#BPU(o+@{l8ER xXEP^pd)xP#F2euS_5$X literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/phi3.avif b/public/learning/images/modules/computer-science/qft/phi3.avif new file mode 100644 index 0000000000000000000000000000000000000000..3a917a12e8674a297f5c1e61d2c76db4b37a8965 GIT binary patch literal 26322 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 literal 0 HcmV?d00001 From 62f8f1aca832e014e35268e94453c22e28727486 Mon Sep 17 00:00:00 2001 From: Katie McCormick Date: Thu, 9 Oct 2025 13:22:07 -0700 Subject: [PATCH 2/6] add metadata to qft module --- learning/modules/computer-science/qft.ipynb | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/learning/modules/computer-science/qft.ipynb b/learning/modules/computer-science/qft.ipynb index c2d37a579aa..0b683ef0048 100644 --- a/learning/modules/computer-science/qft.ipynb +++ b/learning/modules/computer-science/qft.ipynb @@ -1,3 +1,4 @@ + { "cells": [ { @@ -1027,6 +1028,9 @@ } ], "metadata": { + "description": "Learn the theory and applications of the quantum Fourier transform.", + "in_page_toc_max_heading_level": 2, + "in_page_toc_min_heading_level": 2, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", @@ -1043,7 +1047,8 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.2" - } + }, + "title": "Quantum Fourier transform" }, "nbformat": 4, "nbformat_minor": 5 From 872e11c8ecf9319baba329172c3a91a08c234d99 Mon Sep 17 00:00:00 2001 From: Katie McCormick Date: Thu, 9 Oct 2025 13:39:38 -0700 Subject: [PATCH 3/6] sundry fixes --- qiskit_bot.yaml | 2 ++ scripts/config/notebook-testing.toml | 1 + 2 files changed, 3 insertions(+) diff --git a/qiskit_bot.yaml b/qiskit_bot.yaml index 7218a9cb80e..18b1b1cc7d5 100644 --- a/qiskit_bot.yaml +++ b/qiskit_bot.yaml @@ -1070,3 +1070,5 @@ notifications: - "@christopherporter1" "docs/tutorials/transverse-field-ising-model": - "@dsierrasosa" + "learning/modules/computer-science/qft": + - "@kcmccormibm" diff --git a/scripts/config/notebook-testing.toml b/scripts/config/notebook-testing.toml index 12e4465dd70..7db66318086 100644 --- a/scripts/config/notebook-testing.toml +++ b/scripts/config/notebook-testing.toml @@ -280,6 +280,7 @@ notebooks = [ "learning/modules/computer-science/grovers.ipynb", "learning/modules/computer-science/quantum-key-distribution.ipynb", "learning/modules/computer-science/quantum-teleportation.ipynb", + "learning/modules/computer-science/qft.ipynb", "learning/modules/quantum-mechanics/superposition-with-qiskit.ipynb", "learning/modules/quantum-mechanics/stern-gerlach-measurements-with-qiskit.ipynb", "learning/modules/quantum-mechanics/exploring-uncertainty-with-qiskit.ipynb", From 6493437312b14ee60802b8177c475ffbc4809bcc Mon Sep 17 00:00:00 2001 From: Katie McCormick Date: Thu, 9 Oct 2025 13:58:23 -0700 Subject: [PATCH 4/6] another typo -_- --- learning/modules/computer-science/qft.ipynb | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/learning/modules/computer-science/qft.ipynb b/learning/modules/computer-science/qft.ipynb index 0b683ef0048..6ef81f68ce8 100644 --- a/learning/modules/computer-science/qft.ipynb +++ b/learning/modules/computer-science/qft.ipynb @@ -1,4 +1,3 @@ - { "cells": [ { @@ -67,7 +66,7 @@ "\n", "We can Fourier transform this waveform to go from the time basis to the frequency basis:\n", "\n", - "![Frequency spectrum of the audio waveform. one clear sharp peak at 260 Hz.](/learning/images/modules/computer-science/qft/my-course/Cnotefreq.avif)\n", + "![Frequency spectrum of the audio waveform. one clear sharp peak at 260 Hz.](/learning/images/modules/computer-science/qft/Cnotefreq.avif)\n", "\n", "In the frequency basis, we can easily see a clear peak at about 260 Hz. That's a middle C! \n", "\n", @@ -132,7 +131,7 @@ "\n", "We can visualize this state by plotting the complex amplitude of each of the terms. The red line guides the eye to show you how the phase of this amplitude winds around the complex plane as a function of the computational basis state. For $|\\phi_0\\rangle$, the phase remains constant:\n", "\n", - "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_0$. They are all real, and so the bars all point to +1 on the x-axis](/learning/images/modules/computer-science/qft/phi0.avif)\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for phi_0. They are all real, and so the bars all point to +1 on the x-axis](/learning/images/modules/computer-science/qft/phi0.avif)\n", "\n", "The next Fourier basis state is the one whose components' phases wind around from $0$ to $2\\pi$ just once:\n", "\n", @@ -140,7 +139,7 @@ "\n", "And we can see this winding in the plot of complex amplitude vs. computational basis state:\n", "\n", - "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_1$. The red line shows how the complex phase accumulates such that it winds around $2\\pi$ once as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi1.avif)\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for phi_1. The red line shows how the complex phase accumulates such that it winds around 2 pi once as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi1.avif)\n", "\n", "\n", "So, each state has a phase that is $2\\pi/4$ radians higher than the state before it when they're ordered in the standard way, since in this example we have four basis states ($N=4$). The next basis state winds around from 0 to 2$\\pi$ twice:\n", @@ -148,7 +147,7 @@ "$$|\\phi_2\\rangle = \\frac{1}{2} (|00\\rangle + e^{i\\pi}|01\\rangle + e^{2i\\pi}|10\\rangle + e^{3i\\pi}|11\\rangle) = \\frac{1}{2} (|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle)$$\n", "\n", "\n", - "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_2$. The red line shows how the complex phase accumulates such that it winds around $2\\pi$ twice as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi2.avif)\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for phi_2. The red line shows how the complex phase accumulates such that it winds around 2 pi twice as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi2.avif)\n", "\n", "\n", "Finally, the highest Fourier component is the one with the fastest varying phase. For our example with two qubits, it's the one whose phases wind around from 0 to $2\\pi$ three times:\n", @@ -156,7 +155,7 @@ "$$|\\phi_3\\rangle = \\frac{1}{2} (|00\\rangle + e^{3i\\pi/2}|01\\rangle + e^{6i\\pi/2}|10\\rangle + e^{9i\\pi/2}|11\\rangle) = \\frac{1}{2} (|00\\rangle - i|01\\rangle - |10\\rangle + i|11\\rangle)$$\n", "\n", "\n", - "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for $phi_3$. The red line shows how the complex phase accumulates such that it winds around $2\\pi$ three times as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi3.avif)\n", + "![Bar graph of the complex amplitude (x-y plane) for each computational basis state (z-axis) for phi_3. The red line shows how the complex phase accumulates such that it winds around 2 pi three times as you step through all of the computational basis states.](/learning/images/modules/computer-science/qft/phi3.avif)\n", "\n", "\n", "\n", @@ -918,7 +917,7 @@ "$|\\pi_2\\rangle = \\frac{1}{\\sqrt{2}}( |\\psi\\rangle|0\\rangle + e^{2\\pi i \\theta}|\\psi\\rangle|1\\rangle)$\n", " $ = \\frac{1}{\\sqrt{2}}|\\psi\\rangle (|0\\rangle + e^{2\\pi i \\theta}|1\\rangle) $\n", "\n", - "Something weird just happened: the controlled-$U$ gate only uses qubit $0$ as a control qubit, so one might think that this gate wouldn't change qubit 0's state at all. But somehow, it does! Even though the operation was applied to the lower qubits, the overall effect of the gate is to change the phase of qubit $0$. This is known as the \"phase kickback mechanism,\" and is used in many quantum algorithms, including Deutsch-Josza and Grover's algorithms. If you want to learn more about the phase-kickback mechanism, see John Watrous' lesson on [Quantum query algorithms](https://learning.quantum.ibm.com/course/fundamentals-of-quantum-algorithms/quantum-query-algorithms#further-remarks-on-the-phase-kickback) in Fundamentals of Quantum Algorithms.\n", + "Something weird just happened: the controlled-$U$ gate only uses qubit $0$ as a control qubit, so one might think that this gate wouldn't change qubit 0's state at all. But somehow, it does! Even though the operation was applied to the lower qubits, the overall effect of the gate is to change the phase of qubit $0$. This is known as the \"phase kickback mechanism,\" and is used in many quantum algorithms, including Deutsch-Josza and Grover's algorithms. If you want to learn more about the phase-kickback mechanism, see John Watrous' lesson on [Quantum query algorithms](https://learning.quantum.ibm.com/course/fundamentals-of-quantum-algorithms/quantum-query-algorithms/deutsch-algorithm) in Fundamentals of Quantum Algorithms.\n", "\n", "After the phase-kickback, we apply one more Hadamard to qubit $0$, which results in the state:\n", "\n", @@ -956,7 +955,7 @@ "\n", "and from $|y\\rangle$, we can deduce $\\theta$.\n", "\n", - "If $\\theta/2^m$ is *not* an integer multiple, however, then taking the inverse QFT will only *approximate* $\\theta$. How well it approximates $\\theta$ will be probabilistic, meaning we won't always get the best approximation, but it will be pretty close, and the more qubits $m$ you use, the better the approximation you will get. To learn about how to quantify this approximation of $\\theta$, check out John Watrous' lesson on [Phase estimation and factoring](learning/courses/fundamentals-of-quantum-algorithms/phase-estimation-and-factoring) in Fundamentals of Quantum Algorithms. \n", + "If $\\theta/2^m$ is *not* an integer multiple, however, then taking the inverse QFT will only *approximate* $\\theta$. How well it approximates $\\theta$ will be probabilistic, meaning we won't always get the best approximation, but it will be pretty close, and the more qubits $m$ you use, the better the approximation you will get. To learn about how to quantify this approximation of $\\theta$, check out John Watrous' lesson on [Phase estimation and factoring](learning/courses/fundamentals-of-quantum-algorithms/phase-estimation-and-factoring/introduction) in Fundamentals of Quantum Algorithms. \n", "\n", "\n", "### Conclusion\n", @@ -1028,7 +1027,7 @@ } ], "metadata": { - "description": "Learn the theory and applications of the quantum Fourier transform.", + "description": "Learn the theory and applications of the quantum Fourier transform.", "in_page_toc_max_heading_level": 2, "in_page_toc_min_heading_level": 2, "kernelspec": { From 70a83c51e9d378ff8200dbec0c841813360575f9 Mon Sep 17 00:00:00 2001 From: Katie McCormick Date: Thu, 9 Oct 2025 14:26:47 -0700 Subject: [PATCH 5/6] fixing links --- learning/modules/computer-science/qft.ipynb | 230 +++++++++----------- 1 file changed, 100 insertions(+), 130 deletions(-) diff --git a/learning/modules/computer-science/qft.ipynb b/learning/modules/computer-science/qft.ipynb index 6ef81f68ce8..3a77b3f8c38 100644 --- a/learning/modules/computer-science/qft.ipynb +++ b/learning/modules/computer-science/qft.ipynb @@ -45,9 +45,9 @@ "source": [ "## Introduction\n", "\n", - "A Fourier transform is a ubiquitous tool with applications in math, physics, signal processing, data compression, and countless other fields. A *quantum* version of the Fourier transform, aptly named the quantum Fourier transform, forms the basis for some of the most important quantum algorithms. \n", + "A Fourier transform is a ubiquitous tool with applications in math, physics, signal processing, data compression, and countless other fields. A *quantum* version of the Fourier transform, aptly named the quantum Fourier transform, forms the basis for some of the most important quantum algorithms.\n", "\n", - "Today, after a reminder of the classical Fourier transform, we'll talk about how we implement the quantum Fourier transform on a quantum computer. Then, we'll discuss one of the applications of the quantum Fourier transform to an algorithm called the phase estimation algorithm. Quantum phase estimation is a subroutine in Shor's famous factoring algorithm, which is sometimes referred to as the \"crown jewel\" of quantum computing. This module builds toward another module all about Shor's algorithm, but it's also meant to be stand-alone. The quantum Fourier transform is a fascinating and useful algorithm in its own right!\n" + "Today, after a reminder of the classical Fourier transform, we'll talk about how we implement the quantum Fourier transform on a quantum computer. Then, we'll discuss one of the applications of the quantum Fourier transform to an algorithm called the phase estimation algorithm. Quantum phase estimation is a subroutine in Shor's famous factoring algorithm, which is sometimes referred to as the \"crown jewel\" of quantum computing. This module builds toward another module all about Shor's algorithm, but it's also meant to be stand-alone. The quantum Fourier transform is a fascinating and useful algorithm in its own right!" ] }, { @@ -60,7 +60,7 @@ "\n", "Before we jump into the quantum Fourier transform, let's first remind ourselves of the classical version. The Fourier transform is a method of transforming from one so-called \"basis\" to another. You can think of two bases as different perspectives of the same problem — they are both valid ways to express a function, but one or the other might be more illuminating, depending on the problem at hand. Some examples of pairs of bases that are connected by Fourier transform are position and momentum, and time and frequency.\n", "\n", - "Let's see an example of how the Fourier transform might help us figure out what note an instrument is playing based on its audio waveform. Typically, we see the waveforms represented in the time basis — that is, the amplitude of the wave is expressed as a function of time. \n", + "Let's see an example of how the Fourier transform might help us figure out what note an instrument is playing based on its audio waveform. Typically, we see the waveforms represented in the time basis — that is, the amplitude of the wave is expressed as a function of time.\n", "\n", "![Single sinusoidal signal plotted as a function of time.](/learning/images/modules/computer-science/qft/Cnote.avif)\n", "\n", @@ -68,7 +68,7 @@ "\n", "![Frequency spectrum of the audio waveform. one clear sharp peak at 260 Hz.](/learning/images/modules/computer-science/qft/Cnotefreq.avif)\n", "\n", - "In the frequency basis, we can easily see a clear peak at about 260 Hz. That's a middle C! \n", + "In the frequency basis, we can easily see a clear peak at about 260 Hz. That's a middle C!\n", "\n", "Now, you might have been able to do determine that a middle C was being played without the use of a Fourier transform, but what if multiple notes are played at once? Then the waveform becomes more complicated when we plot it in the time basis:\n", "\n", @@ -81,7 +81,7 @@ "\n", "This was a C-major chord, playing the notes C, E, and G.\n", "\n", - "This kind of Fourier analysis can help us extract the frequency components of any sort of complicated signal. \n", + "This kind of Fourier analysis can help us extract the frequency components of any sort of complicated signal.\n", "\n", "\n", "### Discrete Fourier transform\n", @@ -90,8 +90,7 @@ "\n", "$$y_k = \\frac{1}{\\sqrt{N}}\\sum_{j=0}^{N-1}x_j\\omega_N^{jk}$$\n", "\n", - "where we take $\\omega_N^{jk} = e^{2\\pi i \\frac{jk}{N}}$. (Note that there are other conventions that have a minus sign in the exponential, so be careful when you see the DFT in the wild.) Recall that $e^{2\\pi i \\frac{jk}{N}}$ is a periodic function, with period $\\frac{N}{k}$. So, by multiplying by this function, the Fourier transform is essentially a way to break the (discrete) function $\\{x_{j}\\}$ into a linear combination of its constituent periodic functions, each with period $\\frac{N}{k}$.\n", - "\n" + "where we take $\\omega_N^{jk} = e^{2\\pi i \\frac{jk}{N}}$. (Note that there are other conventions that have a minus sign in the exponential, so be careful when you see the DFT in the wild.) Recall that $e^{2\\pi i \\frac{jk}{N}}$ is a periodic function, with period $\\frac{N}{k}$. So, by multiplying by this function, the Fourier transform is essentially a way to break the (discrete) function $\\{x_{j}\\}$ into a linear combination of its constituent periodic functions, each with period $\\frac{N}{k}$." ] }, { @@ -101,18 +100,13 @@ "source": [ "## The quantum Fourier transform\n", "\n", - "So now, we've seen how the Fourier transform is used to represent a function as a linear combination of a new set of so-called \"basis functions.\" Basis transformations are regularly done on qubit states, too. For example, the state of a single qubit $|\\psi\\rangle$ can be expressed in the computational basis $|\\psi\\rangle = c_0 |0\\rangle + c_1 |1\\rangle$, with basis states $|0\\rangle$ and $|1\\rangle$, or in the $X$ basis $|\\psi\\rangle = c_+ |+\\rangle + c_- |-\\rangle$ with basis states $|+\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |1\\rangle)$ and $|-\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle - |1\\rangle)$. Both are equally valid, but one might be more natural than the other, depending on the type of problem you are trying to solve. \n", + "So now, we've seen how the Fourier transform is used to represent a function as a linear combination of a new set of so-called \"basis functions.\" Basis transformations are regularly done on qubit states, too. For example, the state of a single qubit $|\\psi\\rangle$ can be expressed in the computational basis $|\\psi\\rangle = c_0 |0\\rangle + c_1 |1\\rangle$, with basis states $|0\\rangle$ and $|1\\rangle$, or in the $X$ basis $|\\psi\\rangle = c_+ |+\\rangle + c_- |-\\rangle$ with basis states $|+\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |1\\rangle)$ and $|-\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle - |1\\rangle)$. Both are equally valid, but one might be more natural than the other, depending on the type of problem you are trying to solve.\n", "\n", "Qubit states can also be expressed in the Fourier basis where a state is expressed in terms of a linear combination of the Fourier basis states $|\\phi_y\\rangle$, rather than the usual, computational basis states, $|x\\rangle$. To do this, you need to apply a quantum Fourier transform (QFT):\n", "\n", "$$ | \\phi_y \\rangle = \\frac{1}{\\sqrt{N}}\\sum_{x=0}^{N-1}\\omega_N^{y x} \\vert x \\rangle$$\n", "\n", - "with $\\omega_N^{yx} = e^{\\frac{2\\pi y x}{N}}$ as above, and $N$ is the number of basis states in your quantum system. Note that, since we're working with qubits now, $m$ qubits gives you $2^m$ basis states, so $N=2^m$. Here, the basis states are written as just a single number $|x\\rangle$ where $x$ ranges from $0$ to $N-1$, but you might more typically see the basis states expressed as $|00...00\\rangle$, $|00...01\\rangle$, $|00...11\\rangle$, ..., $|11...11\\rangle$, where each binary digit represents the state of qubit 0 through $m-1$, from right to left. There's an easy way to convert these binary states to a single number: just treat them like binary numbers! So, $|00...00\\rangle = |0\\rangle$, $|00...01\\rangle = |1\\rangle$, $|00...10\\rangle = |2\\rangle$, $|00...11\\rangle = |3\\rangle$, and so on, all the way up to $|11...11\\rangle = |2^m -1\\rangle = |N-1\\rangle$.\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "with $\\omega_N^{yx} = e^{\\frac{2\\pi y x}{N}}$ as above, and $N$ is the number of basis states in your quantum system. Note that, since we're working with qubits now, $m$ qubits gives you $2^m$ basis states, so $N=2^m$. Here, the basis states are written as just a single number $|x\\rangle$ where $x$ ranges from $0$ to $N-1$, but you might more typically see the basis states expressed as $|00...00\\rangle$, $|00...01\\rangle$, $|00...11\\rangle$, ..., $|11...11\\rangle$, where each binary digit represents the state of qubit 0 through $m-1$, from right to left. There's an easy way to convert these binary states to a single number: just treat them like binary numbers! So, $|00...00\\rangle = |0\\rangle$, $|00...01\\rangle = |1\\rangle$, $|00...10\\rangle = |2\\rangle$, $|00...11\\rangle = |3\\rangle$, and so on, all the way up to $|11...11\\rangle = |2^m -1\\rangle = |N-1\\rangle$." ] }, { @@ -121,9 +115,9 @@ "id": "07d09c65-9ba8-41cb-983d-b5dd33d99458", "metadata": {}, "source": [ - "### Building intuition for the Fourier basis states \n", + "### Building intuition for the Fourier basis states\n", "\n", - "So, we've just gone over what the computational basis states are and how they're ordered: they're the set of states where each qubit is either in $0$ or $1$, and we order them from the state where all qubits are $0$, $|00...00\\rangle$, to the state where they are all $1$, $|11...11\\rangle$. \n", + "So, we've just gone over what the computational basis states are and how they're ordered: they're the set of states where each qubit is either in $0$ or $1$, and we order them from the state where all qubits are $0$, $|00...00\\rangle$, to the state where they are all $1$, $|11...11\\rangle$.\n", "\n", "But how can we make sense of the *Fourier* basis states? All of the Fourier basis states are equal superpositions of all the computational basis states, but each state differs from the other in the periodicity in the components' *phase*. To understand this more concretely, let's take a look at the four Fourier basis states of a two-qubit system. The lowest Fourier state is one whose phase does not vary at all:\n", "\n", @@ -163,7 +157,7 @@ "\n", "### Try some example QFTs:\n", "\n", - "Let's try to continue to build our intuition for the quantum Fourier transform by making a state in the computational basis, then seeing what happens when we apply the QFT to it. For now, we'll just treat the QFT as a black box that we apply using the `QFTGate` from the Qiskit circuit library. Later, we'll take a peak under the hood to see how it's implemented. \n", + "Let's try to continue to build our intuition for the quantum Fourier transform by making a state in the computational basis, then seeing what happens when we apply the QFT to it. For now, we'll just treat the QFT as a black box that we apply using the `QFTGate` from the Qiskit circuit library. Later, we'll take a peak under the hood to see how it's implemented.\n", "\n", "We start by loading the necessary packages and selecting a device to run our circuit on:" ] @@ -178,7 +172,7 @@ "import numpy as np\n", "from qiskit import QuantumCircuit\n", "from qiskit.visualization import plot_histogram\n", - "from qiskit.circuit.library import QFTGate\n" + "from qiskit.circuit.library import QFTGate" ] }, { @@ -196,16 +190,16 @@ } ], "source": [ - "#Load the Qiskit Runtime service\n", + "# Load the Qiskit Runtime service\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", - "#Load the Runtime primitive and session\n", + "# Load the Runtime primitive and session\n", "from qiskit_ibm_runtime import SamplerV2 as Sampler\n", "\n", "service = QiskitRuntimeService()\n", "\n", - "#Use the least busy backend\n", - "#backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)\n", + "# Use the least busy backend\n", + "# backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)\n", "backend = service.backend(\"ibm_pinguino2\")\n", "\n", "print(backend.name)" @@ -232,11 +226,12 @@ "# Load the Aer simulator and generate a noise model based on the currently-selected backend.\n", "from qiskit_aer import AerSimulator\n", "from qiskit_aer.noise import NoiseModel\n", + "\n", "noise_model = NoiseModel.from_backend(backend)\n", "\n", "# Define a simulator using Aer, and use it in Sampler.\n", "backend_sim = AerSimulator(noise_model=noise_model)\n", - "sampler_sim = BackendSamplerV2(backend = backend_sim)" + "sampler_sim = BackendSamplerV2(backend=backend_sim)" ] }, { @@ -248,8 +243,9 @@ "source": [ "# Alternatively, load a fake backend with generic properties and define a simulator.\n", "from qiskit.providers.fake_provider import GenericBackendV2\n", + "\n", "backend_gen = GenericBackendV2(num_qubits=18)\n", - "sampler_gen = BackendSamplerV2(backend = backend_gen)" + "sampler_gen = BackendSamplerV2(backend=backend_gen)" ] }, { @@ -270,9 +266,8 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhMAAAFvCAYAAADwq0kDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9/0lEQVR4nO3deVxU5f4H8M8s7AyyGgiyCyLiLuaehiapkRfLvFbe9Fbem0VdA8sys7yRS2lqmd2yxYprZYtLZu4RNws1NBUBEbggoI0iCLLNzPn9wY+5EovMnJlzAD/v18uXzFm/R2T4zPM85zkKQRAEEBEREZlJKXcBRERE1LkxTBAREZEoDBNEREQkCsMEERERicIwQURERKIwTBAREZEoDBNEREQkCsMEERERicIwQURERKIwTBAREZEoDBNEREQkCsMEERERicIwQURERKIwTBAREZEoDBNEREQkCsMEERERicIwQURERKIwTBAREZEoDBNEREQkCsMEERERicIwQURERKIwTBAREZEoDBNEREQkCsMEERERicIwQURERKIwTBAREZEoDBNEREQkCsMEERERiaKWuwCizi49Pb3d22q1Wnz55Zf405/+BE9Pz3bvN3ToUHNKIyKSBFsmiCSk1Wrx7rvvQqvVyl0KEZHFMEwQERGRKAwTREREJArDBBEREYnCMEEkIY1Gg0mTJkGj0chdChGRxSgEQRDkLoKoMzPlbg5z8W4OIurI2DJBJKHa2loUFhaitrZW7lKIiCyGYYJIQnl5eYiPj0deXp7cpRARWQwnrSKiFgmCAL1eL3cZJlGpVFAoFHKXQXTTYZggohbp9Xps3bpV7jJMEh8fD7Wab2tEUmM3BxEREYnCMEFERESisD2QSEK9e/fGL7/8IncZREQWxZYJIiIiEoVhgkhCBQUFmDNnDgoKCuQuhYjIYhgmiCRUXV2NkydPorq6Wu5SiIgshmGCiIiIRGGYICIiIlEYJoiIiEgUhgkiCfn4+GDp0qXw8fGRuxQiIothmCCSULdu3RAbG4tu3brJXUqno9PpkJOTI3cZRNQCTlpFJKGysjLs3bsXMTExcHNzk7scq6uoqMCJEyeQl5eHc+fO4ffff4dOp4NKpYJGo0FQUBCCgoIQGRkJX1/fVo+j0+nwxhtv4NixY3jqqacwZMgQCa+CiG6EYYJIQhcuXMDKlSsRFRXVpcNEdnY2vv/+exw+fBg6na7FbS5duoT8/HwcOHAAABAREYEJEyYgOjq6ycO6GoNEeno6AODNN9/EunXr4OzsbP0LIaJ2YTeHBLRaLZKSkhAaGgp7e3v07NkTCQkJqKqqwty5c6FQKLB+/Xq5yyQSraKiAmvWrMELL7yAH3/8sVmQ0Gg08PDwgKura7NHhWdmZmLt2rV45plnkJubC6B5kLCxscGTTz7JIEHUwbBlwsoyMjIQGxuL0tJSODk5oU+fPiguLsbatWuRm5uLy5cvAwAGDBggb6FEIh05cgQbN27E1atXjcucnZ0xduxY9O3bF8HBwU3GitTU1KCgoADZ2dk4ePAgzp8/DwAoKirC4sWLMWXKFJSUlDQJEk8//TT69+8v7YUR0Q0xTFiRVqvF1KlTUVpaigULFmDJkiXQaDQAgBUrVmDhwoVQq9VQKBTo16+fzNUSmW/v3r147733IAgCgIYQMXPmTIwePRq2trYt7mNvb4/w8HCEh4djypQpOHXqFD7++GPk5+fDYDBg27Ztxm0ZJIg6NnZzWNETTzyBoqIizJ8/H6tWrTIGCQBISkpC//79odPpEBgYCBcXFxkrJak4Ojpi2LBhcHR0lLsUizl06BDeffddY5AYOnQoVq1ahdtvv73VIPFHCoUCffv2xbJlyzB9+vQm65RKJRYsWMAgQdSBMUxYSWZmJrZs2QJPT08kJye3uM3gwYMBoNmbZF5eHu666y5oNBq4ubnhwQcfxKVLl6xeM1mfv78/1q1bB39/f7lLsYiCggK88847xtdTpkzBP/7xD7i6uoo65vUMBoOxC4SIOiaGCStJSUmBwWDArFmzWh0s5uDgAKBpmLh69SrGjRuHoqIipKSk4J133kFqaiqmTJkCg8EgSe1kPXq9HpWVldDr9XKXIppOp8OGDRuM1zJhwgTMmjWr2cBKU453/WDL6+/o+Pe//43i4mLxRRORVTBMWMn+/fsBAOPGjWt1m6KiIgBNw8Q777yD8+fP4+uvv8aUKVNwzz334NNPP8Xhw4eb9CFT55STk4Px48d3icmXdu7cifz8fABAz5498eCDD1osSNjY2CAxMRGxsbEAgPr6evzrX/+ySN1EZHkcgGkljU21AQEBLa7X6XRIS0sD0DRM7NixA6NGjWrSDD58+HAEBwdj+/btuPvuu02uZciQISgtLTV5P2qfP/bxt+XixYsAgF27duHo0aPt3m/atGkm1yWWra1tq110Op0Ou3btAtAw3mHevHmwsbEx6zwtBYnGwZbh4eE4duwYLly4gMzMTOTm5iIkJKTVY4WFhaGurs6sOohudt7e3jhy5IhZ+zJMWElVVRUAoLq6usX1W7ZsgVarNc4C2Oj06dO45557mm0fGRmJ06dPm1VLaWkp+5ytqPF73R6N/x+qq6tN2k+O75+dnV2r644cOYIrV64AaBhw2dYv+La0FSSAhjs+4uLijOMy9uzZ0+a5iouLUVtba1YtRGQ+hgkr8fb2RllZGY4dO4bhw4c3WVdSUoLExEQAQL9+/Zo0DZeVlbU4eM3d3R1ZWVlm10LW4+Tk1O5tGwOEg4ODSfu1NdW0tbR1J0bjrJVAw1gJc9woSDQaOXIkPv74Y1y7dg1paWl46KGHWg06PXr0YMsEkZnE/K5gmLCSmJgYZGZmYvny5ZgwYQLCwsIAAOnp6XjggQeg1WoBSDNZlbnNVtQ+jb8M2+PMmTNISUlBbGwsevfu3e791qxZY0Zl4uh0OmzdurXZckEQcPbsWQCAq6sr+vbta9ax2xMkgIYWkujoaBw8eBD19fXIz89HeHh4i8fNzs5uMnCTiKTBAZhWkpSUBA8PDxQWFiIyMhJRUVHo1asXoqOjERwcjPHjxwNofluom5ubsfn4epcvX4a7u7sUpZMVhYaGYvfu3QgNDZW7FLNduHDB2MISHBxs8qBLU4JEo+DgYOPXeXl5ZlRNRNbEMGElfn5+SE1NxeTJk2Fvb4/8/Hy4u7tj48aN2LlzJ7KzswE0DxMREREtjo04ffo0IiIiJKmdrEetVsPNza1Tf3r+73//a/z6+vE+7WFOkACahok/zkNBRPJjmLCiiIgI7NixA1evXsXVq1fx888/45FHHkFVVRXy8/OhVCqbNRFPmTIFP/74o/G2UQD4+eefkZubi6lTp0p9CWRhRUVFWLBgQZPvb2dz7do149fXP2vjRswNEn88T2uDmolIPp3341EndurUKQiCgLCwsGbTKj/yyCNYt24d4uLisHTpUtTU1CApKQnR0dGIi4uTqWKylMrKSqSmpuLhhx+WuxSzjRgxAlFRUaivrzfp6Z1VVVXGEGXqszbc3Nzw+uuvw9bW1jjZGxF1HGyZkMFvv/0GoHkXBwC4uLhg//798PHxwX333Ye//vWvGDFiBHbs2AGlkt8ukp+trS08PDzg7e1tUpjo1q0bFi9ejICAAJMf2qVWq9GjRw94enqadBcMEUmDLRMyaCtMAEBISAh27NghZUlEknB3d0dycjKDMVEXw59oGdwoTBB1ZQwSRF0PWyZk0PjcDrr5eHl5ISEhAV5eXnKXQkRkMQwTRBLy8PDArFmz5C6DiMii2N5IJKGKigrs3bsXFRUVcpdCRGQxDBNEEiouLsaiRYtQXFwsdylERBbDMEFERESiMEwQERGRKAwTREREJArDBJGE7OzsEB4eDjs7O7lLISKyGN4aSiShoKAgbN68We4yiIgsii0TREREJArDBJGEsrKyMHLkSGRlZcldChGRxTBMEElIEATU19dDEAS5SyEishiOmSCiFqlUKsTHx1vseCs3bsHVqiponJyQ+OiMZq8tQaVSWeQ4RGQahgkiapFCoYBabbm3CAGAQWj4W61WN3tNRJ0XuzmIiIhIFH4cIJJQYGAgUlJS4OvrK3cpREQWwzBBJCF7e3uEhITIXQYRkUWxm4NIQiUlJVi2bBlKSkrkLoWIyGIYJogkVF5ejm3btqG8vFzuUoiILIZhgoiIiERhmCAiIiJRGCaIiIhIFIYJIgkplUoMHDgQSiV/9Iio6+A7GpGEDAYDfv31VxgMBrlLISKyGIYJIiIiEoVhgoiIiERhmCAiIiJRGCaIJKTRaDBp0iRoNBq5SyEishg+m4NIQr6+vnjppZfkLoOIyKLYMkEkodraWhQWFqK2tlbuUoiILIZhgkhCeXl5iI+PR15entylEBFZDLs5iIhaIAgC9Hq93GWYRKVSQaFQyF0G3YQYJoiIWqDX67F161a5yzBJfHw81Gq+rZP02M1BREREojBMEBERkShsDyOSUO/evfHLL7/IXQYRkUWxZYKIiIhEYZggklBBQQHmzJmDgoICuUshIrIYhgkiCVVXV+PkyZOorq6WuxQiIothmCAiIiJRGCaIiIhIFIYJIiIiEoVhgkhCPj4+WLp0KXx8fOQuhYjIYjjPBJGEunXrhtjYWLnLoE7KYDBAqeRnQOp4GCaIJFRWVoa9e/ciJiYGbm5ucpdDEikrK8O5c+dQVFSEmpoaAICdnR38/PwQHBwMNze3Gz6gq6ysDMnJybj33nsxZMgQKcomajeGCSIJXbhwAStXrkRUVBTDRBen1Wqxb98+/PDDD7h06VKb27q5uWHUqFGYMGECunfv3mx9WVkZXn75ZRQXF2P16tV4+umnMXDgQGuVTmQytpdJQKvVIikpCaGhobC3t0fPnj2RkJCAqqoqzJ07FwqFAuvXr5e7TCKygLKyMrzxxht4/PHH8dVXX90wSDTus337diQkJOC1116DVqttsq4xSAANwcPX19dq9ROZgy0TVpaRkYHY2FiUlpbCyckJffr0QXFxMdauXYvc3FxcvnwZADBgwAB5CyUiUQRBQGpqKj788ENUVVUZlyuVSvTu3RshISEIDAyEi4sLAODq1avIz8/HuXPnkJmZCb1eD0EQkJ6ejpMnT+L+++/HwIEDsWzZMmOQ8PT0xAsvvNBi6wWRnBgmrEir1WLq1KkoLS3FggULsGTJEmg0GgDAihUrsHDhQqjVaigUCvTr10/maonIXAaDAZs2bcLevXuNy1xcXDBx4kSMHz8e7u7uLe43YsQIAMCVK1dw8OBB7N69G2VlZaiursa//vUvODg4GGdLZZCgjozdHFb0xBNPoKioCPPnz8eqVauMQQIAkpKS0L9/f+h0uiafVqhrc3R0xLBhw+Do6Ch3KWQhBoMBGzdubBIkRo4ciddeew3Tp09vNUhcz9XVFXfffTdee+013HbbbcblDBLUWTBMWElmZia2bNkCT09PJCcnt7jN4MGDAQD9+/c3LmsMH9HR0bCzs7vhCG/qXPz9/bFu3Tr4+/vLXQpZyNatW3Ho0CEAgEqlwt///nc8/vjjTT48tJejoyNmzJjRLIBERkYySFCHxjBhJSkpKTAYDJg1axacnZ1b3MbBwQFA0zBx9uxZbN26Fd7e3hg6dKgktZJ09Ho9Kisrodfr5S6FLCA3NxdfffUVAEChUOCJJ57AmDFjzD5e42DLxrFUjQ4dOoTTp0+LqpXImhgmrGT//v0AgHHjxrW6TVFREYCmYWLMmDEoKSnBtm3bEBMTY90iSXI5OTkYP348cnJy5C6FRKqvr8eGDRtgMBgAANOnT8ewYcPMPt4f79rw9PTEtGnTjOvffvtt4xwVRB0NB2BaSUFBAQAgICCgxfU6nQ5paWkAmoYJa8xuN2TIEJSWllr8uNRg+vTp7d724sWLAIBdu3bh6NGj7d7v+l8qndW0h56Ek7MLSkpL4Ofn1+x1R2Nra9tqFyUApKWlGT8QBAYGIi4uzuxztRQkXnjhBXh6euL06dPIysrCxYsXceDAgTZnUA0LC0NdXZ3ZddDNzdvbG0eOHDFrX4YJK2m8NaxxANUfbdmyBVqtFhqNBkFBQVatpbS0FOfPn7fqOW5m198GeCON/x+qq6tN2q8rfP8M/9+1Y9Drcf78+WavOxo7O7s213///ffGrx966CGo1ea9nbYWJBrHSMydOxdJSUkAgD179mDSpEmtjqUqLi5GbW2tWXUQicEwYSXe3t4oKyvDsWPHMHz48CbrSkpKkJiYCADo16+f1QdZent7W/X4NzsnJ6d2b9sYIBwcHEzarytMUqRUqYx/+/r6Nnvd0dja2ra6Ljc3F+fOnQMABAUFISwszKxz3ChIAA2DdiMiIpCZmYni4mKcOnUKffv2bfF4PXr0YMsEmU3M7wqGCSuJiYlBZmYmli9fjgkTJhjfbNLT0/HAAw8YZ7iTYrIqc5utqH3S09Pbve2ZM2eQkpKC2NhY9O7du937rVmzxozKOpZX3vwEFZVV8PH2QVFRUbPXHY1Op8PWrVtbXHfixAnj17fffrtZHwjaEySuP0dmZqbx3K2FiezsbLNbSIjE4ABMK0lKSoKHhwcKCwsRGRmJqKgo9OrVC9HR0QgODsb48eMBNB0vQV1faGgodu/ejdDQULlLIREaWyUAoE+fPibvb0qQ+OM58vLyTD4fkbUxTFiJn58fUlNTMXnyZNjb2yM/Px/u7u7YuHEjdu7ciezsbAAMEzcbtVoNNzc3fnrs5Bp/oTs4OJjcNGxqkAAansfRrVs3AA1BRhAEMysnsg6+o1lRREQEduzY0Wx5ZWUl8vPzoVQqW22upK6pqKgIq1evxlNPPdUh72Cg9ikrKwMA3HLLLSbdgWVOkAAa5rDw8fFBeXk5qqqqoNPpYGNjY/4FEFkYw4QMTp06BUEQEBYW1uK0yl988QUAGCepaXwdGBiIIUOGSFcoWVxlZSVSU1Px8MMPy10KmUkQBEyfPh11dXXG1oL2evfdd81+aNfo0aMRERHR5sBQIrkwTMjgt99+A9B6F8c999zT4uvZs2fjgw8+sGptRNQ2hUJh9rwfc+fORXFxMerr601+1sbtt99u1jmJpMAwIYMbhQn2hxJ1Te7u7li8eDF0Oh2ftUFdCsOEDG4UJoio62rPU0SJOhuGCRk0PreDbj5eXl5ISEiAl5eX3KUQEVkMwwSRhDw8PDBr1iy5yyAisijOM0EkoYqKCuzduxcVFRVyl0JEZDEME0QSKi4uxqJFi4y3BxIRdQUME0RERCQKwwQRERGJwjBBREREojBMEEnIzs4O4eHhsLOzk7sUIiKL4a2hRBIKCgrC5s2b5S6DiMii2DJBREREojBMEEkoKysLI0eORFZWltylEBFZDMMEkYQEQUB9fT0f5kZEXQrHTBARtUClUiE+Pt5ix1u5cQuuVlVB4+SExEdnNHttCSqVyiLHITIVwwQRUQsUCgXUasu9RQoADELD32q1utlros6M3RxEREQkCuMwkYQCAwORkpICX19fuUshIrIYhgkiCdnb2yMkJETuMoiILIrdHEQSKikpwbJly1BSUiJ3KUREFsMwQSSh8vJybNu2DeXl5XKXQkRkMQwTREREJArDBBEREYnCMEFERESiMEwQSUipVGLgwIFQKvmjR0RdB9/RiCRkMBjw66+/wmAwyF0KEZHFMEwQERGRKAwTREREJArDBBEREYnCMEEkIY1Gg0mTJkGj0chdChGRxfDZHEQS8vX1xUsvvSR3GUREFsWWCSIJ1dbWorCwELW1tXKXQkRkMQwTRBLKy8tDfHw88vLy5C6FiMhiGCaIiIhIFI6ZoBYJgoBr1Tq5yzCJo4MaCoVC7jKIugRBEKDX6+UuwyQqlYrvATJhmKAWXavWwfnWj+QuwySVhx+Ek6ON3GUQdQl6vR5bt26VuwyTxMfHQ63mrzU5sJuDiIiIRGGEI5JQ79698csvv8hdBhGRRbFlgoiIiERhmCCSUEFBAebMmYOCggK5SyEishiGCSIJVVdX4+TJk6iurpa7FCIii2GYICIiIlEYJoiIiEgUhgkiIiIShWGCSEI+Pj5YunQpfHx85C6FiMhiOM8EkYS6deuG2NhYucsgIrIotkwQSaisrAyff/45ysrK5C6FSHI1NTX4/fffUVpaCq1Wi/r6epP2z8rKwtGjR61UHYnBlgkiCV24cAErV65EVFQU3Nzc5C6HyKpqamrw008/4dSpUzh37hxKSkogCIJxvUqlgr+/P4KCgjBw4EAMGjQIKpWqxWNlZWUhOTkZ9fX1+Mc//oHBgwdLdRnUDgwTRERkUVqtFjt37sShQ4dw7dq1VrfT6/XIy8tDXl4e9u/fD3d3d8TExGDSpElwdHQ0btcYJGpqagAA+/btw6BBg/iE0A6E3RwS0Wq1SEpKQmhoKOzt7dGzZ08kJCSgqqoKc+fOhUKhwPr16+Uu0+L++cRgCCfm4qG7e7W4/sB7d6LmyF8QGcpP6USdnSAI2LdvHxITE7Fr164mQUKtViM4OBi33norRo0ahejoaPj5+TUJBJcvX8Znn32GxMREHD9+HEDzIBEVFYUnn3ySQaKDYcuEBDIyMhAbG4vS0lI4OTmhT58+KC4uxtq1a5Gbm4vLly8DAAYMGCBvoVbw4lu/YupYf7z+9DB8/9N5nL/wvzeXJ++PxG1DffDMmnScOssxBESd2bVr1/DGG28YQwAA2NjYYOTIkRg3bhxCQkJafDx4TU0NTp8+jX379uHYsWMQBAGXLl1CcnIyoqOjceLEiSZBIjExEba2tpJdF7UPw4SVabVaTJ06FaWlpViwYAGWLFkCjUYDAFixYgUWLlwItVoNhUKBfv36yVyt5dXrDJj9/A/4+eO78N6LozHpb7sBAGGB3fDPx4fg8ImLWPnBbzJXKR1HR0cMGzasSRMuUWdXWVmJZcuWIT8/37jstttuw6xZs4zvd62xt7fHoEGDMGjQIJSWluJf//oXTp06BQBNnrDLINGxsZvDyp544gkUFRVh/vz5WLVqVZMfrKSkJPTv3x86nQ6BgYFwcXGRsVLr+TXzEpLfO447Rvrh4fhwKJUKfPTPMVAogNnP/wCDQbjxQboIf39/rFu3Dv7+/nKXQmQRtbW1ePXVV41BQqPRYOHChZg3b94Ng8QfeXt747nnnsPkyZObLHd1dcXTTz/NINGBMUxYUWZmJrZs2QJPT08kJye3uE3jiOT+/fsbl33xxReIj49HQEAAHB0d0bt3bzz33HOorKyUpG5rePmdX5Fx5hJWLYjGumeHY1hUdzy37iiy88vlLk1Ser0elZWV0Ov1cpdCZBFbtmzB2bNnATTMo/Liiy9i4MCBZh8vJycH+/bta7LsypUr+Pnnn0XVSdbFMGFFKSkpMBgMmDVrFpydnVvcxsHBAUDTMLFq1SqoVCq88sor2LVrF/72t79hw4YNmDRpEgwGgyS1W5pOJ2D28z/A3k6Fv8+IQOqxUqz5+KTcZUkuJycH48ePR05OjtylEImWlZWFXbt2AWgYH7Fo0SL4+vqKOt71gy179uxpXPfhhx9yfpYOjGMmrGj//v0AgHHjxrW6TVFREYCmYWL79u3w8vIyvh47diy8vLwwa9Ys/PjjjxgzZoyVKrau8so61NbpYWujwrephRBunt4Noi5HEAS8++67xnkj7r33XgQEBJh9vJbu2khMTMTGjRuRlpaGqqoqfPLJJ5g/f75F6ifLYpiwooKCAgBo9QdMp9MhLS0NQNMwcX2QaDRkyBAAwPnz502uY8iQISgtLTVpHwNsAPfnTT5XW95/aTRsbVQ4nVuG5x8ZgM925+Fc0VWLHb9XWBiUMG1GPUuYPn16u7e9ePEiAGDXrl0mzeQ3bdo0k+vqaKY99CScnF1QUloCPz+/Zq+7us52/ba2tq12zwLA6dOnUVhYCAAIDg5uNs7BFK0FCVtbW/zlL3/BiRMncPXqVfz000+4//774erq2uJxwsLCUFdXZ3YdNztvb28cOXLErH0ZJqyoqqoKAFBdXd3i+i1btkCr1UKj0SAoKKjNYx04cAAAEBERYXIdpaWlpocQhS3gbvKpWvX4n/tgXHQPLFp7BN8cKMCxLXdj00ujcducby12jpLiYkCQ/o2k8fvcHo3/F6qrq03az5wQ2dEY/n+ciEGvx/nz55u97uo62/Xb2dm1uX737t3Gr6dOnQql0rxe87aCBNAwoHP8+PH45ptvoNfrceDAgVbDdXFxMWpra82qg8RhmLAib29vlJWV4dixYxg+fHiTdSUlJUhMTAQA9OvXr80JWM6fP4/Fixdj0qRJZs1F4e3tbfI+BtigxOS9Whbq74LkhCH45bffsXzTCRgMAl7ccAzJCUPx+J/7YN2npy1yHp8ePWRpmXBycmr3to0BwsHBwaT9xPRDdxTK/58mWalSwdfXt9nrrq6zXX9bd07U1tYaW9ZcXV0xdOhQs85xoyDR6Pbbb8e2bdsgCALS0tJaDRM9evRgy4QI5vyuaMQwYUUxMTHIzMzE8uXLMWHCBISFhQEA0tPT8cADD0Cr1QJoe7KqyspKxMXFwdbWFps2bTKrDnOaraqu1cP51o/MOt/1FArgg5fHQKVUYPbzh4y3ga54/zf86fZAJCcMwc4fCi3S3ZGTnQ0nRxvRxzFVenp6u7fV6XT4y1/+Ao1G0+IEPq1Zs2aNGZV1LK+8+QkqKqvg4+2DoqKiZq+7us52/TqdDlu3bm1xXUFBgfGOpAEDBpj0f7lRe4MEAHTv3h0BAQHIz8/H+fPnUVNTA3t7+2bbZWdnm1ULice7OawoKSkJHh4eKCwsRGRkJKKiotCrVy9ER0cjODgY48ePB9B0vMT1qqurMXXqVOTl5eH777+Hj4+PlOVbxILZURg58Ba88NYxnMn7322gBoOAvyz+AWqVEpteGi1jhdJSq9Vwc3PjGx51aufOnTN+HRwcbPL+pgSJP55HEIQmk2NRx8AwYUV+fn5ITU3F5MmTYW9vj/z8fLi7u2Pjxo3YuXMnsrOzAbQcJurr6zF9+nQcOXIEu3btQp8+faQuX7TeQd3w8mOD8NPxi3jtw+a3gZ7OvYIXNxzD2CE+ePzPne/6zFFUVIQFCxZ0yE+iRO1VXFxs/NrUOzjMCRIAEBgYaPy6I44xudnx45GVRUREYMeOHc2WV1ZWIj8/H0qlEn379m2yrnFuin379uHbb79FdHS0VOVa1Jm8cjgM/bDNbV597wRefe+ERBXJr7KyEqmpqXj44YflLoXIbA4ODvD09ER9fb1Js1zm5OSYFSQAwMXFBd26dYOtrS1sbKTvzqS2MUzI5NSpUxAEAWFhYc2e0/DYY4/h888/xzPPPANHR0ccPnzYuC4kJKTFW0eJiKQyc+ZMzJw50+T9PDw84ObmhpKSEpOftXHrrbfi1ltvNfmcJA12c8jkt98aHm7VUhdH44xyr776KoYPH97kz86dOyWtk4jIUtzd3bF48WLExMTwoV1dDFsmZNJWmODgIiLqqtzd3fHXv/5V7jLIwtgyIZO2wgR1XV5eXkhISGBXFRF1KWyZkEnjczvo5uLh4YFZs2bJXQYRkUWxZYJIQhUVFdi7dy8qKirkLoWIyGIYJogkVFxcjEWLFjW5T5+IqLNjmCAiIiJRGCaIiIhIFIYJIiIiEoVhgkhCdnZ2CA8Ph52dndylEBFZDG8NJZJQUFAQNm/eLHcZREQWxZYJIiIiEoVhgkhCWVlZGDlyJLKysuQuhYjIYhgmiCQkCALq6+shCILcpRARWQzDBBEREYnCAZjUIkcHNSoPPyh3GSZxdOB/ZyJLUalUiI+Pt9jxVm7cgqtVVdA4OSHx0RnNXluCSqWyyHHIdHz3pRYpFAo4OdrIXQYRyUShUECtttyvCAGAQWj4W61WN3tNnRu/g0QSCgwMREpKCnx9feUuhYjIYhgmiCRkb2+PkJAQucsgIrIoDsAkklBJSQmWLVuGkpISuUshIrIYhgkiCZWXl2Pbtm0oLy+XuxQiIothmCAiIiJRGCaIiIhIFIYJIiIiEoVhgkhC7u7umD17Ntzd3eUuhYjIYhgmiCSkVCphY2MDpZI/ekTUdfAdjUhCWq0W7777LrRardylEBFZDMMEERERicIwQURERKIwTBAREZEoDBNEEtJoNJg0aRI0Go3cpRARWQwf9EUkIV9fX7z00ktyl0FEZFFsmSCSUG1tLQoLC1FbWyt3KUREFsMwQSShvLw8xMfHIy8vT+5SiIgsht0cRERELRAEAXq9Xu4yTKJSqaBQKCQ/L8MEERFRC/R6PbZu3Sp3GSaJj4+HWi39r3Z2cxAREZEoDBNEREQkCrs5iCTUu3dv/PLLL3KXQURkUWyZICIiIlEYJogkVFBQgDlz5qCgoEDuUoiILIZhgkhC1dXVOHnyJKqrq+UuhYjIYhgmiIiISBSGCSIiIhKFYYKIiIhEYZggkpCPjw+WLl0KHx8fuUshIrIYhgkiCXXr1g2xsbHo1q2b3KUQUSf0+++/y11CizhpFZGEysrKsHfvXsTExMDNzU3ucojIygRBwH//+1+cO3cOeXl5KCkpQV1dHZRKJZydnREQEICgoCD06tULLi4ubR5r9+7d2Lx5M5588kkMGTJEoitoH4YJIglduHABK1euRFRUFMMEURdWWVmJH374AXv27EFJSUmr26WnpwMAlEolhgwZgokTJyIyMrLZkz93796N999/HwCwevVqrFixAr6+vta7ABOxm0MCWq0WSUlJCA0Nhb29PXr27ImEhARUVVVh7ty5UCgUWL9+vdxlEhGRSAaDAd999x0ee+wxfPTRR20GiT/u98svv2DZsmV47rnnUFhYaFx3fZAAgKlTp6JHjx4Wr10MtkxYWUZGBmJjY1FaWgonJyf06dMHxcXFWLt2LXJzc3H58mUAwIABA+QtlIiIRLl48SI2bNiAzMzMJsv79OmDgQMHIjg4GP7+/nBwcIDBYMDly5eRl5eHs2fPIi0tDVeuXAEAnDt3Ds8++yymT58Oe3t7fPDBB8Zj3X333ZgxY0azlgu5MUxYkVarxdSpU1FaWooFCxZgyZIl0Gg0AIAVK1Zg4cKFUKvVUCgU6Nevn8zVEhGRufLz85GcnIzy8nLjsnHjxmHKlCmtdkd4e3vD29sbw4cPx8yZM3HkyBF89tlnKC4uhk6nw7///e8m23fUIAEwTFjVE088gaKiIsyfPx+rVq1qsi4pKQmffvopjh8/jqCgoBsOvKGuwdHREcOGDYOjo6PcpRCRhRQWFmLZsmWorKwEAHh5eWHevHmIjIxs9zHUajVuvfVWDBo0CJ9//jm2b9/eZH1cXFyHDRIAx0xYTWZmJrZs2QJPT08kJye3uM3gwYMBAP379zcuS01NRUxMDHx8fGBnZwc/Pz/MmDGjWbMZdU7+/v5Yt24d/P395S6FiCygpqYGK1asMAaJXr16ITk52aQgcT1bW1t4eno2W25jY9NhgwTAMGE1KSkpMBgMmDVrFpydnVvcxsHBAUDTMFFWVoaoqCisXbsW33//PZYvX45Tp05h+PDhKCoqkqR2sh69Xo/Kykro9Xq5SyEiC/jkk0+Mcz8EBwfj2WefbfU9vz3+ONiy0VdffdWhnzbMMGEl+/fvB9DQZ9aaxnBwfZi46667sHr1atxzzz0YO3YsZs2ahS+//BLl5eXYunWrdYsmq8vJycH48eORk5MjdylEJNLp06exZ88eAICdnR0SEhJEdWH+MUjcfffdiIuLA9DwQWTDhg0wGAziirYSjpmwksYEGRAQ0OJ6nU6HtLQ0AE3DREs8PDwANPSpmWPIkCEoLS01a1+6senTp7d724sXLwIAdu3ahaNHj7Z7v2nTpplcV0cz7aEn4eTsgpLSEvj5+TV73dXx+jvf9dva2rbaTQ0A33zzjfHrmTNn4pZbbjH7XC0FiRkzZkCn0+Ho0aMoKipCfn4+jh8/joEDB7Z6nLCwMNTV1ZlVg7e3N44cOWLWvgwTVlJVVQUAqK6ubnH9li1boNVqodFoEBQU1Gy9Xq+HwWBAQUEBnn32WXh7e+Pee+81q5bS0lKcP3/erH3pxhq/1+3R+P+hurrapP26wvfP8P9dOwa9HufPn2/2uqvj9Xe+67ezs2t1XWlpKY4fPw6gYcDlxIkTzT5Pa0FCoVDAxsYG9913n3EQ//fff99mmCguLkZtba3ZtZiLYcJKvL29UVZWhmPHjmH48OFN1pWUlCAxMREA0K9fvxYH1YwdO9bYchEaGor9+/fDy8vL7FrIepycnNq9bWOAcHBwMGm/jjTTnbmUKpXxb19f32avuzpef+e7fltb21bXHThwwPj1hAkToFSaN2qgrSDRaNCgQfD09IRWq0VGRgYuXbpkbLH+ox49eohqmTAXw4SVxMTEIDMzE8uXL8eECRMQFhYGoGHq1AceeABarRZA65NVvffee7hy5Qry8vKwcuVKTJw4EWlpaWbdBWBusxW1T+N0uO1x5swZpKSkIDY2Fr179273fmvWrDGjso7llTc/QUVlFXy8fVBUVNTsdVfH6+9816/T6Vodq3bmzBnj12PGjDHr+O0JEkDDVNujR4/GV199BUEQkJ2d3exDaqPs7Gyzu8TF4ABMK0lKSoKHhwcKCwsRGRmJqKgo9OrVC9HR0QgODsb48eMBtD5eIjw8HMOGDcN9992Hffv24erVq1ixYoWUl0BWEBoait27dyM0NFTuUojITAaDAfn5+QCA7t27w9XV1eRjtDdINLr+PePcuXMmn8/aGCasxM/PD6mpqZg8eTLs7e2Rn58Pd3d3bNy4ETt37kR2djaAGw++BABXV1eEhobi7Nmz1i6brEytVsPNzU2WTw5EZBklJSXGcQktjXm7EVODBNBw22mjxiDTkfAdzYoiIiKwY8eOZssrKyuRn58PpVKJvn373vA4Fy9eRFZWFoYNG2aNMklCRUVFWL16NZ566qkOO4KdiNrWOEEVgFbHLrTGnCABAG5ublAqlTAYDCYN3pYKw4QMTp06BUEQEBYW1uye5Pvvvx+hoaEYMGAAXF1dkZOTg9WrV0OtVuOpp56SqWKylMrKSqSmpuLhhx+WuxQiMlPPnj3xwgsvoL6+3qQwUVdXh927dxtfm/qsjcTERKjValGTYlkLw4QMfvvtNwAtd3Hceuut+Oijj/DGG2+gpqYGPXv2xLhx47Bo0aJW56wgIiLpODo6ok+fPibvZ2tri+effx4vv/wyhg0bZvKzNtq6JVRuDBMyaCtMzJ8/H/Pnz5e6JCIikoC7uzv++c9/wsHBoUM/a8NUDBMyaCtMEBFR19YVnxrMMCGDxud20M3Hy8sLCQkJZk9ARkTUETFMEEnIw8MDs2bNkrsMIiKL4jwTRBKqqKjA3r17UVFRIXcpREQWwzBBJKHi4mIsWrQIxcXFcpdCRGQxDBNEREQkCsMEERERicIwQURERKIwTBBJyM7ODuHh4bCzs5O7FCIii+GtoUQSCgoKwubNm+Uug4jIotgyQURERKIwTBBJKCsrCyNHjkRWVpbcpRARWQzDBJGEBEFAfX09BEGQuxQiIovhmAkiIqIWqFQqxMfHW+x4KzduwdWqKmicnJD46Ixmry1BpVJZ5DimYpggIiJqgUKhgFptuV+TAgCD0PC3Wq1u9rozYzcHERERidK5oxBRJxMYGIiUlBT4+vrKXQoRkcUwTBBJyN7eHiEhIXKXQURkUezmIJJQSUkJli1bhpKSErlLISKyGIYJIgmVl5dj27ZtKC8vl7sUIiKLYZggIiIiURgmiIiISBSGCSIiIhKFd3MQiTR06NB2b+vn54clS5YgJiYGPj4+VqyKiEg6DBNEEvLx8cGLL74odxlERBbFbg4iIiIShWGCiIiIRGGYICIiIlEYJoiIiEgUhgkiIiIShWGCiIiIRGGYICIiIlEYJoiIiEgUhgkiIiIShWGCiIiIRGGYICIiIlEYJoiIiEgUhglqZv/+/VCpVAgNDZW7FKI2ffvttxgwYADs7OwQGBiI119/Xe6SJPXDDz8gLi4OAQEBUCgUWLZsmdwlSWrlypUYPnw43Nzc4OrqilGjRuG7776TuyzJbN68GYMHD4abmxscHBwQERGB119/HYIgSF4LwwQ1UVpaitmzZ2PixIlyl0LUpiNHjiAuLg6xsbHIyMjAiy++iEWLFuHtt9+WuzTJVFZWok+fPlixYgW8vb3lLkdy+/fvx5w5c3DgwAH88ssvGDFiBKZMmYK0tDS5S5NE9+7dsXjxYvznP//BqVOn8Mwzz2Dx4sVYu3at5LXwEeRkZDAYcP/99+Oxxx5DTU0NcnJy5C6JqFWvv/46hg4diuTkZABAREQETp06hVdffRXz5s2TuTpp3HnnnbjzzjsBAAsXLpS5Gunt2rWryesVK1bgu+++w5dffomRI0fKVJV07rjjjiavg4OD8fXXX+PgwYNISEiQtBaGCTJ6+eWXoVAosHDhQixdulTucqiTKv39MioqrzVbrtPrjX9n5xU1e91IpVQi2N8HCoWizfOkpaVh7ty5TZZNmjQJq1atQlFREfz8/MReilmuVdegqFTbbHl7rx8AetziAWdHB+sXayV5hSWo1+mbLDPl+p0d7dHjFk+Tz2swGFBRUQEnJyczK7eMS2UVuHSlotlyU/4NQvx7QKVqf+eBIAhIT09HWloann/+eRHVm4dhggAABw4cwNtvv41ff/31hm/iRG2p1+nwwee7YGil3/ZadQ02ffZtq6/vGDMUIQE9bniekpKSZk37ja9LSkpkCxN2trb4/od0FJX+3uL6G13/LZ5umD97mtXrtKbiC5ewfd9/Wlx3o+tXAHh45hSzzvvKK6/gypUreOSRR8za31JUKiU+/WYvamrrWlx/o3+DwX3DEBbUvv+/5eXl8PX1RV1dHQwGA5YsWYInnnhC3AWYgWMmCFqtFvfffz/ef//9m7LflSyrp093jB8xyKx9/XvcgjHD+lu4ImmpVErcO2Uc1GqV6fsqG/a1UXfuz3nDB0ciNMDXrH1HDe2HYP8bh8k/euutt/DKK6/giy++kC1INnJ1cUbcBPO6WVxdnDE1ZkS7t9doNMjIyMCRI0ewfv16vP7663jvvffMOrcYDBOEkydPori4GFOmTIFarYZarcZLL72E3NxcqNVqfPrpp3KXSJ3MuOED4efjZdI+tjZq3DvlNqiU7Xtb8vHxQWlpaZNlFy5cMK6TU3cPV9x52zCT94sZNRi+ZjTvdzRKhQL33DkW9na2Ju13i6cbJo4ZYvL5Vq1ahcTERGzbtg0xMTEm728NA/qEol/vYJP2UQC4d8o4k/7dlEolQkND0a9fP8ybNw9JSUl47rnnTKxWPIYJwtChQ/Hbb78hIyPD+GfevHno2bMnMjIyMHnyZLlLpE5GpVJixuRxsDHh0/nk8cPh6dat3duPHDkSu3fvbrLsu+++Q0BAgOyfTAHg1kGR6BXY/k/nAb63YGwnb5W5XjcXZ9w9cVS7t1cplZgxdbzJrTIvvPACli5dim+//bbDBAkAUCgUuHviKGicHdu9z+jofgjuKS4IGwwG1NTUiDqGOTp3WxpZhJOTE/r27dtkWffu3WFra9tsOVF7eXm44s5xt+KbPTe+Ta93iD+i+/c26fhPPfUURowYgeeeew4PPPAAfv75Z6xbtw6rV682t2SLUioUmH7nbViz6QtU19S2ua2tjRr3Th4HZTtbZRpVVlbi7NmzAIC6ujqUlpYiIyMDzs7OHWKemAF9QnE6Jx8nzpy74bYTRg9Bj+4eJh3/ySefxMaNG5GSkoLw8HBjS5WDgwO6dWt/MLUWRwd73BM7Fps+33XDbb293DFx9FCTjr9kyRKMHj0awcHBqK+vxw8//IDly5fjoYceMrdksykEOWa3oA7vxRdfxMcff2x8oyIyhyAIeP/zXc1Gql/P0cEOT825x6RPcI127tyJRYsW4cyZM/D29kZCQgL+8Y9/iCnZ4o6fPouU7fvb3OZPk8aYHKYA4ODBgxg3blyz5WPHjsXBgwdNPp41XKuuwZpNX7R4h0+jQD9vPDJzislhqrXB4rNnz8YHH3xg0rGs6evvf8ThX0+3ul6lUmL+g9PgY2KYeuqpp7B9+3acP38e9vb2CA4Oxpw5czBv3jyoVKaP2RGDYYJMcq26BpevXDW5P5xuXhVXq7C6jU/n9989AX3DgySuSlop2/bheGZui+siQv3x4J/u6NJ3UWXnFTW5W+F6trY2SHgoHh6uLhJXJZ26unqs/fBLaC+Xt7g+9rZojB02QNqiLIxjJsgkqem/Yf1HX2Hn/sNyl0KdhIvGCdNa6Tsf1DesywcJAIibOAouzs3nPnBysMefJo3p0kECAMKC/DB8UGSL66aOH96lgwTQEJhmTB4HZQvf50A/b4we2k+GqiyLYYLaraq6Bv85ehJAww8AUXv1iwjBgD5N+/BdXZxxlwm3wHVmjvZ2uOfOsc2W/2nSGGicTO/e6YxibxsGL/em4xgiQgMwpF+4TBVJq2eP7hg3YmCTZba2Nrh38m0md+90RJ3/Cv6fQqEwpvvt27dj9OjRcHFxgaenJ6ZPn47c3P81Me7YsQNjx46Fq6srXFxcEBcX1+bU0bW1tXjjjTcwYsQIuLq6wt7eHuHh4UhMTIRW23ymOwD4+eefsXDhQgwdOhTe3t6ws7ODr68v7r33XqSnp7d6rm+//RZ33nknunfvDhsbG3h4eCAiIgJz5syRfb75H9N/Q21dPXy6e6BPrwBZa6HO564JI9FN0/DpXAHg3sm3mXzrYGfWK8gPIwb/79P54KgwRIYFyleQxBpu/f3fp3MnR3vE3wStMtcbP3wQ/Lz/10V81+0j4N5VWmWELgKAAEBYv369AEDo0aOHMHDgQMHBwUEAIPj6+goXL14UVq9eLQAQfHx8mqz39vYWLl682Oy4paWlwsCBAwUAglKpFAICAoSoqCjBzs5OACD4+/sLubm5zfYLCQkRAAju7u5CZGSkMHDgQMHDw0MAIKjVauGLL75ots+bb75pvA4PDw9h0KBBQkREhODs7CwAEB599FGr/Nu1R+W1auGF1zcJC1/dKJzMypOtDurccvKKhIWvbhR27v9J7lJkUVtXL6x6Z4vw6oZPheqaWrnLkcWe1CMN7yPZeXKXIouL2jLh+VXvCh9u/U4wGAxyl2MxXWYAZmO6dXR0xIYNG/Dggw8CAC5fvoxJkyYhPT0dU6ZMwb59+/D2228b11+6dAl33HEHjh49ioULF+LVV181HlMQBIwbNw6HDh3C5MmTsX79egQGBgJouCUrISEBmzZtwvDhw/Gf/zSdOvajjz7CiBEjmtyeZTAY8M033+DBBx+EWq1GYWEhnJ2dAQA6nQ7du3dHWVkZ3nrrLTzyyCPG0biCICA1NRWXLl3CtGmmT7O77sMvcbWy2uT9rldbV4faunoolcpO/cwAkl9dfT1s1Oqb6hPp9fR6PQQAaolH23cUgiCgvl4HW1sbuUuRTV29DmqVCkplx/oZ0Dg74PHZfzJr3y4XJh5//PFmj1/97rvvEBsb2+r6Xbt24c4770S/fv1w/Phx4/Jvv/0WkydPRt++fZGeng57e/sm++n1ekRHR+PYsWP48ccf2/2UusWLF2PZsmVISUnBfffdB6Dh0d8+Pj5wc3PD5cuXTbv4G3jlzU9QUVll0WMSEVHX4uLshEWPzTJr3y43adVf//rXZssGDRrUrvXnzjWdWGXr1q0AGu5Z/mOQAACVSoW77roLx44dw8GDB5uFiZycHPz73//G8ePHcenSJdTX1wMALl68CADIyMgwhgkvLy/Y29vjypUr2LNnDyZMmNDua74RjbO4lgS2ShARdX1ifld0uTAREhLSbJmXl1eb67t37w6goevieidOnAAAvP/++/j6669bPF/jswDOnz/fZPlrr72GZ555BjqdrtVaL126ZPxapVIhISEBy5cvx8SJEzFo0CDExMRg1KhRGDt2LFxczB+kY26zFdBwB8eKt1MAALPiYm6qAWNERNQ+Xa6bo7XLMWd9r1692j0D5PUzrqWlpWHUqFFQqVRYunQp4uLiEBgYCCcnJygUCmzatAlz585tNkubwWDAW2+9hTfffBNnzpwxLrezs8Of//xnrFq1Cu7u7u2q53pixkywVYKI6OYgZsxEl2uZsKTGwZHbtm3D1KlT273f5s2bAQALFixo8elt17dIXE+pVGL+/PmYP38+ioqKkJqaij179uCzzz7D+++/j8LCQuzZs8fk67haWS16zITBYOC4CyIiahHDRBsiIyORkZGBkydPmhQm8vLyAACjRrU869/hwzeePdLPzw8zZ87EzJkzsWDBAkRFRWHv3r3Iy8tDUJBpMwaa2w/GVgkiopsHx0xYyfTp0/HJJ5/gnXfeweOPP25sqbgRB4eGb0jjE+yul5OTgx07dphUR2RkJLp164YrV66guLjY5DBhTrMVx0oQEVF7dZkZMK0hLi4OY8eORX5+PiZOnIiTJ082WW8wGPDTTz9h3rx5Te4EGT16NAAgOTm5ycybp06dwtSpU1ucOvX06dN4+OGHcfjw4SbjNvR6PdasWYMrV67A3t4ekZEtz29vaZztkoiI2osDMG+wXqvVIi4uzjgpVUBAALy9vVFdXY3c3FxUVTWMI8jMzETv3g2PEL569SoGDRqEs2fPwsbGBuHh4TAYDMjMzISPjw/+/ve/4/nnn28yADMjIwMDBzbM267RaBASEgKVSoX8/HzjGIu33noLf/vb38z69zFFY6tEbV09Hpg2ka0SRETUJrZM3ICnpycOHTqEDz74ABMmTEBVVRWOHDmCvLw8hIaGIiEhAYcOHUJYWJhxH41Ggx9//BFz5syBm5sbsrKyUFlZiUcffRTHjh2Dr69vs/OEhYXh3XffxYwZM+Dj44Nz587h+PHjsLe3xz333IPU1FRJggQA1NTWwb9Hd7ZKEBFRu3SZlgmyvJraupvqQUxERGQehgkiIiIShd0cREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESiMEwQERGRKAwTREREJArDBBEREYnCMEFERESi/B+OdETGpfXXtAAAAABJRU5ErkJggg==", "text/plain": [ - "

" + "\"Output" ] }, "execution_count": 7, @@ -295,12 +290,12 @@ " qc.x(i)\n", "\n", "\n", - "# make a copy of the above circuit. (to be used when we apply the QFT in next part) \n", - "qc_qft = qc.copy() \n", + "# make a copy of the above circuit. (to be used when we apply the QFT in next part)\n", + "qc_qft = qc.copy()\n", "\n", "\n", "qc.measure_all()\n", - "qc.draw('mpl')\n" + "qc.draw(\"mpl\")" ] }, { @@ -311,9 +306,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 8, @@ -322,7 +316,6 @@ } ], "source": [ - "\n", "# Step 2: Transpile\n", "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", "\n", @@ -333,20 +326,20 @@ "\n", "# Step 3: Run the job on a real quantum computer OR try fake backend\n", "\n", - "sampler = Sampler(mode = backend)\n", + "sampler = Sampler(mode=backend)\n", "pubs = [qc_isa]\n", "\n", "# Run the job on real quantum device\n", "\n", - "job = sampler.run(pubs,shots=1000) \n", + "job = sampler.run(pubs, shots=1000)\n", "res = job.result()\n", "counts = res[0].data.meas.get_counts()\n", "\n", "# OR Run the job on the Aer simulator with noise model from real backend\n", "\n", - "#job = sampler_sim.run([qc_isa])\n", - "#res = job.result()\n", - "#counts = res[0].data.meas.get_counts()\n", + "# job = sampler_sim.run([qc_isa])\n", + "# res = job.result()\n", + "# counts = res[0].data.meas.get_counts()\n", "\n", "# Step 4: Post-Process\n", "plot_histogram(counts)" @@ -368,9 +361,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 9, @@ -381,9 +373,9 @@ "source": [ "# Step 1: Map\n", "\n", - "qc_qft.compose(QFTGate(qubits),inplace=True)\n", + "qc_qft.compose(QFTGate(qubits), inplace=True)\n", "qc_qft.measure_all()\n", - "qc_qft.draw('mpl')" + "qc_qft.draw(\"mpl\")" ] }, { @@ -394,9 +386,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 10, @@ -415,20 +406,20 @@ "\n", "# Step 3: Run the job on a real quantum computer - try fake backend\n", "\n", - "sampler = Sampler(mode = backend)\n", + "sampler = Sampler(mode=backend)\n", "pubs = [qc_isa]\n", "\n", "# Run the job on real quantum device\n", "\n", - "job = sampler.run(pubs,shots=1000) \n", + "job = sampler.run(pubs, shots=1000)\n", "res = job.result()\n", "counts = res[0].data.meas.get_counts()\n", "\n", "# OR Run the job on the Aer simulator with noise model from real backend\n", "\n", - "#job = sampler_sim.run([qc_isa])\n", - "#res = job.result()\n", - "#counts = res[0].data.meas.get_counts()\n", + "# job = sampler_sim.run([qc_isa])\n", + "# res = job.result()\n", + "# counts = res[0].data.meas.get_counts()\n", "\n", "# Step 4: Post-Process\n", "plot_histogram(counts)" @@ -449,7 +440,7 @@ "\n", "#### Two computational basis states\n", "\n", - "Now, let's see what happens when we prepare a superposition of computational basis states. What do you think the Fourier transform will look like in this case? \n", + "Now, let's see what happens when we prepare a superposition of computational basis states. What do you think the Fourier transform will look like in this case?\n", "\n", "Let's choose the superposition:\n", "\n", @@ -464,9 +455,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 11, @@ -484,16 +474,15 @@ "\n", "# to make this state, we just need to apply a hadamard to the last qubit\n", "\n", - "qc.h(qubits-1)\n", + "qc.h(qubits - 1)\n", "\n", "\n", "qc_qft = qc.copy()\n", "\n", "\n", - "\n", "qc.measure_all()\n", "\n", - "qc.draw('mpl')" + "qc.draw(\"mpl\")" ] }, { @@ -504,9 +493,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 12, @@ -527,23 +515,23 @@ "\n", "# Step 3: Run the job on a real quantum computer - try fake backend\n", "\n", - "sampler = Sampler(mode = backend)\n", + "sampler = Sampler(mode=backend)\n", "pubs = [qc_isa]\n", "\n", "# Run the job on real quantum device\n", "\n", - "job = sampler.run(pubs,shots=1000) \n", + "job = sampler.run(pubs, shots=1000)\n", "res = job.result()\n", "counts = res[0].data.meas.get_counts()\n", "\n", "# OR Run the job on the Aer simulator with noise model from real backend\n", "\n", - "#job = sampler_sim.run([qc_isa])\n", - "#res = job.result()\n", - "#counts = res[0].data.meas.get_counts()\n", + "# job = sampler_sim.run([qc_isa])\n", + "# res = job.result()\n", + "# counts = res[0].data.meas.get_counts()\n", "\n", "# Step 4: Post-Process\n", - "plot_histogram(counts)\n" + "plot_histogram(counts)" ] }, { @@ -562,9 +550,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 13, @@ -573,11 +560,11 @@ } ], "source": [ - "# Step 1: Map \n", + "# Step 1: Map\n", "\n", - "qc_qft.compose(QFTGate(qubits),inplace=True)\n", + "qc_qft.compose(QFTGate(qubits), inplace=True)\n", "qc_qft.measure_all()\n", - "qc_qft.draw('mpl')" + "qc_qft.draw(\"mpl\")" ] }, { @@ -588,9 +575,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 14, @@ -599,7 +585,6 @@ } ], "source": [ - "\n", "# Step 2: Transpile\n", "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", "\n", @@ -610,20 +595,20 @@ "\n", "# Step 3: Run the job on a real quantum computer OR try fake backend\n", "\n", - "sampler = Sampler(mode = backend)\n", + "sampler = Sampler(mode=backend)\n", "pubs = [qc_isa]\n", "\n", "# Run the job on real quantum device\n", "\n", - "job = sampler.run(pubs,shots=1000) \n", + "job = sampler.run(pubs, shots=1000)\n", "res = job.result()\n", "counts = res[0].data.meas.get_counts()\n", "\n", "# OR Run the job on the Aer simulator with noise model from real backend\n", "\n", - "#job = sampler_sim.run([qc_isa])\n", - "#res = job.result()\n", - "#counts = res[0].data.meas.get_counts()\n", + "# job = sampler_sim.run([qc_isa])\n", + "# res = job.result()\n", + "# counts = res[0].data.meas.get_counts()\n", "\n", "# Step 4: Post-Process\n", "plot_histogram(counts)" @@ -642,20 +627,20 @@ "
\n", "\n", "\n", - "Using the hint above, explain why the result we got for the QFT of $|\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |N/2\\rangle)$ is expected. \n", + "Using the hint above, explain why the result we got for the QFT of $|\\psi\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + |N/2\\rangle)$ is expected.\n", "\n", "\n", "\n", "__Answer:__\n", "\n", - "The original state has a relative phase of 0 (or an integer multiple of $2\\pi$) between the two parts of the superposition. So, we know this state has Fourier components whose phases also match up in that way: i.e. the ones that have 0 phase shift between the |0000> term and the |1000> term. Each Fourier basis state $|\\phi_y\\rangle$ is composed of terms whose phase accumulates at a rate of $2\\pi y/N$, meaning when ordered in the usual way, each term in the superposition has a phase of $2\\pi y/N$ greater than the term that came before. So, at the halfway point $N/2$, we want the phase $2\\pi y/N * N/2$ to be an integer multiple of $2\\pi$. This happens when $y$ is even. \n", + "The original state has a relative phase of 0 (or an integer multiple of $2\\pi$) between the two parts of the superposition. So, we know this state has Fourier components whose phases also match up in that way: i.e. the ones that have 0 phase shift between the |0000> term and the |1000> term. Each Fourier basis state $|\\phi_y\\rangle$ is composed of terms whose phase accumulates at a rate of $2\\pi y/N$, meaning when ordered in the usual way, each term in the superposition has a phase of $2\\pi y/N$ greater than the term that came before. So, at the halfway point $N/2$, we want the phase $2\\pi y/N * N/2$ to be an integer multiple of $2\\pi$. This happens when $y$ is even.\n", "\n", "
\n", "
\n", "\n", "\n", - " \n", - "What computational state superposition would correspond to a QFT with peaks on every odd binary number? \n", + "\n", + "What computational state superposition would correspond to a QFT with peaks on every odd binary number?\n", "\n", "\n", "\n", @@ -663,8 +648,7 @@ "\n", "If you took the QFT of the state $\\psi = |0\\rangle - |N/2\\rangle$, then you would see peaks on every odd binary numbered state.\n", "\n", - "
\n", - "\n" + "" ] }, { @@ -674,7 +658,7 @@ "source": [ "## Breaking down the QFT Algorithm\n", "\n", - "Now that we've gained more intuition into the relationship between qubit states in the computational basis and the Fourier basis, let's dig into the QFT algorithm itself. In other words, what gates do we actually implement on the quantum computer to achieve this transform? \n", + "Now that we've gained more intuition into the relationship between qubit states in the computational basis and the Fourier basis, let's dig into the QFT algorithm itself. In other words, what gates do we actually implement on the quantum computer to achieve this transform?\n", "\n", "Let's start small, with a single qubit. So, that means we'll have 2 basis states. QFT$_2$ transforms computational basis states $|0\\rangle$ and $|1\\rangle$ into Fourier basis states $\\phi_0$ and $\\phi_1$:\n", "\n", @@ -692,7 +676,7 @@ "Use the equation for the QFT in the previous section to verify these two Fourier basis states above.\n", "\n", "\n", - " \n", + "\n", "__Answer:__\n", "\n", "The general QFT formula is:\n", @@ -714,29 +698,29 @@ "\n", "$$ \\text{QFT}_N = \\frac{1}{\\sqrt{N}} \\sum_{x=0}^{N-1} \\sum_{y=0}^{N-1} \\omega_N^{xy} \\vert x \\rangle \\langle y \\vert$$\n", "\n", - "If you're not familiar with this notation for expressing a quantum operator, that's okay! It is a way to represent an $N \\times N$ matrix, where $x$ and $y$ index the columns and rows of the matrix, from $0$ to $N-1$, and $\\omega_N^{xy}$ is the value of that particular entry. So, the entry in the 0th column and 2nd row, for example, would just be $\\omega_N^{0,2} = e^{2 \\pi i \\frac{0 \\times 2}{N}} = 1$. \n", + "If you're not familiar with this notation for expressing a quantum operator, that's okay! It is a way to represent an $N \\times N$ matrix, where $x$ and $y$ index the columns and rows of the matrix, from $0$ to $N-1$, and $\\omega_N^{xy}$ is the value of that particular entry. So, the entry in the 0th column and 2nd row, for example, would just be $\\omega_N^{0,2} = e^{2 \\pi i \\frac{0 \\times 2}{N}} = 1$.\n", "\n", "In this representation, each of the computational basis states is associated with one of the basis vectors:\n", "\n", - "$$|0\\rangle = \n", + "$$|0\\rangle =\n", "\\begin{pmatrix}\n", "1 \\\\ 0 \\\\ \\vdots \\\\ 0\n", "\\end{pmatrix},\n", - "|1\\rangle = \n", + "|1\\rangle =\n", "\\begin{pmatrix}\n", "0 \\\\ 1 \\\\ \\vdots \\\\ 0\n", "\\end{pmatrix},\n", - "|N-1\\rangle = \n", + "|N-1\\rangle =\n", "\\begin{pmatrix}\n", "0 \\\\ 0 \\\\ \\vdots \\\\ 1\n", "\\end{pmatrix}.\n", "$$\n", "\n", - "If you'd like to learn about this representation in more depth, see John Watrous's lesson on multiple systems in the [Basics of Quantum Information](/learning/courses/basics-of-quantum-information/multiple-systems) course.\n", + "If you'd like to learn about this representation in more depth, see John Watrous's lesson on multiple systems in the [Basics of Quantum Information](/learning/courses/basics-of-quantum-information/multiple-systems/introduction) course.\n", "\n", "Lets try to construct the matrix for QFT$_4$. Using the above formula, we find that\n", "\n", - "$\\text{QFT}_4 = \\frac{1}{2} \n", + "$\\text{QFT}_4 = \\frac{1}{2}\n", "\\begin{pmatrix}\n", " 1 & 1 & 1 & 1 \\\\\n", " 1 & i & -1 & -i \\\\\n", @@ -747,7 +731,7 @@ "\n", "To implement this matrix on a quantum computer, we'll need to figure out which combination of gates applied to which qubits will give us a unitary transformation that matches the matrix above. We already know one of the gates that will be needed: the Hadamard. Another gate we'll need is the controlled-phase gate, which applies a relative phase $\\alpha$ to the target qubit's state, as long as the control qubit is in the state $|1\\rangle$. In matrix form this looks like:\n", "\n", - "$\\text{CP}_\\alpha = \n", + "$\\text{CP}_\\alpha =\n", "\\begin{pmatrix}\n", " 1 & 0 & 0 & 0 \\\\\n", " 0 & 1 & 0 & 0 \\\\\n", @@ -760,7 +744,7 @@ "\n", "Finally, we'll need some SWAP gates too. A SWAP gate swaps the states of two qubits. It looks like:\n", "\n", - "$\\text{SWAP}_\\alpha = \n", + "$\\text{SWAP}_\\alpha =\n", "\\begin{pmatrix}\n", " 1 & 0 & 0 & 0 \\\\\n", " 0 & 0 & 1 & 0 \\\\\n", @@ -769,7 +753,7 @@ "\\end{pmatrix}\n", "$\n", "\n", - "The procedure to construct a QFT$_{2^m}$ circuit on $m$ qubits is iterative — you first apply QFT$_{2^{m-1}}$ to qubits $1$ through $m-1$, then add some gates between qubit $0$ and the other $m-1$ qubits. But to apply QFT$_{2^{m-1}}$, you first need to apply QFT$_{2^{m-2}}$ to qubits 2 through m-1, then add some gates between qubit 1 and the remaining qubits $2$ through $m-1$. It's like a Russian nesting doll: each doll adds a factor of two in the dimension of the QFT circuit, with the smallest doll at the very center, being QFT$_2$, or the Hadamard gate. \n", + "The procedure to construct a QFT$_{2^m}$ circuit on $m$ qubits is iterative — you first apply QFT$_{2^{m-1}}$ to qubits $1$ through $m-1$, then add some gates between qubit $0$ and the other $m-1$ qubits. But to apply QFT$_{2^{m-1}}$, you first need to apply QFT$_{2^{m-2}}$ to qubits 2 through m-1, then add some gates between qubit 1 and the remaining qubits $2$ through $m-1$. It's like a Russian nesting doll: each doll adds a factor of two in the dimension of the QFT circuit, with the smallest doll at the very center, being QFT$_2$, or the Hadamard gate.\n", "\n", "To put a doll inside the next biggest size doll, hence increasing the dimension of the QFT by a factor of two, you always follow the same procedure:\n", "\n", @@ -790,9 +774,8 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAABuCAYAAACk2MjUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAEgElEQVR4nO3dz0vbdxzH8VfSssYf8VBdl4mu1dmw2poIisPDGDo9uOJp0EspPbijWJiYP6CXLtBT6cXjTpKeBjNXWRHZIBIEcVJBiGj1y/iiF611RL87bbA27TRav+98eT6Ofj/x8z48+X4S9Yshz/M8AT4L+z0AIBEijCBEmECIMIEQYQIhwgRChAmECBMIESYQIkwgRJhAiDCBEGECIcIEQoQJhAgTCBEmECJMIESYQIgwgRBhAiHCBEKECYQIEwgRJhAiTCBEmECIMIEQYQIhwgRChAmECBMIESYQIkwgRJhAiDCBEGHCRb8HCDLP86SDA7/HOJlLlxQKhc59W0L8kA4OVLxz3+8pTuTis5+kSOTc9+VohgmECBMIESYQIkwgRJhAiDCBEGECIcIEQoQJhAgTCBEmECJMIESYELgQXddVKpVSW1ubIpGImpub9eDBA+3t7WlkZEShUEhPnz71e0y8IVB/BrawsKChoSE5jqOamhq1t7drc3NTT5480erqqra3tyVJnZ2d/g56Qs/dPzX426/6sT2hHz7/ouSaj355pm+vfKqfv/zqnKc7G4G5I7quq+HhYTmOo/HxcW1tbSmfz8txHKXTaWWzWeVyOYVCISUSCb/HxRsCE+LY2Jg2NjY0Ojqqx48fKxqN/nstlUopmUyqWCzq2rVrqqur83FSlBKIEJeXl5XJZNTQ0KBHjx6VXNPV1SVJSiaT5zkajikQ7xGnpqZ0dHSku3fvqra2tuSaqqoqSZUd4qvDQ7mV9gzMMQUixJmZGUlSX1/fO9dsbGxIquwQH75Y0sMXS36P8UEEIsS1tTVJ0tWrV0teLxaLmpubk3S6ELu7u+U4zrHXV4XD+qOzt+z93vT9Z636rrG55LWh35+fyR7xeFz7R0dlvTYWi2l+fr6s1wYixL29PUnS/v5+yeuZTEau6yoajaqlpaXsfRzH0cuXL4+9vvrCBamz7O3e0lZbq28+/uTsvmEJm5ubenV4+EH3KCUQIcZiMe3s7Cifz6u39793oK2tLU1MTEiSEonEqZ7ZjcViJ1pfFa68z4KNjY2nuiOWKxAhDgwMaHl5Wel0WoODg4rH45KkXC6ne/fuyXVdSaf/QfZJjx3v9euKe655ZWVFIZ5rLk8qlVJ9fb3W19d18+ZNdXR06Pr16+rp6VFra6v6+/slVfYHlaALRIhNTU2anZ3V7du3FYlEVCgUdPnyZU1OTiqbzWplZUUSIVoWiKNZkm7cuKHp6em3vr67u6tCoaBwOKxbt275MBmOIzAhvsvS0pI8z1M8Hld1dbXf45Tl64Yr+mv4znvX/N916wJxNL/P4uKiJI5l6wgRJhAiTAj8e8R/fg8N2wJ/R0RlIESYQIgwgRBhAiHCBEKECYQIEwgRJhAiTCBEmECIMCHkeZ7n9xBBxT+FPD5ChAkczTCBEGECIcIEQoQJhAgTCBEmECJMIESYQIgwgRBhAiHCBEKECYQIEwgRJhAiTCBEmECIMIEQYQIhwgRChAmECBMIESYQIkwgRJhAiDDhb1+BCUFmootuAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 15, @@ -802,8 +785,8 @@ ], "source": [ "qc = QuantumCircuit(1)\n", - "qc.compose(QFTGate(1),inplace=True)\n", - "qc.decompose().draw('mpl')" + "qc.compose(QFTGate(1), inplace=True)\n", + "qc.decompose().draw(\"mpl\")" ] }, { @@ -814,9 +797,8 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAACuCAYAAABTEIhIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAULUlEQVR4nO3de1CV953H8feDIheBIHghgoqKGFQujUaRNheMdte7nYSYxiZuo+N2t1ntrCPJNDub1p3U1TixsaYd0zab7DbDQMylEePaGC8xrsFbiK4iLEaMgCfpUVREIQJn/ziBhHhQOJ7D4ffwec0wI5znefgyI7zPcznPsVwulwsRERFDBQV6ABERkVuhkImIiNEUMhERMZpCJiIiRlPIRETEaAqZiIgYTSETERGjKWQiImI0hUxERIymkImIiNEUMhERMZpCJiIiRlPIRETEaAqZiIgYTSETERGjKWQiImI0hUxERIymkImIiNEUMhERMZpCJiIiRlPIRETEaAqZiIgYTSETERGjKWQiImI0hUxERIymkImIiNEUMhERMZpCJiIiRlPIRETEaAqZiIgYTSETERGjKWQiImI0hUxERIymkImIiNEUMhERMZpCJiIiRlPIRETEaL0DPYCIiCculwsaGgI9RseFhGBZVqCn6JEUMhHpnhoaaHxoYaCn6LDeBa9CaGigx+iRdGhRRESMppCJiIjRFDIRETGaQiYiIkZTyERExGgKmYiIGE0hExERoylkIiJiNIVMRESMppCJiIjRFDIRERs5XV17S+s3N7s447jso2m6hkImImITfyosZ9SsTby2pdyr9ZubXfzk3/Yyfv6fOVZe4+Pp/EchExGxgaIjX/DY07u51tjMY09/0OmYtUTs92+U8teaeqb9/X9Td+Wan6b1LduHzOl0kpubS1JSEqGhoQwZMoRly5ZRV1fHokWLsCyLDRs2BHpMsTmXC47VwG4HfPg5fHprR39ErjMxdQA/ybkDcEepMzH7ZsQAevWyWLdiEn3Dg/02ry/Z+m1ciouLmT59Og6Hg759+zJmzBiqq6tZv349J0+e5Pz58wBkZGQEdlCxrSuN8OfPYFMFnP7WaYfUfvBgIvxNPPS2/VPKwNjt/IJp+3bx72PS+OeRd3hcps/mAmYMvJ23J93dxdP5lmVZvPh0FgC/KzjRGjOABTOT2l3PU8ReW3Uf8/92hP+H9hHbhszpdDJ79mwcDgfLly/nmWeeITIyEoA1a9bw5JNP0rt3byzLIi0tLcDTih0562HpR1B2yfPjR2vcH9urYdV4CLXtb6N0lc7GzA4RAxsfWly6dCmVlZU88cQTrF27tjViALm5uaSnp9PY2EhiYiJRUVEBnFTsqK7xxhH7pj2fw9OHocnl/7nE/lpi9g8P3fgwo10iBjYNWUlJCfn5+fTv359Vq1Z5XGb8+PEApKent/n6qVOnmDNnDpGRkfTr14/HHnuMc+fO+X1msZf8TzsWsRYt585EfOFmMbNTxMCmhxbz8vJobm5mwYIFREREeFwmLCwMaBuy2tpasrOziYmJIS8vj6tXr5Kbm8usWbPYu3cvQUG27L74WJML3jzd+fU2nYJ743w/j8CVpiacDQ2BHqNLtXeYsbkZ9hx22CZiYNOQ7dixA4Ds7Ox2l6msrATahuyll16iqqqKDz74gKFDhwKQkJBAVlYW77zzDvPmzfPf0GIbh5zguNr59fb91X1erX+o72fq6VaWHmNl6bFAj9HlPMVs4dO7aTmKbYeIgU1Ddvq0++nwsGHDPD7e2NjI3r17gbYhKyws5Hvf+15rxAAmT57MiBEj2Lx5s9chmzBhAg6Hw6t1xTxhmTnc9tg6r9adcP9MGk9/4uOJzBQWFMTxjMk+2dbioSN4YPAQj49N/2i3T75HcnIyV5ubfbItX3MB4eGzuBJ6V2vEcLmIuljA8sX/yvIAztYiLi6OgwcPerWuLUNWV1cHwNWrnp8W5+fn43Q6iYyMZPjw4a1fP378ODk5OdctP3bsWI4fP+71PA6Hg6qqKq/XF7PE1tRwm5fr/vWLz7mi/ysAhPfqBRm+2VZSRAT3Dxjkm421o7q6mitNTX79Ht6zIP4KfGtvv6bmIjUXzP//ZsuQxcXFUVNTw+HDh5k8ue0zurNnz7JixQoA0tLSsCyr9bGamhqio6Ov215MTAylpaW3NI/0HH1cV7xaz9XcTGxwM/3i4308kZnCDDsnPXjw4G65R+bC4kL4LK6ETvjqCy6wLPdHwiL69etH+JdHAzskt/Z30pYhmzp1KiUlJaxevZpp06aRnJwMwIEDB3j00UdxOp1A170Q2tvdZTFTkwvmbYeznTxP9t24INYfP+yfoQzkqq+n8aGFgR6jw8rKyrBCu9cJTk9XJ0aGB3Oh9qtbT1lBXIzK4TfP/uaGL5ru7sx6ytNBubm5xMbGcubMGcaOHUtqaiqjRo1i4sSJjBgxgilTpgDXX3rfr18/Lly4cN32zp8/T0xMTFeMLjbQy4IHEju/Xo4X64i0p71L7PuGuW871Tesd+ty3tybsTuxZcgSEhLYs2cPM2fOJDQ0lIqKCmJiYti4cSNbtmyhrKwMuD5kKSkpHs+FHT9+nJSUlC6ZXezhoeFwRydOlE25Hb7r31M40oN05HVit0UE3/RF06awZcjAHaXCwkJqa2upra2lqKiIJUuWUFdXR0VFBUFBQYwbN67NOrNmzeLDDz9svTQfoKioiJMnTzJ79uyu/hHEYOG94YVJMCb65stmx8HKOyHIuvmyIjfT0Rc7d/QOICawXC5Xj7oxTlFREZmZmYwePZoTJ060eezSpUukpqbSv39/fvnLX1JfX09ubi4DBgxg3759ekG0dFp9IxSegYKK6+94f2es+xDk1MHuw5HSlmnnyHoXvBrwc2QdiVjC1DyqvrhC/MBwKrf/EJfLxU+f/R9+V+D+exgUZPGfz95j1DmzHveX+ehR99U53z6sCBAVFcWOHTu4/fbbefjhh1m8eDFZWVkUFhYqYuKV0N7w4HDIvw9euxdaemUBL33Xfed7RUx8wdvbTtlhz8yWVy3eyI1CBjBy5EgKCwu7ciTpASwLRt/mDpiLr4Mm4isHjzn541vu8/+dvWOHpzuAPLnuAPOyhxnxnmQ9bjfjZiETETHRxNQBvLbqXvoEB3l126lv7pkNig1j+++nGxEx6IF7ZC33YRQRsZuHp4/k7jvjiB/U16v1W2L2L0syGDzQu20EQo/bIxMRsTNvI9bCsiyjIgYKmYiIGE4hExERoylkIiJiNIVMRESMppCJiIjRFDIRETGaQiYiIkZTyERExGgKmYiIGE0hExERo/W4ey2KiCFCQuhd8Gqgp+i4kJBAT9BjKWQi0i1ZlgUBfqNKMYMOLYqIiNEUMpFuKjExkdGjR5ORkcGYMWN48cUX2102JyeHffv2dWi7mzZt4sc//jHz5s0jOTmZ9PR0pk2bRnn51+8IfPfdd3Pq1Klb/hlEuoJCJtKN5efnU1xczNatW/n5z3/OkSNHrltm//79nD9/nsmTJ3dom2+99Rbz5s1jyZIllJaW8sknnzB37lwWL17cuszy5ct55plnfPZziPiTQiZigGHDhjF69GjKysque2zjxo088sgjAFy4cIGEhARiY2PJyMggJSWFkJCQ1khdu3aNvXv3MmPGDGbMmOE+DwVkZmZSUVHRus2ZM2eydetWLl686P8fTuQWKWQiBjh69CgnTpwgPT39usd27drFpEmTAIiOjuaRRx7hZz/7GcXFxfz6178mMzOTP/zhDwDs3LmTrKwsgoPbvoX9Cy+8wNy5c1s/Dw4OJjU1lT179vjxpxLxDV21KNKNzZ8/n7CwMMLDw3n55ZcZNWrUdctUVlYyaNCg1s+Li4tZunQpAIcOHeI73/lO62Nvv/02P/jBD9qs/6tf/Yry8nLef//9Nl+Pi4ujsrLSlz+OiF8oZCLdWH5+PhkZGTdcJjw8nPr6+tbPi4uLW+N16NAh5syZA4DL5WLbtm2sWbOmddm1a9fy5ptvsn37dsLDw9tst76+nrCwMB/9JCL+o0OLIoZLS0ujtLQUgKqqKizLIj4+HoAjR46QmpoKuC8KSUlJISIiAoDnn3+evLw83nvvPaKjo6/bbklJicdDmSLdjUImYrgHH3yQbdu2AfDxxx+3OZQYHR3Nb3/7W+DrqxXBfThy+fLlXLhwgezsbDIyMlrPswFUVFTQ1NSkkIkRLJfL5Qr0ECI9xcR3oBn3M8j9c3yzzcuXL5OVlcW+ffvo27dvu8uNHTuWnTt3MnDgwJtu86mnniIpKanNJfliDwlT86j64grxA8Op3P7DQI/jE9ojEzFcREQE69atu+kLmI8dO9ahiAEMHjyYxx9/3BfjifidLvYQsYH777/fp9truepRxATaIxMREaMpZCIiYjSFTEREjKaQiYiI0RQyERExmq5a7IZcLhc0NAR6jM4JCWm9k7qISFdSyLqjhgYaH1oY6Ck6pXfBq3pbehEJCB1aFBERoylkIiJiNIVMRESMppCJiIjRFDIRETGaQiYiIkZTyERExGgKmYiIGE0hExERoylkIiJiNIVMRESMppCJiNhEpaOOGf+4jarP67zexvsfVbPgqV1cu9bsw8n8SzcNFhGxgUpHHfct2sLJM7Xct+hddv1xBvGD+nZqG+9/VM2sf/oL9Q1NXG1oJH/NFIKDu//+Tvef0AecTie5ubkkJSURGhrKkCFDWLZsGXV1dSxatAjLstiwYUOgxxQR8ZoLV+u/yz+7xH2L3u3Untk3IwbgcrXdZndm+5AVFxeTmprKc889h8PhYMyYMVy7do3169czf/58SkpKAMjIyAjsoH6w2/kFfTYX8PzJE+0u02dzAfOK9nThVD1PTQO88n8wfye0HKxpBt46DVcbAzmZ2MmQuAh2/nEGI4dEAp2L2bcjNm/KMPKfy6ZPcC+/zuwrtg6Z0+lk9uzZOBwOli9fztmzZzl8+DAOh4PVq1ezZcsWDhw4gGVZpKWlBXpcsRmXyx2wGe/BhhI4Wdv28Wc/gel/ge3VgZlP7MebmJkeMbB5yJYuXUplZSVPPPEEa9euJTIysvWx3Nxc0tPTaWxsJDExkaioqABOKnb0Yok7YDc6Z365EZ46CFvOdN1cYm+diZkdIgY2DllJSQn5+fn079+fVatWeVxm/PjxAKSnp7d+rSV8EydOJCQkBMuyumResZc9DnilvOPLryyG05f9No70MB2JWf2XTbaIGNg4ZHl5eTQ3N7NgwQIiIiI8LhMWFga0DVl5eTlvvPEGcXFx3HXXXV0yq79daWrC2dDg8UP8I+/Tzi3f5IJNFX4ZRXqo9mLW1OQ+RHDuQoMtIgY2vvx+x44dAGRnZ7e7TGVlJdA2ZPfccw9nz54F4Be/+AV79+7145RdY2XpMVaWHgv0GD3G6cuw39n59TZ/Bj+9A0Jt+1spXa0lZtmL3uXkmVrKP7tEUFDbo0ymRwxsHLLTp08DMGzYMI+PNzY2tkbqmyELCvL9TuqECRNwOBwdXj4sKIjjGZN99v0XDx3BA4OHeHxs+ke7ffI9kpOTudpszgso/Sl0wlyiH3+x0+tdboQ7sqbSWN3+VaYi3mgMiqJX5N/R1CuW5uavL6kP/bKE/ZtWMmJTUwCnc4uLi+PgwYNerWvbkNXVuY8FX7161ePj+fn5OJ1OIiMjGT58uF9ncTgcVFVVdXj58F69IMN33z8pIoL7Bwzy3QY9qK6u5kpT4H8ZuoPYMQ1Ee7mu8+Jl6jrxf0WkY6ogahMMXQIt5/1dLuo/fYXqa+cCO5oP2DZkcXFx1NTUcPjwYSZPbrt3c/bsWVasWAFAWlqa3y/oiIuL69TyYX7YK/S3wYMHa4/sKyEh3h+iiY0IITo+3ofTiEB97+Gci1zwdcQALIteo3IZcOk/6OWqbX/lLtLZv5PfZNuQTZ06lZKSElavXs20adNITk4G4MCBAzz66KM4ne6TGF3xQujO7i676utpfGihn6bxj7KyMqzQ0ECP0S1c+BJm/AW+7GTX48Nh/8HdBOlCWfGhlkvs+erCju9nxVP+2SU+raylqVcsEekrvbqdVXdi3lP/DsrNzSU2NpYzZ84wduxYUlNTGTVqFBMnTmTEiBFMmTIFaHt+TMQXovvA973YqXowEUVMfMrT68Q2/2Yau1727g4g3ZVtQ5aQkMCePXuYOXMmoaGhVFRUEBMTw8aNG9myZQtlZWWAQib+8aOR0KcTv139Q2D2UP/NIz3PjV7sfCu3s+qObBsygJSUFAoLC6mtraW2tpaioiKWLFlCXV0dFRUVBAUFMW7cuECPKTaUFAWrJkBHbhx+WzC8kOnekxPxhY7cscNOMbNcLpcZtzf2oaKiIjIzMxk9ejQnTlx/qfOmTZsAKCgo4PXXX+f1118HIDExkQkTJvh9PhPPkfUueFXnyDw4fA7W/S+UXPT8+KQBkJsKwzy/Zl+k0zp726kzjsutrzMDSBoaZdw5M9te7HEjR48eBdo/rJiTk+Px84ULF/LKK6/4dTaxlztj4b/uhWM1sLUSnA3u82Dx4TB7CAxVwMSHvLl3oqcXTXv7fmaBopB50AN3UsXPxvZzf4j4y+HjTq/vnegpZtmL3+Xj/Hn0DQ/29+i3zNbnyNpzs5CJiJhm3Kh+fH+y+3JZb2479e1zZj/JucOIiEEPPUfW3ekcmYh448trTbzwp2Ms+9FYr++deMZxmW17q1j8wGgfT+c/Clk3pJCJiHRcjzy0KCIi9qGQiYiI0RQyERExmkImIiJGU8hERMRoCpmIiBhNIRMREaMpZCIiYjSFTEREjKaQiYiI0XSLqm7I5XJBQ0Ogx+ickBAsywr0FCLSAylkIiJiNB1aFBERoylkIiJiNIVMRESMppCJiIjRFDIRETGaQiYiIkZTyERExGgKmYiIGE0hExERoylkIiJiNIVMRESMppCJiIjRFDIRETGaQiYiIkZTyERExGgKmYiIGE0hExERoylkIiJiNIVMRESMppCJiIjRFDIRETGaQiYiIkZTyERExGgKmYiIGE0hExERo/0/CubzfqFL6X4AAAAASUVORK5CYII=", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 16, @@ -826,8 +808,8 @@ ], "source": [ "qc = QuantumCircuit(2)\n", - "qc.compose(QFTGate(2),inplace=True)\n", - "qc.decompose().draw('mpl')" + "qc.compose(QFTGate(2), inplace=True)\n", + "qc.decompose().draw(\"mpl\")" ] }, { @@ -838,9 +820,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 17, @@ -850,8 +831,8 @@ ], "source": [ "qc = QuantumCircuit(3)\n", - "qc.compose(QFTGate(3),inplace=True)\n", - "qc.decompose().draw('mpl')" + "qc.compose(QFTGate(3), inplace=True)\n", + "qc.decompose().draw(\"mpl\")" ] }, { @@ -862,9 +843,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "execution_count": 18, @@ -874,8 +854,8 @@ ], "source": [ "qc = QuantumCircuit(4)\n", - "qc.compose(QFTGate(4),inplace=True)\n", - "qc.decompose().draw('mpl')" + "qc.compose(QFTGate(4), inplace=True)\n", + "qc.decompose().draw(\"mpl\")" ] }, { @@ -896,7 +876,7 @@ "\n", "$\\lambda = e^{2\\pi i \\theta}$\n", "\n", - "where $\\theta$ is a real number between 0 and 1. If you would like more information on unitary matrices, see John Watrous' [lesson on the subject](/learning/courses/basics-of-quantum-information/multiple-systems) in Basics of Quantum Information.\n", + "where $\\theta$ is a real number between 0 and 1. If you would like more information on unitary matrices, see John Watrous' [lesson on the subject](/learning/courses/basics-of-quantum-information/multiple-systems/introduction) in Basics of Quantum Information.\n", "\n", "Note that $\\lambda$ is *periodic* in $\\theta$. Already, this might suggest to you that a QFT could be involved, since we saw how useful QFTs are for analyzing periodic functions. Below, we'll walk through the algorithm and see precisely how the QFT comes into play.\n", "\n", @@ -933,7 +913,7 @@ "\n", "\n", "\n", - "This more precise QPE circuit starts out the same as the single bit version: Hadamards are applied to the first $m$ qubits, and the remaining qubits are prepared in the state $|\\psi\\rangle$, creating the state: \n", + "This more precise QPE circuit starts out the same as the single bit version: Hadamards are applied to the first $m$ qubits, and the remaining qubits are prepared in the state $|\\psi\\rangle$, creating the state:\n", "\n", "$$|\\pi_1\\rangle = \\frac{1}{2^{m/2}}|\\psi\\rangle(|0\\rangle+|1\\rangle)(|0\\rangle+|1\\rangle)...(|0\\rangle+|1\\rangle)$$\n", "\n", @@ -949,18 +929,18 @@ "\n", "$$ \\text{QFT}_{2^m}| y \\rangle = \\frac{1}{\\sqrt{2^m}}\\sum_{x=0}^{2^m-1}\\omega_{2^m}^{y x} \\vert x \\rangle$$\n", "\n", - "So, if the phase $ \\theta = y/2^m $ for some integer $y$ between $0$ and $2^m-1$, then taking the inverse QFT of this state will result in the state: \n", + "So, if the phase $ \\theta = y/2^m $ for some integer $y$ between $0$ and $2^m-1$, then taking the inverse QFT of this state will result in the state:\n", "\n", "$$|\\pi_3\\rangle = |\\psi\\rangle \\otimes |y\\rangle $$\n", "\n", "and from $|y\\rangle$, we can deduce $\\theta$.\n", "\n", - "If $\\theta/2^m$ is *not* an integer multiple, however, then taking the inverse QFT will only *approximate* $\\theta$. How well it approximates $\\theta$ will be probabilistic, meaning we won't always get the best approximation, but it will be pretty close, and the more qubits $m$ you use, the better the approximation you will get. To learn about how to quantify this approximation of $\\theta$, check out John Watrous' lesson on [Phase estimation and factoring](learning/courses/fundamentals-of-quantum-algorithms/phase-estimation-and-factoring/introduction) in Fundamentals of Quantum Algorithms. \n", + "If $\\theta/2^m$ is *not* an integer multiple, however, then taking the inverse QFT will only *approximate* $\\theta$. How well it approximates $\\theta$ will be probabilistic, meaning we won't always get the best approximation, but it will be pretty close, and the more qubits $m$ you use, the better the approximation you will get. To learn about how to quantify this approximation of $\\theta$, check out John Watrous' lesson on [Phase estimation and factoring](/learning/courses/fundamentals-of-quantum-algorithms/phase-estimation-and-factoring/introduction) in Fundamentals of Quantum Algorithms.\n", "\n", "\n", "### Conclusion\n", "\n", - "Hopefully this module gave you a sense for what a QFT is, how it's implemented on a quantum computer, and how useful it can be in solving problems. We gave you a taste for its usefulness when we saw how it can be used in quantum phase estimation to learn about the eigenvalues of a unitary matrix. \n" + "Hopefully this module gave you a sense for what a QFT is, how it's implemented on a quantum computer, and how useful it can be in solving problems. We gave you a taste for its usefulness when we saw how it can be used in quantum phase estimation to learn about the eigenvalues of a unitary matrix." ] }, { @@ -984,7 +964,7 @@ "3. T/F QFT is a key component of Shor’s algorithm.\n", "4. T/F The output of Quantum Phase Estimation is a quantum state representing the eigenvector of the operator.\n", "5. T/F QPE requires the use of the inverse Quantum Fourier Transform (QFT†).\n", - "6. T/F In QPE, if the phase $\\phi$ is exactly representable with $n$ bits, the algorithm gives the correct result with probability 1. \n", + "6. T/F In QPE, if the phase $\\phi$ is exactly representable with $n$ bits, the algorithm gives the correct result with probability 1.\n", "\n", "### Short Answers\n", "1. How many qubits are needed to perform a QFT on a system with $2^n$ data points?\n", @@ -995,9 +975,9 @@ "### Problems:\n", "\n", "1. Use matrix multiplication to verify that the steps in the QFT algorithm indeed result in the $\\text{QFT}_4$ matrix:\n", - " \n", + "\n", "$$\n", - "\\text{QFT}_4 = \\frac{1}{2} \n", + "\\text{QFT}_4 = \\frac{1}{2}\n", "\\begin{pmatrix}\n", " 1 & 1 & 1 & 1 \\\\\n", " 1 & i & -1 & -i \\\\\n", @@ -1010,20 +990,10 @@ "\n", "\n", "\n", - "### Challenge problems: \n", - "\n", - "1. Make a 4-qubit state that is an equal superposition of all odd computational bases: $|\\psi\\rangle = |0001\\rangle + |0011\\rangle + |0101\\rangle + |0111\\rangle +|1001\\rangle +|1011\\rangle +|1101\\rangle +|1111\\rangle$. Then perform a QFT on the state. What is the resulting state? Explain why your result makes sense, using your knowledge of Fourier transforms.\n", + "### Challenge problems:\n", "\n", - "\n" + "1. Make a 4-qubit state that is an equal superposition of all odd computational bases: $|\\psi\\rangle = |0001\\rangle + |0011\\rangle + |0101\\rangle + |0111\\rangle +|1001\\rangle +|1011\\rangle +|1101\\rangle +|1111\\rangle$. Then perform a QFT on the state. What is the resulting state? Explain why your result makes sense, using your knowledge of Fourier transforms." ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "313754e4-aaa4-4210-aae5-0079cb8ad9fb", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -1031,7 +1001,7 @@ "in_page_toc_max_heading_level": 2, "in_page_toc_min_heading_level": 2, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1045,7 +1015,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3" }, "title": "Quantum Fourier transform" }, From c8dfdd9565cb5c8683d949b2e660d90ee41277fe Mon Sep 17 00:00:00 2001 From: Katie McCormick Date: Thu, 9 Oct 2025 14:35:35 -0700 Subject: [PATCH 6/6] remove unused image --- .../images/modules/computer-science/qft/QPE.avif | Bin 8216 -> 0 bytes .../066a1c6b-864e-4cf3-b9f1-2751b9b00998-0.avif | Bin 0 -> 1607 bytes .../0ad8006b-caaf-4e4c-b222-a9224d3f6af8-0.avif | Bin 0 -> 3866 bytes .../11793bc2-53ea-4c34-aed7-06e1ce630557-0.avif | Bin 0 -> 3403 bytes .../15b9688a-8c71-457d-87e7-8bfec6f4ee76-0.avif | Bin 0 -> 6956 bytes .../198a4223-96ab-475e-a83c-75596bf569cb-0.avif | Bin 0 -> 7052 bytes .../51b45910-624c-40ee-ad56-d9af094490d2-0.avif | Bin 0 -> 3456 bytes .../6de41e8b-2900-4600-bd35-96df80b1b409-0.avif | Bin 0 -> 727 bytes .../79943d18-2d57-41f4-ba6e-9c40aca24d38-0.avif | Bin 0 -> 2960 bytes .../b3375193-b230-4dda-a676-ae350c3a9b93-0.avif | Bin 0 -> 3846 bytes .../c16bbbb1-99fe-4824-b9a5-b74fa79eeedf-0.avif | Bin 0 -> 3839 bytes .../cd0b237b-b139-451a-8170-69babdc29e56-0.avif | Bin 0 -> 2922 bytes .../dffb70da-0107-4aeb-b433-20f4b82f6abf-0.avif | Bin 0 -> 2487 bytes 13 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 public/learning/images/modules/computer-science/qft/QPE.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/066a1c6b-864e-4cf3-b9f1-2751b9b00998-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/0ad8006b-caaf-4e4c-b222-a9224d3f6af8-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/11793bc2-53ea-4c34-aed7-06e1ce630557-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/15b9688a-8c71-457d-87e7-8bfec6f4ee76-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/198a4223-96ab-475e-a83c-75596bf569cb-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/51b45910-624c-40ee-ad56-d9af094490d2-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/6de41e8b-2900-4600-bd35-96df80b1b409-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/79943d18-2d57-41f4-ba6e-9c40aca24d38-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/b3375193-b230-4dda-a676-ae350c3a9b93-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/c16bbbb1-99fe-4824-b9a5-b74fa79eeedf-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/cd0b237b-b139-451a-8170-69babdc29e56-0.avif create mode 100644 public/learning/images/modules/computer-science/qft/extracted-outputs/dffb70da-0107-4aeb-b433-20f4b82f6abf-0.avif diff --git a/public/learning/images/modules/computer-science/qft/QPE.avif b/public/learning/images/modules/computer-science/qft/QPE.avif deleted file mode 100644 index 257359c76c4cb8dcfe22694de990212b7cb765dd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8216 zcmb_hc{o(j-@mhB?EB8x_kGE}?@M+O#TbKOjA@KDMV5#ZDutx9DOpmMN~t80REWxw z7L}!TGO$^hb<7grd z^toH32{as?2bWYtD2ciXA&5f6)7J5N%RwR1q8S|+c={1ZF?f2<#sWe@bOz!cUu_`> za{_|X8L?gK45S4i7)--&<~Yy;m$>IT1HTKp2}B~95h`PpA9M%|Q@{f*UQ>&%@rMK> z|B^7eAKS#$bd}fCVRU2B#ApJ9qfkghJdQ?;A!|@W!&DNZNpzE3DMSjD0$N`p1s?+l zHe9@x^)472fSf(}7!s92jR9eC-lQ9Va{+5)8r9R@3hU>;8Ot;YQec9ZAq5DI!^cuA z-Q8X2R@YlP{&RgDTur!Njc)4?|9?WZP%p+M51wohR0mJc@`1WNjf!!mV=&3E8FI)*H-LEn{!RqhtztMPBF@1F zU?2|{!^c{KT0#NVvq0$1&muxgZ`9$d+q0LBtbc{phg)d3aMO!NwL~kUQc%f$T%i zmu}}fg=R(f1$2=Z3W@P;03In#AlcJ-X@GTOfr<7(Sx{7 z$7}xW7_%Gx+nXmNo+vOc#NRUO`L546{r!m5tk#^=Tw1k4BP7zm`wUsfP?D&`@CX{# z68s_%u#RNBx++#%Q(F)G&Vt_;x(oz;@nHOJzyx~!a2YQk$h2)`W#!r*&Z!N8E^Yvy z|CK+Sq5=4MW`&@xEBH8S{Hi@9y+MJ$5}e>m6NV%p8AuW2qYddp#*hVM3pqhKH zZ3XXZ1bEM>Py&mBLQI z&cQCiuE1`=?!g|zp21$iCSjjpi*N*-4bBG_hs(n?;0AC@xHH@vz6Bl*-v&>HXTtZv zkH9P87vN3sTk!kvC-8CjG<*R8Ay^Rt2q}ab!T@27a6@cHgdwPiorqjSF`^Pti?|Br zxgRl(m_htNqLI8vEK&`;!460tBp$g9xf8h;S&FPeHX-jI`;jk^v&dg4c9a-O1!aVC zMERk@Q3E^dM~;hU5CDjevE#NUSMKk z5@u3iGG%gO!ZFd9b~BYQU0`Zs>SLN<`p(SCEXl0RY{$HrnarHdT+Do)`37?z^E>9B zEL<#dEJiGDETJq(Ec;nbv0P<&$TGq56T^*Bz?fpZF_D;Em?M~4Ob2EJ^M#d_Rhre1 z)q|DDn#OvBwVt($^(E^MHXb%*Hfy#(wm7zZY-ibSvOQz_!p_bv&u+oKnVrVIkNq5b zJNp>>cMe_-bq+_4P>xiNGL9yWK8}x^ESz$jmYiETlR1kyFL6HPoZ({OlIODK!g1~7 zD&xAsHN>^R&C9LD?ZzF=y_fqu_dV|SJWM?DJhnWcJefQvdD?ki^CEaV#CU)K6&zX&>oy={o6A8H|j9Oqk3; zncFh6vXZi{vMI9Fvd`sM@!DnD13K(F zb~>p#Ejn|$D!K&SW4cfEc=cTMvh{B3E$eU4r|Q@0Pi~Oi5WL~&h9Lt!19yYH23>|I zLo35n!&bu|M*2oHqXwf-#%jh<#^;USn<$tNOir1+HkCHTnVv8mH^Z6*n;kbBHvXHR|wK!w(&Qi%T((;1kM=MP$s#T-aH)|v79o9E(5H|KUxi-DFJhnczrM6>s z(sto?)poP?diLAxZ#tkHoE-`sh8)Em@s8&lXPq`U?Qpu|%;xOnTg0OBb!4O5M)JmHH^|M=?SR{;yMp^R_iG+#4|k6;kGGy$o++N4Uc6pGUgy2OdRuw# z_a639^ojGi?aS#K=zGrh+a{Y$MVrR`H2ik>-S-#qC;GQ+X4>q#`OM~p0Na2=0TY3G zfx80-wp`4BxS&hHsNhY(=YyAUZn#R^LWpC?(U4iZHU2PuI@BWc zVCW>llu$%?7iJn(6!t#cH2gsLWQ2J{al{PKnpjGli*$&ri2N4i7Iijig|vxO7tI_U z9DRk%LyjWfiIIp&jCo8^q3ouNZ!_9OCR|G7P9!JxBq=BDNqU!Tmwb9Vayx$e?G&k$T`4bjSnfEn6SgyC=j~LP)Xdb0 zH2buwU6@@_yB?%#rWd8pXKc#2nkk-{miao%KC5~+$8PHGp={&qiX3DPF{gKr&YqGz zzj8x!yYn>jiu0EC;`esvYvmuwU)dM7uXn%x{$mB`0&>A%p?P6d5qD8?(dz@Q2bvCI z59S`6KNNK6Ua@X*#bM0hxWnT|T#mGq$d(k8ER{x-J}I**t2-)obkEUm<)P($$1IN3 zR)|;RRV*GS9)Ehm{zOxyd}Z-T^vU>>Z%_H2>O5_5`rH|jGkIs0&yvrMS9w<5Ik(~5 zx$|P@_gBNKZOLs5Hz_w~ zZiU}^eLLv(aJygoz#We}y&cXSU3cy7ws%@~wso0ywcazjcct5)yZOHU{iYthp2i1y z4;p**dz&6^c-ZpD@X^)BCXa9QnfKl5x9Pt-;5cyq$;Ky-2Ym*g4h0U4KMj5Q{u$}n z-1GS7KZnysP$RjcT%*NfVq=vrlwQ=0>yKZ5Y4ft@mDj7`*Z9}dZ(`ppO=P}he_Q-c z^4+=j+V5K@?Is^h1x!s$Q>K5;?Eb+0;pj)jkC#7LeCnC?o1K`W&aHgj`$hQ6*?Hah z+Y9asV_&1c{`{8vUHE&|4}%|_i<=hT{Y+S5S~{|=;j*4Tf1;CaW zf`@_q?dP))#O@D4ypO>8Az*d?$B=-n?pXnbt=)9`AH2Fpqz`~K1XK&w?;bN?bu$D( z^`{_6p1yw$gdlfz2=X?B;5s_LZ-xrkQ#1CJ^bQ*AA&%QGheU_04gI%fbaWozXgAodoS>#0` zbw#+e3;1~;c&_3Ji_5#t@0@RnbEJJ$>j_JVG!8Bj8tseRcI(Ryu}gCge~r1BXYQCy zGvHacI`zbbfZ?*WeiP=jtG2Up_th>gZebh`B10(yT?GYWmxy}xRcJgql z>W~zZYP)EHp^9uN?c{J-K@R29wwmYH#n2(OpP!{F&5HlEZ$Bc#E!y4c4I5xU1z=l2F$$lWjxR%bOY8aa&VDGz4ZN zzhwx%h)2YarUk{D81sMp;(TKY^5q-*h*OK#wY__pO||b;dHbav)@;_o`uyRE=AV5E z2k*7^SLCtIEnYs+da%dvf`s)uPs)OPx2lQ%G3lO0Wzv&VkCOy0+UZXjD{H1NnICvM zD_C-xtCU)PuWG+nY}<@El5na_O{egZ{ev#!19=NfP`b>eBtu$S;inzt@*3~Y8Y8rH ztUp}y+kas;_v7t__T!D+dC3_%wc1NQy#%bOd@^23GR(9*zun~Qq_uJ+_* zKv%XMdPucEvLW5 zAU0lUacg(o^yP7VTJ3b)h*MT~d1IXW4iBM1eEnCa$A%)|`?u=rXlf(t9+C?~JNFC^ z+@wX(_B^O5dp{vFZM*k$9ahjRsbLRiP<Gbsm{zr z4=u4_TA4XKf0!B(c6Ha@=Z=a$K76K77F#Prq^(X5&krSykBrqgJwKy9zX_dsZRAXK zoBx8!uW#4F$Ew@xjz~%l=*Ft{EZn?`!v&vtRzR~@3Gy%hZu~XDae1M2zw6gj_5MN= zOCH^)q@{p+ug}!G?ok?S?UwHfek`M?I#cj`%ys@i|51m{by=SA21#4eFEzlkY%DGA zZuZ-f+a^7jG(%cqt* z=#iSPJ-Nq_mrT{4wgtcWu&woT`cHUvo@?sQ2Al>pM!-pbNTuxOj6}UXCMUI7^EoYQ z`hMTnou@hHzwE3U*>G<8v$7Ya1$CpOw#}hfDP>Bd{Oy%Y>-1lo1AZwE<_#mJk1Dhp z^L3S3bls5EIt#3sm8DG2Id3kTl^EAJ=Wb;-EhesTieZd6lo16NKL2`8ZEtD5&rg~; zG(CHLuzKXnraHAF(L`Pub>$@2F{3N>eO>vD8{SS?c<|JQ32U&7zhzvv~My`Piqr zxUws~W357{46D!y!wG)LfWak6n*!rX&x_6ID*cZFqos*7dqmC)QAZ)7fc zAy;;r=P>lWr^hTW(aUWXO71D1KPE zcV1kW?9pM5?F;RZdUeb}bI5BTBQS{acGGgwQ3uybxmRsG0g+nGO*@wI#AZ*M&Aur- za4r$f^t6U!(7(!MCb`+9wj!v5$MNF3&$nm2rfyxFfA!3PKa;)W;Kmd4md`icI_V)X z@K#CVO}y3fW5Q{C&G1I%?L~ssxg5}e%a0^yI_rkS%kAvDB_dc4m)Y)n1X(^x>qxP0 zPYgQyaJrw1fA;jsxAb2%@{`3u$J-^J=JdDTzxqyP-|GyPWB1=l)0zrjmA-hnP|!Vv zg&|tIcBq)&iL&`#c;bO~s?wp}{A}#2)pM`&XJ2@vBkc1f>UmB|xym)+!=lhkH zb7cxu*Q=KziYv25Y9vn)O|u4$5Bn{qiL%p>qj&oE4w6-?165$>RbTwL5H}a5=;2>7 zAj_qGRJh4p^m1%BwIbitX=+(IFk|>D?!wD1EpOLrJSqOZey}5@-%a~V`XFcSV5R*k zl=nSfnic}n#d+_uiMj|Zj|$J9^DW|YQq|I^U3{*^7uFl0o5o7ViSR6moRS#c>} z{myBgEv*$rjh|2sid3DdP3<$YTTJgzhAMh5e>N}d{8TK!K2a%o^jw9Ehp2tQ zF}Wd6$@K0CGe_z9kC1PbOkT_GsZ+j3615DLrrusU&eXupRkK0lorLa+WlIO!ws@z5 z7n=;`lAwF#zjz<)HkE{18wHH^IEQLEUD~c|@Yqm*1IC{byuak__uaiIL_((To>ANtJ+CSTzGUSSvhDj3^lETLj}*!5JOcrd%@wS6bDUkZ*4Ury^1 zx4JPlDdvSd|4{whOi0t2qJ+I}orWcvA3xPEsXcSvjd+^>nbplDHp{|S;Vpjpl$qto zv9}j4zVY0%?`?09Nk$r0v#$2K_oehoz3Yd|o0fkz*QO|b%aYl+>8P#D9--!One(st zJ8}m1A2&>AuU0MV7qohEoqemcy+>%W(vX$uC;gB0*D5c*MzEowDi8PWxUlgS-gCN1 zo~G17qsaj_@So$VtG>9j;#mm6&|&lMzC-lWuc)^fbt(rI%!|yo?*oQjh!; z%K3qsWK)rNBuKfOP5eu)&Ro6g^-fn2`^Fuv>GhHE+x3(M-^-p3**lLqBz#irVfUH& z1Lu1XY*YINq~~>P!zN(V5%;PPwa|^-6G6`&98h?A;cRiD;ZVU=mWOp@9@6|rKgoU7 zIT0$B$-Vxp=ATc6eDZUaIDuR0qDFUFHb@>0v=E9qSQ{zC9=8#8->pu4K;u($yWESp z^d|MbWyu~XiGsDa0Biy}7VYw;f_ta?yqZuVh8gQKRHM~>8SKeFBVgZ^P1jzHO- z5NThHlX#EbUEbU9CX3^H234(J#ah1K`qe>pTFJBafy$ti%EbPIq5eiKUV>XI6*sPM zA;tpOQp4v1@0lMi3z(lT;la5(pI`p&Vk|56kbhv}_;u0`LD~2A)>m=5(H#9R!>-=a zQm(l>J#B0O7N|^&1u7;@TNZQ_Et-V-jZ(fGy~*-SxE}rC74n>dwOnCi)wD!W7qJ;1HBeWE>vScPI4o z8v0cLZhC*UMHKA@=XH$J2`KY8d|euDaU8LZ89M{W(#zVBew^clrxFO{*oYXKNup6= zG=+X{iUntfeGIaZw!v^qW}T7y2Kp{1^= z@t@Ra#IXNGjXtuf#>i{coeABTkvlPwK=QKz2d?B;5Sp2mo|b_L!_WU1`V;A@s!uF| zY8?{|G-+mkRee?Y@4h9LJ6 z`s$UUp@Ke_bauSoPdN2st51U3#!a(pSd{C`-PQd?^mY~BMA!MTP|lmA`Y)iQ_H`@j zl9khZB&kVjaYgZ!+y|EaW=>4F{9^NYD^uoj;#Vi?qLWCE)J2kxLS;2$jG&mVRb*z) zPORd)hQE&5M;$PKhsTfJb|}2;)po_+WR#LJ-7UsWuLHQ2Q+Fwcp`CQQbGg%u&nY^x zdXLJYRL(kxd&KJ&Jn_Y7N-13da43s7+cGrgYx0a{7T!%<&YeyCZmm{t_}==$iG+my z{E_5%wpBZ=79v1A5YM?xweEp1*d<$0{_9H9uwrFT^-6>ueZ4>|N3Y{TwR5BHu6S&nwk)UZnf@h+&YH zvP$)&jK8G~OJ+TL%RgGJ$==7!+oB??|LjZ4Mm|%xxROg8(LPknr0RV3v7ZbXHcE@> z8Cc9_i{*39+hzDpmitfccrdrw@1PM@HYjRe(m7jQfrB=5uI>k$T#|~h?|cf6SHAi| z>5t!B&sr^2C&<0u<9^is11{G0ctwl!Q-mmnkfG~1HG%cDRB8dPN_5`*>^&YiI=8nk zb>@6O!iN&3+}cok!`v_xCC+nGzssN$WRA#!>8h7({d3opYd4oXWEd3e$5L;8+1%sL zjtqU5&e`;C;+c28n8H4B?s5+PshP@Z7P3#K=2J*A=EX5hY!F~*mqGWS?8Dkc=PlZP zLdit!3$?Jgf3rZ1Mg0D1E-pXrQ|0s-eKb4Ch!*{}F?zSnm*W@LU*6VzAj9LPl#ae- z5v8$uyrGl1J52a|-la=pu?qq51{iFX$i4To#=$fErKWcraWz$E11`Shmf6GIU3ce^ zL-+I1xi-+4MUmxfm5jOlCK~H+wD~wOZE&HOCO~fPDAB*vYGTp2`L*lB zFFtGKrU=a+)T+HZzeP=AJZ2+vT+`gx8Z6g{Hj`ndVx}@@D1fVfdAuUxpr^~zlx_l( zZ_PEX?>bjOH57X^RP&^E>~OQqj_T8rE3yBei+38p?+;4&{^((KV61!Oj>=Q(=;e}L e$tg@D>Jz@wGpyInkF-BJ`s>?(Qq%!4Db~Ne*_k*1 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/0ad8006b-caaf-4e4c-b222-a9224d3f6af8-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/0ad8006b-caaf-4e4c-b222-a9224d3f6af8-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..f48b24f13e40f8250d99f1d9918ab53fe52f9a42 GIT binary patch literal 3866 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 Lj>8V>E06vc)GG^$ literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/11793bc2-53ea-4c34-aed7-06e1ce630557-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/11793bc2-53ea-4c34-aed7-06e1ce630557-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..df5237eb9df2770c9968cac9bfe24a67a29f78be GIT binary patch literal 3403 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/198a4223-96ab-475e-a83c-75596bf569cb-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/198a4223-96ab-475e-a83c-75596bf569cb-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..3f673f572e1c4f039516d061d256776e75fea81d GIT binary patch literal 7052 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 aEfH41pPa@Q*5|0cC#B09=pK<1n*2Zh!8FML literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/51b45910-624c-40ee-ad56-d9af094490d2-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/51b45910-624c-40ee-ad56-d9af094490d2-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..b23bca92f0b4916466ea8015039c212b19cd2f06 GIT binary patch literal 3456 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/b3375193-b230-4dda-a676-ae350c3a9b93-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/b3375193-b230-4dda-a676-ae350c3a9b93-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..ae3d2e79f698a7d74b3a624212cd454b799291a8 GIT binary patch literal 3846 zcmYLMXE+?*(_MX)Ska@47M)nVL`@Ka=p|Tvqb-Z*U9{+;t|&neHCVkwU%f={f)Ij4 z@Bfv&zvrC~cg{I8=eaZY+XVmsbT)2YFo*}#27nGnsEyzqc7#IE90TTP?FPBi(ZOtI z<>2}c0st_mrQ3h_zf25+x;g$O80ZrWb#S)4V~Vl>Ou(H2z)1d=0f2kFXbm02U;k48 zN@ywug*yEm<8PG$O|1X6q1_M<0l_=R|BL9#e_{m`<_bd>qo6QLXLKflcnB&4VH4dM z$f0nU^&J2Ju@S_0<4C)EJQ?P(QAUgeDKi!>#-r`>krXtzpKc`E%L1ql`)9gmvyzNtuvs_oHtVX%g<|$ipX;};NN{1-j1I{L* z17o9(cWBOR3&3sHWI5|TMzx~7dZ!*c0vPdws)US`1Br{ErmUK^(I<(HBH$%j45RPl z%grs7(E_xDLiD{(j6L}&sHqHYagAlXG1H5<-Z_zwiFvA-58xzrPbOmv<6I@@XuNVi zff?U5FH#P*-IgCIn`D}Wxx9eKO~~caVN#LOgUbLH%Q!<76<^0b2ki0Uyd%iNZ0${p z))9dhmZAN66aj&Im_iCVh}ezHQ;5TBzP*9DuJw%KX;M{|O&Q8n(cSHU2k3X+f_h$g;I1PO?ls83?=G81{u| zZ3XB}ou1`>`Pmn}fsv-Cx#7*-vJ$AQ(cS+bYeB)i-Hg&4^kHQe?$*)O6=4@}NoF&k zV5z*Vw;4{S(<07ut*uf2s_y!OHY118b$Bue&nQuiZhlzoTM&@Ll<;_1`fB)PIc`i) zuw%LH3Wfizj}Jud!E?zavE7MvFT6R5P@x8mA%B170?!INMsCko=6)9}TsKiuyht~t z&Vnyji}om$&-|eE;9%vIS!_7T+J(8Q^RT)xW9os_&v(gMY7^PR>0eYrpre-08Ya$v z;0r7lr3*!H-5bUK_-TZA=B3ZMhr+?dnC$}DzE4Ad)y3d6ic@$RDX~jJi zM8mE~wgxF6UU}g%-r=3Y+pkq$CGo_$o~EsRbWEacuV*#&4_8 z&z$uYJu^6jRP)FNq_p&_HP^l8+PfI;uNzAY%(>b@fbqANhFZJ~#R^R#I zy8g?a5B}7ZAzT9&_=$elNU|+PIwzqLEz^qY{XXW7b zFu~D!0;pcjkL41^Q5gZR#~W71Iw^ZXH21f$W0W7=}x zpYQ3*OPbfU)lB!{-`UI0atsOO@k~*K-6OT9bA4~7lw)5t^x6`+8FAwJUMcM7Y-IpR z@`g9dC^W`q{7U9}!<%c$5b%lTyB3W|UF3aY-XCvBDYh+8h`l-dc&y2camsi;5*D>@ z*gajsiZIWJXC+?|i2N;3`zXG~5?j%{$iuw8?}?v7d>}_Bx+_K4`cGoJ@=-FnrA@pI zeqUXprim}*2F$YpS8-n4)T-7eTfP=09$BibGso29#Z3eX3F8a<=dF3Ma95h;B%`!` zErBw=QAZ>;T1tCJ;Zpoz@Xb385#iLJsEYp0_b&7;*QCIYC=1T0pxZN+k*KL6bur$~ zUH&qXAdx_k5*&LPA`0l?I5?EnA$`<|%J39rCZOOyl()DbWPIJSQ5`PwW`eT&oMj7eF(q!iywp!s+95zlj@i8+mu)*ZDLe0YbVm@v4ILycn znK;s|tIVxTF%!_!B;aAcY#J`>&66QEO^jl9=~PnZ$Vm;+!_kX5S^uKE zq_IcEopIO!2j{7`6kYN=hUG0RjfNdEI|mO(nRa#pM5y`FWCP8XOlid{+ zhX17Ue!iNesM${>vGBd&Y%wqX@p~g(n&S9#n7uVmz2zI#fz{J6>FTfw@kAw~g@C3p zN5MQ~g@nNcUci{Okvgyds3j;Do%5KCC;=GFR83#}md|to1Jo`3VNA7i@0a@s!^@PD zsJ+n_3FgV9b2<)g6~MRx6r1TQM%nk}Y~Prre3E3B(r0Q~g=20T(GEXv`c zlTMENL)mhE_N{7boA@m&e9QUA$jb}+^%PMXj8N@e;PaTHJ?rH(uQnV$Ixt*B?{)fu zRDSls^;TYPM=@A9`Qj=(7DE=ZaAqki;>||mg$-a>nx3Jz{LyW$U}}mTjHchcMp+Hs zl3>FN?GNeA!ss0v*3SbV827{#08I`poYOP;R^Hf7uFgpeg`LLcw;4xkM352I0So>o z%$lefjFv~ZQP}E3dG4{+@mXeM0PcbTZ_Co@kJ>AGgaZZc469iwwy{mAD?*l!KMTtL zp(f)wto?i$&_AVnnn6&LFTV70e`NII{hl(U`4mZC_1acP=h1p2Yi`5pYQppCeXejS z&{IXLq+R|C0evU^&(GY)bBvft0%h~t3quT$OatkG0RV{x)J+=QvDK)|v%zfEdDalJ z^ClkJU^r;g{De2wGrFliDYUL+H&VNK7qbK_R9SyFV9otA+tELN$;1uIr%UL|FAh|o(X zn>C7*JL9R)m#Ec!mhyXGlg-d8fynGkxHU^$pyoImW*=mPj$rMU&M3SX!Mx)eR#xb@ z9i|j1Gv3OMctgP%=|;kH*~%f8ZJMk2ZO|a=Nz+&*n3GVP`}B|RkuI`hubvArBXF3g zXRTS!K)n8)44Pt5v1f^~An{3%;S*1Nd|3}0x46k*QT*mG4Tpev?owR&`@J*nwN5tT zTLCB3^YAhTi<=Uz_vuwbTQoY?dUPbyo(FGct`tWwXugu3%P2)q%A}S)WV%@t9+)sS z(`6^atU z>Dq~PSEs}WPFhgfWySQdK&U_X(&MwAd!* zL}g`h<zbrZIR! z5G@7}nbomZY~jRz9n}GsmkwQP_oj_-NY}S~3eo7XsTib#!LfeDWD-}K3Cg^@}ivE~wn2j(>YXWs< zx?O&-`KUv9($zdlr!?QnTZvmDYws^2=f?a5$KvgDmnD&ysUon~eyiLiwv*-D(|^s{ zw*!DGtq{I{(hT%lCU>pV@aXv_t4eY55Y}pEtjWYo zB^(YotNB-#;i>Z9+O;zorN@aQk4JLQpC!D%pQSL_$6{#mNES&wA>n(7Xvd#@P>K6% pFNxuuY17upUQds%He`j3Ysn8_Cm}gRo#N$0ut&(0eL9)a^*?-o1DyZ> literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/c16bbbb1-99fe-4824-b9a5-b74fa79eeedf-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/c16bbbb1-99fe-4824-b9a5-b74fa79eeedf-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..9bee4615e7addca50994996d646a593508107cdd GIT binary patch literal 3839 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 literal 0 HcmV?d00001 diff --git a/public/learning/images/modules/computer-science/qft/extracted-outputs/cd0b237b-b139-451a-8170-69babdc29e56-0.avif b/public/learning/images/modules/computer-science/qft/extracted-outputs/cd0b237b-b139-451a-8170-69babdc29e56-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..26c4fc0ecc326731ccbab466f1948a69423f0585 GIT binary patch literal 2922 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 literal 0 HcmV?d00001