# A gentle introduction to quantum computing

Interested in Quantum Computing but afraid it’s too hard to grasp? Here’s a gentle introduction so that you can get enough knowledge While we might not be able to understand or utilize Quantum Computing in our daily lives fully, we cannot deny its importance in the future of computing. This blog post serves as a gentle introduction to get a better understanding and further explore its use.

Here’s our Coding with Nylas Livestream video to get a better understanding:

## What are Quantum Computers?

Quantum computers rely on naturally occurring quantum-mechanical phenomena, basically superposition and entanglement. We’ll go into detail about these two states in the following sections!

These two states can drastically increase computational speeds in complex sets of data, although they are not meant to be used on every computational problem.

While classical computers use bits, Quantum computers use Qubits:

In classical computers, a Bit can be either 0 or 1. In Quantum computers, a Qubit can be either 0 or 1, but it can also be both values simultaneously, which is called Superposition.

A Qubit is a two-dimensional vector space:

But of course, with Superposition, it can become:

Both Alpha and Beta are complex numbers and together they follow:

## What is Entanglement?

Entanglement means that a pair or group of particles are linked together, and they cannot be described separately. No matter if they are separated by a million years away.

In other words, let’s say we have two boxes, each containing a ball. The ball can be red, yellow or both colours at the same time. Let’s say we close the boxes, and take a look at the ball on the first box, if it’s yellow when we look at it, then the ball on the second box will be yellow as well. If we close both boxes and look at the ball in the second box first, and it happens to be red, then we can know that the ball in the first box will be red as well.

They can be both colours at the same time as well. This is critical concept to understand in Quantum Computing.

## Why would this matter to us?

Quantum computers can handle a lot of data in a fast way. Although quantum computing is not meant for every kind of problem.

Its uses are:

• Machine Learning
• Optimization
• Biomedical simulations
• Financial services

Quantum Computers need an operating temperature of 15 millikelvin which is roughly equivalent to -237 Celcius or -459 Fahrenheit.

## Can we even use Quantum Computing?

Gladly, we can and even when it’s just a simulation, we can do it locally:

`\$ pip3 install qiskit`

Qiskit is a Python Open Source Framework that can handle up to 24 Qubits.

That might not look like much as IBM Quantum Computers can manage up to 50 Qubits, Alphabet’s can manage up to 72 Qubits and D-wave can manage up to 2,000 Qubits.

Of course, a D-Wave Quantum Computer can cost up to 1.5 million dollars, so being able to handle 24 Qubits is as good as it gets for now.

We might need to install some additional libraries:

```\$ pip3 install matplotlib
\$ pip3 install pillow```

Qiskit is composed of four elements broken down as follows:

• Terra – The Earth element is the core of the Qiskit framework.
• Aer – The Air element is a high-performance quantum simulator.
• Ignis – The Fire element is dedicated to fighting noise and errors.
• Aqua – The Water element is for algorithms used in real-world applications.

## The Bell State

One of the most simple but at the same time most important examples in Quantum computing is the Bell State.The Bell State involves two Qubits and represents both Superposition and Entanglement. This means that if we measure a Qubit and get a result of 1, the other Qubit will measure 1 no matter what.

This is the basis for Quantum Communication and Quantum Teleportation.

Let’s create the following script and call it Quantum_Bell_State.py:

```# Import libraries
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer
from qiskit.tools.visualization import *
from PIL import Image
import matplotlib.pyplot as plt

q = QuantumRegister(2) # Two Qubits
c = ClassicalRegister(2) # Two Bits

bell_state = QuantumCircuit(q, c) # Quantum Circuit
bell_state.cx(q, q) # Entanglement. CNOT gate.
bell_state.measure(q, c) # Measure value

# Use the simulator to get the measurements
job = execute(bell_state, backend = BasicAer.get_backend('qasm_simulator'), shots=1000)
result = job.result() # Get the result back from the job
bell_state.draw(output='mpl') # Draw the circuit
plt.show() # Display the circuit
fig = plot_histogram(result.get_counts(bell_state)) # Generate the image
fig.savefig("bell_state.png") # Save the image
image = Image.open("bell_state.png") # Open the image
image.show() # Display the image```

We can run this by typing on the terminal:

`\$ python3 Quantum_Bell_State.py`

In this diagram, we can that we have two Qubits, and we apply a Hadamard gate first to create a Superposition state on both and then a CNot gate to create an Entanglement state, linking together both Qubits.

Finally, we measure both Qubits.

As we can see, we have a 48.7% chance that both Qubits are going to measure 0 and a 51.3% chance that both Qubits are going to measure 1.

We need to start learning what a Half Adder is. A Half Adder is an electronic circuit that performs the addition operation on numbers. While it can only sum two bits, it’s the foundation for more powerful operations.

A and B are the input bits. S is the sum and C is the carry.

1 + 1 equals 10 because that’s 2 in binary.

A Full Adder has 3 inputs and two outputs. Full Adders are great because they can be chained:

```# Import libraries
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, BasicAer, execute
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.visualization import *
from PIL import Image
import matplotlib.pyplot as plt

q = QuantumRegister(5) # Five Qubits
c = ClassicalRegister(5) # Five Bits
qc = QuantumCircuit(q, c) # Quantum Circuit

qc.x(q) # Pauli X gate
qc.x(q) # Pauli X gate
qc.ccx(q, q, q) # Toffoli Gate
qc.cx(q, q) # CNot gate
qc.x(q) # Pauli X gate
qc.ccx(q, q, q) # Toffoli Gate
qc.cx(q, q) # CNot gate
qc.cx(q, q) # CNot gate

qc.measure(q, c) # Measure value
qc.measure(q, c) # Measure value

# Use the simulator to get the measurements
job = execute(qc, backend = BasicAer.get_backend('qasm_simulator'), shots=1000)
result = job.result() # Get the result back from the job
qc.draw(output='mpl') # Draw the circuit
plt.show() # Display the circuit
fig = plot_histogram(result.get_counts(qc)) # Generate the image
image = Image.open("full_adder.png") # Open the image
image.show() # Display the image```

On the terminal, we can run this:

`\$ python3 Quantum_Full_Adder.py`

We have 3 Qubits, q00, q01 and q03. We apply a Pauli X Gate (X) to perform a bit-flip operation, which means changing their state from 0 to 1 on q00 and q01.

Next, we apply a Toffoli gate, which is pretty much an AND gate. It receives 2 inputs and returns 1 output. If the inputs are 1, it inverts the output, otherwise, it does nothing.

Then, we apply a CNOT (Controlled Not Gate), which is pretty much an XOR gate. The target will change only if the control is 1. q00 is the control and q01 is the target.

At this point, we have a Half Adder.

We apply a Pauli X Gate (X) on q02.

Next, we apply a Toffoli gate on q01 and q02 with a target on q04.

Then we apply a CNOT gate, where the control is q01 and the target is q02.

Finally, we apply a CNOT gate, where the control is q00 and the target is q01.

We measure the results coming from q01 and q02:

We know that 1 + 1 + 1 is going to be 3, because 0011 in binary is 3. And we can see that we have a 100% chance that this will happen.

## Generating a Word

Using Binary, we can represent letters, for example, The letter a is 01100001, which means that a single letter takes up to 8 bits.

Actually, by doing a bit of research, we can figure out that the first 3 bits 001 never change.

With that in mind, we can create a small application that will take 24 bits, that’s 3 characters and create 3 letter words.

Now, we need to make sure that the generated letters are valid, and that’s where the Enchant library comes in. To install it, do

`\$ pip3 install pyenchant`

Note: If you are on a Mac, also install the enchant library using Brew, before installing the Python package:

`\$ brew install enchant`

We’re going to call this file, Quantum_Words.py:

```# Import libraries
from qiskit import IBMQ, BasicAer, execute
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
import enchant

d = enchant.Dict("en_US")
q = QuantumRegister(24, 'q') # Twenty four Qubits
c = ClassicalRegister(24, 'c') # Twenty four Bits
qc = QuantumCircuit(q, c) # Quantum Circuit

# First letter
qc.x(q) # Pauli X gate
qc.x(q) # Pauli X gate

# Second letter
qc.h(q)
qc.h(q)
qc.h(q)
qc.h(q)
qc.h(q)
qc.x(q)
qc.x(q)

# Third letter
qc.h(q)
qc.h(q)
qc.h(q)
qc.h(q)
qc.h(q)
qc.x(q)
qc.x(q)

# Measure all 24 Qubits
for j in range(24):
qc.measure(q[j], c[j])

# Use the simulator to get the measurements
job = execute(qc, backend=BasicAer.get_backend('qasm_simulator'), shots=100)
# Get the result back from the job
result = job.result().get_counts(qc)

characterDict = {}
# Separate each result into 8 bits, turning them into letters
for bitString in result:
char1 = chr(int( bitString[0:8] ,2))
char2 = chr(int( bitString[8:16] ,2))
char3 = chr(int( bitString[16:24] ,2))
# Put all resulting words into an array
characterDict[ char1 + char2 + char3 ] = result[bitString] / 1024

counter = 0
# Loop through all the generated words
for char in characterDict.keys():
# Using pyenchant, find which ones are valid
if d.check(char) == True:
# Count the valid words
counter += 1
# Print them out
print(char)

# Out of a 100, how many are actually valid?
print(str(counter) + " valid words of a generated 100")  ```

Starting from the right side, we create Superposition on all the values that can change using Hadamard gates.

For the ones that will not change, we can negate using a Pauli X Gate, as they need to be 1.

Once they are all defined, we simply measure them in order to get their results.

We read the generated binary numbers, separated by packs of 8 bits, turn them into letters and make words with them.

By using the enchant library, we can make sure they are valid words.

This application is slow, but we’re using 24 Qubits and trying to generate a 100 words.

Using Quantum Computing on non Quantum Computers is still slow but getting better over time.

We can run this by typing on the terminal:

`\$ python3 Quantum_Words.py`

Note: If you’re on a Mac, you might get this error message:

While the enchant library is installed, its path is not always defined, so we need to use Brew to install it. But there’s a simple fix, just run the following:

`\$ PYENCHANT_LIBRARY_PATH=/opt/homebrew/lib/libenchant-2.dylib PYENCHANT_VERBOSE_FIND=x python3 Quantum_Words.py`

Here we have generated 4 valid words:

While here on 2.

Hope you will find out that Quantum Computing is not that hard.

Like what you read but looking for some Nylas content, make sure to check our great selection of blog posts.

## What’s next?   