Gain insights into quantum computing, starting with qubits and quantum mechanics. Discover quantum gates, circuits, and algorithms like Grover’s search and Shor’s factoring. Explore potential applications.

Intro to Quantum Computing_Getting started with Burp Suite extension.png

tarball.tar.gz

Quantum Computing

Jupyter Notebook

Firms like IBM, Honeywell, Zapata, Rigetti, Amazon, Google, IonQ, and others are all adopting and investing heavily in quantum computing. This is a great opportunity to get involved.

In this course, you will learn the fundamentals of quantum computing, starting with quantum bits or qubits. These are the centerpiece and most basic computational unit. 

You will then move on to quantum mechanics and the role of quantum gates, circuits, and simulating computers. From there, you will get acquainted with the many different quantum algorithms that are asymptotically faster than their classical counterparts. These include: Deutsch Jozsa, Grover’s search, and Shor’s factoring.

By the end of this course, you will have the foundations in place to start exploring more applications of quantum computing. This is just the beginning!

The Fundamentals of Quantum Computing

So far, we've learned what a quantum state is and its different properties but only in the context of a single qubit. However, a single qubit can't really do much. What we are really interested in is how we can study multiple qubits and their states.

# Two qubits
Let's start by taking an example of two qubits, both initially in the $|0\rangle$ state.

We can simply represent the **combined** state of the two qubits as $|00\rangle$. Now, what does this mean in vector form? In vector notation we take the **tensor-product** or **outer product** of the vectors as $|0\rangle \otimes|0\rangle$. To keep things simple and avoid writing huge vectors and matrices, we use the **bra-ket notation**, $|00\rangle$.

## Qubits in superposition
Things get interesting when our qubits are in a **superposition**. Building from the knowledge about a single qubit in superposition being both $|0\rangle$ and $|1\rangle$ simultaneously, **two** qubits in superposition would be in **four** different states at the same time. Let's see how this works. 

Our first qubit is in a superposition, so we can represent it as $|q_0\rangle = |0\rangle + |1\rangle$. Let's ignore the **amplitudes** for the sake of this example. Similarly, our second qubit can be represented as $|q_1\rangle = |0\rangle + |1\rangle$ as well. We'll pair up all the combinations of these states together as we did for the simple $|00\rangle$ example. Our combined state would look something like this. 

$$|q_1q_0\rangle = |00\rangle + |01\rangle + |10\rangle + |11\rangle$$ 

An easy way to remember them is binary counting, i.e. the **four** states are 0, 1, 2, and 3 but in binary numbers.

Working this out formally, we can take the **tensor-product** of the two states. It will provide us with the same result.

$$|q_1q_0\rangle = |q_1\rangle \otimes |q_0\rangle$$

$$|q_1q_0\rangle = (|0\rangle + |1\rangle) \otimes (|0\rangle + |1\rangle)$$

$$|q_1q_0\rangle = |00\rangle + |01\rangle + |10\rangle + |11\rangle$$



# Exponential power
Here lies the real power of **superposition** as we see that two qubits can represent four binary numbers simultaneously. And thus, this relationship grows **exponentially**.

An $n$ qubit system would be in a superposition of $2^n$ different states simultaneously.

However, there is a caveat. Vectors with these **complex-numbers** don't equate to anything tangible in the real world. It's important to understand that these **superposition** states can't be observed in reality. You cannot use two qubits to generate four binary numbers that you can actually store somewhere, that's the classical way of thinking about computation, and we must keep that out.

We'll finally see how we can use quantum states to perform computation. It's not as simple as it may seem right now. Hopefully, all will be made clear in subsequent lessons.






We've looked at the properties of a quantum state, now let's understand the states of multiple qubits.

Baby Steps

The Essence of Quantum Mechanics

Quantum Gates and Circuits

Simulating Quantum Computers

Getting Started with Quantum Algorithms

The Deutsch-Jozsa Algorithm

Grover's Search Algorithm

Shor's Factoring Algorithm

The Future

Multi-Qubit States

Two qubits