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

In the last chapter, we saw the definitions of various quantum gates (shortened as 'gates' henceforth) and the operations they perform. As you would recall, gates are matrices. We can use **NumPy** to define multi-dimensional `arrays` or `lists`. In fact, we encourage you to try defining some basic gates studied earlier in the code editor below. Once you are confident, you can compare your implementations with ours and see how well you did.

import numpy as np
import math

# Try defining the identity, pauli x/y/z, hadamard gates yourself  
# your code here.

# Single-qubit gates

In this section, we will learn how to define the following single-qubit gates:

* Identity gate
* Pauli-X gate
* Pauli-Y gate
* Pauli-Z gate
* Hadamard gate

## Identity gate
Starting with the simplest gate. We know the Identity Gate $I$ does not affect the state of a qubit. What goes in, however it goes in, comes out the same. Thus, on a single qubit, the Identity Gate is defined as follows:

$$I=\begin{bmatrix}1&0\\0&1\end{bmatrix}$$

We can use a `2x2` array in `matrix` to easily define the above gate.

import numpy as np

identity = np.array([[1, 0],[0, 1]])

'''
another way of creating the gate above would be:
  
  identity = np.identity(2)

here the 2 defines the dimensions we want 
'''

print("Identity Gate: ")
print(identity)

## Pauli gates

We've studied three **Pauli gates**. First, the **Pauli-X** gate $X$ can be considered the classical **NOT** gate, whereby it simply interchanges the amplitudes of $|0\rangle$ and $|1\rangle$ in an arbitrary state $\alpha|0\rangle+\beta|1\rangle$. Visually, we can represent this process as rotating the qubit's state vector by $\pi$ around the **X-axis**. The **Pauli-X** gate is defined as follows:

$$X=\begin{bmatrix}0&1\\1&0\end{bmatrix}$$

Moving on, recall that the **Pauli-Y** gate $Y$ causes a rotation of $\pi$ radians on the **Y-axis**. Mathematically, the gate is defined as follows:

$$Y=\begin{bmatrix}0&-i\\i&0\end{bmatrix}$$

Finally, recall that the **Pauli-Z** gate $Z$ causes a rotation of $\pi$ radians on the **Z-axis**. Mathematically, the gate is defined as follows:

$$Z=\begin{bmatrix}1&0\\0&-1\end{bmatrix}$$

As before, we can use multi-dimensional `arrays` in **NumPy** to define these gates, using $j$ to define complex numbers in Python. The implementation of all three Pauli gates is given below.




In this lesson, we shall define the quantum gates using NumPy and Python.

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

Simulating Quantum Gates in Python

Single-qubit gates

Identity gate

Pauli gates