--- title: First Quantum Algorithm jupytext: formats: md:myst text_representation: extension: .md format_name: myst kernelspec: display_name: Python 3 language: python name: python3 mystnb: render_markdown_format: myst --- (lecture-4)= # Lecture 4: First Quantum Algorithm ```{warning} These lecture notes are a work in progress and are not a replacement for watching the lecture video, it's intended to be a supplementary reading after watching the lecture. ``` ## Learning Outcomes ```{admonition} Learning Outcomes :class: information - Understand what a quantum algorithm is and how it differs from a classical one. - How a quantum algorithm is represented using quantum circuits. - Study the Deutsch algorithm, one of the earliest quantum algorithms. - Understand how quantum algorithms are programmed. ``` ## Algorithm: Definition ```{admonition} Algorithm :class: information An algorithm is a set of instructions that solves a given problem. ``` ```{figure} ./images/algorithm_diagram.png :align: center Algorithm diagram. ``` - A classical algorithm is based on binary operations or the moving around of bits (0's and 1's). ```{figure} ./images/algorithm_01.png :align: center Algorithm binary representation. ``` - A classical algorithm is always run on classical hardware. ## Quantum Algorithm: Definition ```{admonition} Quantum Algorithm :class: information A quantum algorithm is an algorithm that leverages quantum mechanics in terms of design and/or hardware. ``` ```{attention} Some algorithms are designed leveraging quantum mechanical properties, but run in a classical hardware. ``` Its basic unit of information is the qubit. It exhibits the following properties: 1. Superposition: A qubit can be in combination of $\ket{0}$ and $\ket{1}$ states. 2. Entanglement: Qubits can be correlated in ways that have no classical equivalent. Measuring the state of one qubit instantely tells us something about another. 3. Interference: A quantum algorithm can be designed so that the "wrong" answers interfere destructively and the right answers interfere constructively. ## Superposition, Entanglement, Interference 1. Superposition $$H\ket{0} = \frac{1}{\sqrt{2}}\ket{0} + \frac{1}{\sqrt{2}}\ket{1}$$ ```{admonition} Superposition :class: information The qubit is in both states at once — measuring gives 0 or 1, each with probability 1/2. ``` 2. Entanglement $$\frac{1}{\sqrt{2}}\ket{00} + \frac{1}{\sqrt{2}}\ket{11}$$ ```{admonition} Entanglement :class: information Measuring qubit 1 instantly fixes qubit 2's outcome. ``` 3. Interference $$H H \ket{0} = \left(\tfrac{1}{2}+\tfrac{1}{2}\right)\ket{0} + \left(\tfrac{1}{2}-\tfrac{1}{2}\right)\ket{1} = \ket{0}$$ ```{admonition} Interference :class: information The $\ket{1}$ amplitudes cancel (destructive), the $\ket{0}$ amplitudes add (constructive). ``` ## Classical vs Quantum Algorithms ### 1. Basic unit of information - Classical: Works with bits. Each bit is definitely either 0 or 1 at every point in time. - Quantum: Works with qubits. Qubits can show superposition, entanglement and interference. ### 2. How states are processed - Classical: to check N possibilities, a classical computer generally has to look at them one at time. - Quantum: N qubits in superposition represent all $2^{N}$ combinations of states simultaneously. ```{attention} Even if quantum algorithms work with a superposition of states, measuring collapses the system to **one result**. ``` ### 3. Gates - Classical: Classical gates implement boolean logic functions on bitstrings. - Quantum: Quantum gates implement linear transformations (represented by unitary matrices) on state vectors. ### 4. Reversibility - Classical: most classical logic gates are irreversible. We can't uniquely reconstruct the input from its output. - Quantum: quantum gates must be reversible. This means they can always be run backward. ```{attention} Reversibility of quantum gates is a **hard mathematical constraint** on how quantum circuits are built. ``` ### 5. Algorithm output - Classical: Algorithm output is deterministic in nature. - Quantum: Measurement is probabilistic in nature. ### 6. Mathematical foundations - Classical: Based on boolean algebra and discrete math. Bitstrings are transformed by logical operations. - Quantum: Based on linear algebra over Hilbert spaces. Statevectors are transformed by unitary matrices. ```{attention} Any classical algorithm can be represented and executed on a quantum computer. ``` ## Computational Complexity - Computational complexity is the study of time and space resources required to solve computational problems. - The big-O notation ($O$) is used to study the worst-case behaviour of specific algorithms. - $f(n)$ is in the class of functions $O(g(n))$ means: ```{admonition} Big-O Notation :class: information There exists constants $c$ and $n_0$ such that for all $n>n_0\rightarrow f(n)inputs, variables, qubits, gates, iterations... ```{figure} ./images/complexity_plot.png :align: center :width: 580px Growth of common complexity classes. ``` - A simple sorting algorithm (e.g. bubble sort) is a good example of computing an algorithm's complexity. ```{figure} ./images/bubble_sort.gif :align: center :width: 360px Bubble sort algorithm animation. Source: commons.wikipedia.org ``` - The bubble sort is a simple (and inefficient) sorting algorithm. - It steps through the list element by element, comparing adjacent elements and swapping their values if the order is not right. - This means it has to do $(N-1) + (N-2) + \dots + 2 + 1 = \frac{N(N-1)}{2}=\frac{1}{2}(N^{2}-N)$ swaps in the worst case. ```{attention} For large $N$, the $N^2$ term dominates, so bubble sort is said to have $O(N^2)$ complexity. ``` ## Circuits - In theoretical computer science a circuit is a model of computation in which input values go through a sequence of gates, each of which computes a function. - Classical (quantum) algorithms can be implemented using complex sequences of classical (quantum) circuits. - Circuits can be thought as an ordered sequence of operations, where each individual operation is a gate. ```{figure} ./images/classical_quantum_circuit.png :align: center Example of classical and quantum circuits. ``` ## Classical and Quantum Circuits: Differences and Similarities ### 1. Similarity: Gate ordering - Both are partially ordered sequences of gates: independent gates can be reordered or run in parallel. ### 2. Difference: Gate timing - Classical: Gate execution times are essentially uniform across gate types. - Quantum: Gate execution times are not uniform. Different gates take different amounts of time to implement on real hardware. ### 3. Difference: Circuit depth - Classical: Circuit depth is not as important as classical bits don't suffer from decoherence. - Quantum: Depth is critical, since qubits have a limited lifetime due to decoherence. ## Quantum Circuits - In a quantum circuit, wires represent qubits and gates represent operations on these qubits. ```{figure} ./images/single_quantum_gates.png :align: center Names, symbols and unitary matrices for common single qubit gates. ``` - Unless stated otherwise, qubits in a circuit are initialised to $\ket{0}$ state. - Circuits are read left to right. Gates to the left are applied first. ```{figure} ./images/quantum_circuit_1.png :align: center Quantum circuit example. ``` $$\begin{aligned} SHX\ket{q_0} &= SHX\ket{0} = SH\ket{1}= \\ &= S\frac{1}{\sqrt{2}}\left(\ket{0}-\ket{1}\right) = \frac{1}{\sqrt{2}}\left(\ket{0}-i\ket{1}\right) \end{aligned}$$ ### Multi-Qubit Circuits ```{figure} ./images/two_qubit_quantum_gates.png :align: center Common two-qubit gates: CNOT, general controlled-U and SWAP gate. ``` - Multi-qubit states in circuits are usually written as $\ket{q_0q_1\dots q_{n-1}}$ (big-endian ordering). ```{attention} Some SDKs like Qiskit use little-endian ordering, which means that multi-qubit states are written as $\ket{q_{n-1}\dots q_1\dots q_{0}}$. In all cases, however, $q_0$ will be at the top when drawing the circuit. ``` ```{figure} ./images/little_endian_big_endian.png :align: center :width: 400px Quantum circuit example to show big-endian little-endian differences. ``` ```{attention} The state of the circuit above would be $\ket{001}$ in little-endian ordering and $\ket{100}$ in big-endian ordering. ``` ```{figure} ./images/quantum_circuit_3.png :align: center 3 qubit quantum circuit example. ``` $$ \begin{aligned} \ket{\psi_0} &= \ket{000} \\[0.5em] \ket{\psi_1} &= (H_0\otimes I_1\otimes I_2)\,\ket{\psi_0} = \tfrac{1}{\sqrt{2}}(\ket{000}+\ket{100}) \\[0.5em] \ket{\psi_2} &= (\text{CNOT}_{01}\otimes I_2)\,\ket{\psi_1} = \tfrac{1}{\sqrt{2}}(\ket{000}+\ket{110}) \\[0.5em] \ket{\psi_3} &= (I_0\otimes \text{SWAP}_{12})\,\ket{\psi_2} = \tfrac{1}{\sqrt{2}}(\ket{000}+\ket{101}) \end{aligned} $$ ### Measurement ```{figure} ./images/measurement.png :align: center Computational basis measurement symbol. ``` ```{attention} Even if measurement is drawn as a quantum gate, it is not. **Measurement is not unitary**. It is probabilistic and irreversible. ``` ```{figure} ./images/measurement_2.png :align: center Example of measurement with classical registers. ``` - The outcomes of measurements are written into a classical bit in the classical register. - Classical registers enable conditional operations after mid-circuit measurements, applying quantum gates conditioned to the values in the classical register. ```{attention} Sometimes all classical registers are drawn using just one double wire, or even not drawn at all. ``` ## Classical Circuit Example: The Half Adder - The half adder is an example of a binary logical classical circuit. - It takes two 1-bit inputs and produces: 1. SUM: A XOR B. 2. CARRY: A AND B. - It is called "half" adder because it doesn't account for a carry-in from previous stage. ```{figure} ./images/half_adder.png :align: center Half adder circuit. ``` | A | B | Sum | Carry | |---|---|-----|-------| | 0 | 0 | 0 | 0 | | 0 | 1 | 1 | 0 | | 1 | 0 | 1 | 0 | | 1 | 1 | 0 | 1 | ```{admonition} Half Adder :class: information When we run an algorithm on a classical computer, it is made of a lot of logical circuits like the half-adder. ``` ## Quantum Circuit Example: The Half Adder ```{figure} ./images/quantum_half_adder.png :align: center Half adder quantum circuit. ``` - The Toffoli gate computes the carry operation, $q_2 = A \cdot B$. - The CNOT gate computes the sum, $q_1 = A \oplus B$. - Measuring $q_1$, $q_2$ reads out the sum and carry into the classical register. ```{attention} This is just classical logic embedded reversibly into unitary gates, no superposition or interference is used. There's **no quantum speedup**: it needs an extra ancilla qubit and offers no efficiency gain over a classical half adder. ``` ## Deutsch Problem ```{figure} ./images/deutsch.png :align: center :width: 200px David Deutsch. ``` - Given a black box $f : \{0,1\} \rightarrow \{0,1\}$ $$\begin{cases} f(0) = f(1) = 0 \\ f(0) = f(1) = 1 \end{cases} \Rightarrow \textcolor{green}{\textbf{Constant } f}$$ $$\begin{cases} f(0) = 0,\ f(1) = 1 \\ f(0) = 1,\ f(1) = 0 \end{cases} \Rightarrow \textcolor{blue}{\textbf{Balanced } f}$$ - Uses an oracle to determine if $f$ is constant or balanced. - Classically -> 2 queries. - Deutsch algorithm -> 1 query. - Early example of QC power (1985). ## Quantum Parallelism ```{admonition} Quantum Parallelism :class: information Quantum parallelism allows quantum computers to evaluate a function f(x) for different values of x simultaneously. ``` - For a binary function, it is possible to build a gate $U_f$ that performs the transformation: $$U_f\ket{x,y}=\ket{x,y\oplus f(x)}$$ ```{figure} ./images/parallelism_oracle.png :align: center Parallelism oracle example. ``` - Input state: $\ket{\psi_0}=\frac{1}{\sqrt{2}}(\ket{0,0}+\ket{1,0})$ - XOR gate ($\oplus$) truth table: | $x$ | 0 | 1 | 0 | 1 | |---|---|---|---|---| | $y$ | 0 | 0 | 1 | 1 | | $x\oplus y$ | 0 | 1 | 1 | 0 | $$U_f\ket{\psi_0}=\frac{1}{\sqrt{2}}(\ket{0,f(0)}+\ket{1,f(1)})$$ ```{attention} $f(0)$, $f(1)$ are evaluated simultaneously! But only one value is accessed per measurement. ``` ## Oracle - For a 1-bit function there are only 4 possible oracles. ### Constant f ```{figure} ./images/oracle_1.png :align: center :width: 200px $f(x)=0$ ``` ```{figure} ./images/oracle_2.png :align: center :width: 200px $f(x)=1$ ``` ### Balanced f ```{figure} ./images/oracle_3.png :align: center :width: 200px $f(x)=x$ ``` ```{figure} ./images/oracle_4.png :align: center :width: 200px $f(x)=1-x$ ``` ## Deutsch Algorithm ```{figure} ./images/deutsch_algorithm.png :align: center Deutsch Algorithm. ``` 1. Initial state. 2. Superposition generated using Hadamard gates. 3. Evaluate values f(x) using the oracle (parallelism). 4. Interference between states. $$\ket{\psi_1}=\ket{0}\ket{1}$$ $$\ket{\psi_2}=\left(\frac{\ket{0}+\ket{1}}{\sqrt{2}}\right)\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)\rightarrow$$ $$\ket{\psi_3}=\frac{1}{\sqrt{2}}\left((-1)^{f(0)}\ket{0}+(-1)^{f(1)}\ket{1}\right)\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)$$ $$\ket{\psi_4}=\pm\ket{f(0)\oplus f(1)}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)$$ ```{admonition} Deutsch Algorithm :class: information Solves the problem in just one measurement! ``` ```{admonition} Note :class: note note-red In order to get the state $\ket{\psi_3}$, we used the fact that $U_f\left[\ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)\right] = (-1)^{f(x)}\ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)$. Let's see why: ``` $$U_f\left[\ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)\right] = \ket{x}\left[\frac{\ket{f(x)}-\ket{f(x)\oplus 1}}{\sqrt{2}}\right]\rightarrow$$ $$\rightarrow \left\{\begin{array}{c}\text{if } f(x)=0\rightarrow \ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right) \\ \text{if } f(x)=1\rightarrow -\ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)\end{array}\right.\rightarrow$$ $$\rightarrow U_f\left[\ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)\right] = (-1)^{f(x)}\ket{x}\left(\frac{\ket{0}-\ket{1}}{\sqrt{2}}\right)$$ ## Deutsch-Jozsa Algorithm - If $f$ is n-bit: - Deutsch-Jozsa algorithm (1992) -> 1 query. - Classically -> Can be up to $2^{n-1}+1$ queries. ```{figure} ./images/jozsa.png :align: center :width: 170px Richard Jozsa. ``` - Looks like a big improvement but... 1. Deutsch problem has no known practical applications. 2. The method evaluating the function it's different between the classical and quantum case. 3. If we use a classical probabilistic algorithm, we can drastically reduce the number of queries needed to solve the problem with high confidence. ## Classical Programs ```{admonition} Classical Program :class: information A classical computer program is a set of instructions in a programming language for a classical computer to execute. ``` - One can think of a classical computer program as a concrete implementation of a classical algorithm. **random_integer.py** ```python import numpy as np import matplotlib.pyplot as plt samples = np.random.randint(16, size=1000) values, counts = np.unique(samples, return_counts=True) plt.bar(values, counts) plt.xlabel("Value") plt.ylabel("Count") plt.show() ``` ```{figure} ./images/random_integer.png :align: center Output of random_integer.py. ``` ## Quantum Programs ```{admonition} Quantum Program :class: information A quantum program is a set of instructions in a programming language for a quantum computation. ``` ```{attention} A quantum program can be executed on a quantum computer or simulated in a quantum simulator. ``` ```{attention} A quantum program may be composed of one or more quantum circuits. ``` ```{figure} ./images/quantum_algorithm_program_circuit_hierarchy.png :align: center Quantum algorithm, program and circuit hierarchy. ``` **random_integer_quantum.py** ```python import matplotlib.pyplot as plt from qiskit import QuantumCircuit from qiskit_aer import AerSimulator qc = QuantumCircuit(4, 4) qc.h(range(4)) qc.measure(range(4), range(4)) counts = AerSimulator().run(qc, shots=1000).result().get_counts() values = [int(bitstring, 2) for bitstring in counts] weights = list(counts.values()) plt.bar(values, weights) plt.xlabel("Value") plt.ylabel("Count") plt.show() ``` ```{figure} ./images/random_integer_quantum_circuit.png :align: center :width: 430px Circuit of random_integer_quantum.py. ``` ```{figure} ./images/random_integer_quantum.png :align: center :width: 720px Output of random_integer_quantum.py. ``` ## Quantum Simulators ```{admonition} Quantum Simulator :class: information A quantum simulator is a classical system that reproduces the behaviour of a quantum computer. ``` - Running algorithms on real hardware is very expensive. - Using quantum simulators allows us to look for bugs, prototype algorithms or do resource estimation before sending them to a real device. - The number of amplitudes grows as $2^n$, so simulating larger systems gets exponentially harder. ```{figure} ./images/qubits_amplitudes.png :align: center :width: 650px Number of amplitudes vs. number of qubits. ``` ### Statevector Simulators ```{admonition} Statevector Simulator :class: information A statevector simulator represents the full quantum state as a single complex vector of length $2^n$. ``` - The statevector simulator is the default simulator in almost all SDKs. - The number of quantum amplitudes grows exponentially with the number of qubits. - Statevector simulation uses brute force to perform the simulation. It is the most exact, but among the most computationally expensive simulators. - Simulating more than 40 qubits with a statevector simulator requires supercomputer-scale distributed memory. ## Accesing Quantum Computing Systems ### Quantum Stack ```{figure} ./images/quantum_stack.png :align: center The quantum computing stack. ``` - The user can interact with the software and hardware elements of the quantum stack in different ways. - Quantum programs can be executed locally or remotely, and using commercial or publicly-funded systems. ### Quantum Computing Software Simualtors (QCSS) ```{figure} ./images/qcss.png :align: center Local and remote QCSS. ``` - QCSS can be installed locally on one's laptop or workstation. - Remote QCSS are installed on larger scale HPC facilities. ### Accessing Quantum Computing Software Simulators - Simulators can be roughly split into two categories: full-stack simulators bundled as a backend of a specific SDK, and standalone simulators used independently of any SDK. | Simulator | Language | Category | Notes | |---|---|---|---| | [Qiskit Aer](https://github.com/Qiskit/qiskit-aer) | C++ | Full-stack | Qiskit's backend; supports statevector, density-matrix, MPS and stabilizer methods | | [PennyLane Lightning](https://github.com/PennyLaneAI/pennylane-lightning) | C++ | Full-stack | PennyLane's state-vector backend, with CPU, GPU and MPI variants | | [Cirq](https://github.com/quantumlib/Cirq) | Python | Full-stack | Google's SDK; built-in `cirq.Simulator` state-vector simulator | | [ProjectQ](https://github.com/ProjectQ-Framework/ProjectQ) | Python / C++ | Full-stack | Open-source framework with a high-performance built-in simulator | | [Amazon Braket](https://github.com/amazon-braket/amazon-braket-default-simulator-python) | Python | Full-stack | AWS Braket SDK's local statevector / density-matrix simulators | | [Intel Quantum Simulator (IQS)](https://github.com/intel/intel-qs) | C++ / MPI | Standalone | Distributed-memory state-vector simulator, formerly qHiPSTER | | [Qulacs](https://github.com/qulacs/qulacs) | C++ / Python | Standalone | Fast state-vector simulator with SIMD, OpenMP and GPU support | | [QuEST](https://github.com/QuEST-Kit/QuEST) | C | Standalone | Multithreaded, distributed, GPU-accelerated statevector and density-matrix simulator | | [qsim](https://github.com/quantumlib/qsim) | C++ | Standalone | High-performance state-vector simulator, usable via Cirq or on its own | | [Stim](https://github.com/quantumlib/Stim) | C++ / Python | Standalone | Very fast stabilizer-circuit simulator, built for QEC research | | [NVIDIA cuQuantum](https://github.com/NVIDIA/cuQuantum) | C++ / Python (CUDA) | Standalone | GPU-accelerated libraries (cuStateVec, cuTensorNet) used as a backend by many simulators | | [MQT DDSIM](https://github.com/munich-quantum-toolkit/ddsim) | C++ / Python | Standalone | Decision-diagram based simulator from the Munich Quantum Toolkit | | [quimb](https://github.com/jcmgray/quimb) | Python | Standalone | Tensor-network library used for large circuit simulation | ### Tightly-Integrated vs Heterogeneous Quantum Stacks ```{figure} ./images/integrated_heterogeneous.png :align: center Tightly-integrated vs heterogeneous quantum stack ``` - Tightly integrated quantum stacks are stacks in which the software layer and the quantum computing layer are developed by the same provider. - Heterogeneous quantum stacks are stacks in which their elements are developed by different providers. ### High-Level Quantum Software - A quantum programming environment is a type of human-computer interface used to create programs to run on quantum computers or quantum software simulators. - Once a quantum program is created, similar to classical programs, it can be compiled into instructions that your choice of hardware can understand and execute. - Some quantum programming languages (QPLs) are standalone languages (e.g. [Q#](https://github.com/microsoft/qdk), [Silq](https://silq.ethz.ch/)), while others are libraries/extensions added on top of an existing classical language. - Most quantum programming libraries today are built on Python (e.g. [Qiskit](https://github.com/Qiskit/qiskit), [PennyLane](https://github.com/PennyLaneAI/pennylane)), though other languages are supported too, such as Julia ([Yao.jl](https://github.com/QuantumBFS/Yao.jl)) or the C ++ ([Intel SDK](https://www.intel.com/content/www/us/en/developer/tools/quantum-sdk/overview.html)). - Aside from generic quantum languages and libraries, there are also specialised languages and libraries designed and optimised for specific application domains, like quantum chemistry, QNLP and QML. For example, [Tequila](https://github.com/tequilahub/tequila) is geared towards solving problems in the quantum chemistry domain, while [Lambeq](https://github.com/Quantinuum/lambeq) represents sentence grammatical structure in the form of a quantum circuit: the sentence "John walks in the park" is deconstructed using diagrammatic methods and then represented as a quantum circuit, which can be used in NLP applications such as classification or sentiment analysis. ```{figure} ./images/john_walks_in_the_park.png :align: center Image example of lambeq library ``` ### Low-Level Quantum Software - Low-level quantum software refers to intermediate representation (IR) languages that serve as an interface between many high-level quantum software languages and the target quantum computing hardware. - In a similar way to classical programming, high-level languages are translated to an intermediate language, which is then used to apply the instructions to quantum hardware. - One of the more common intermediate languages is [OpenQASM](https://openqasm.com/). For example, a Bell state written in high-level Qiskit code compiles down to the equivalent OpenQASM circuit. - Some consider these intermediate representations the equivalent to assembly in the classical programming world. They provide similar functionality: different high-level QPLs can be compiled to the same IR, which provides a mechanism to target different quantum systems with the same high-level code.