Simulate Quantum Particles with Python and Qiskit

Code walkthrough on a classical and quantum computer.

View the complete code on my GitHub

Since their birth, quantum computers have been seen as a promising tool to be able to simulate what is happening at the quantum scale. In the status quo, we rely on computationally inefficient algorithms attempting to simulate quantum phenomena. Instead, why don't we just simulate quantum phenomena with the power of … quantum phenomena?

Quantum computers utilize particles on the quantum scale to store and process information. They have the unique ability to take on a continuum of states and generate interference between qubits. Utilizing these computers, simulating quantum mechanics becomes exponentially more efficient.

(For an in-depth refresher on the basics of quantum computers, refer to this article.)

Those who are familiar with basic quantum mechanics know that extremely small particles don’t behave in a predictable way. If I kick a soccer ball, I know exactly where it is going and where it is going to end up. At a quantum scale, the motion of small particles (i.e. electrons) is governed by, what is mathematically best described as, waves of probability. Formally, we call these “waves of probability” wave functions.

The graph below is a visual representation of a wave function. The amplitude of the wave relates to the probability of the particle being at that point in space.

This article provides the math and code behind using the split operator method to simulate the evolution of a particle’s wave function on a quantum computer. Feel free to skip around in the article to whatever section is most interesting to you:

1) Exploring the math behind the split operator method [click here]
2) Coding the algorithm on a classical computer (with python) [click here]
3) Coding the algirthm on a quantum computer (with python/qiskit) [click here]

The Math Behind the Split Operator Method

Erwin Shrödinger gave us the Shrödinger equation to describe an electron’s wavefunction based on external conditions.

In this differential equation, ℏ is the reduced Planck’s constant, Ĥ is a time-independent Hamiltonian, and ψ is the wavefunction of the particle (what we are solving for). A Hamiltonian represents the “total energy” of a system, including both its kinetic and potential energy.

We can integrate the equation on both sides to get the following:

We can now use this equation to find a particle’s wavefunction at time t based on its initial wavefunction and the hamiltonian of the system.

The term exp(-iĤt/ℏ) is used to calculate how the wave “propagates” over time, and is appropriately named the propagator.

As previously mentioned, Ĥ can be broken down into kinetic (T) and potential (V) energy:

Our high school physics knowledge covers the basics of breaking down kinetic energy in terms of momentum (p):

In an ideal world we can break down our propagator into kinetic and potential energy in one easy step:

Unfortunately, the two operators don’t commute. Concretely, exp(T+V) is not equal to exp(T)*exp(V). However, the Lie-Trotter product formula gives us an alternate way to split the two:

This essentially splits the propagator into an infinite amount of smaller steps alternating between the kinetic and potential propagators. The smaller the step, the more accurate our result will be. To reduce error, we can further split this by applying a half step of the potential propagator, a full step of the kinetic propagator, and the second half step of the potential propagator:

Substituting this into our integrated Shrödinger equation gives us:

Projecting this onto a coordinate basis ∣x⟩ gives us:

which can be simplified into our algorithm:

Note that we apply each operator on the RHS from right to left. The two integrals are just Fourier and inverse Fourier transforms to convert between the coordinate and momentum basis.

To translate the formula above, the algorithm will consist of 5 steps per time step/iteration:

1. Apply a half step of the potential propagator to the initial state ψ
2. Fourier transform into the momentum basis
3. Apply a full step of the kinetic propagator on the momentum basis
4. Inverse Fourier transform back into the coordinate basis
5. Apply another half step of the potential propagator

*Note: I learned the math behind the algorithm from this video

Using Python to Code the Algorithm

Coding this on a classical computer is relatively straightforward. The equation above gives us our entire algorithm.

Here are all the libraries we are going to use. The first two lines are packages to better visualize+animate the wavefunction. Numpy allows us to work with arrays and makes the math a lot simpler to code.

from matplotlib import animation, rc, pyplot as plt

from IPython.display import HTML

import numpy as np

Next, let’s introduce some constants that we are going to be using in our code.

'''constants'''

N=500 #number of grid points

hbar=1 #reduced plancks constant

dt=0.5 #delta t, or the time step

m=1 #mass of particle in au

We then initialize spatial (x) and momentum (p) grids to apply the potential and kinetic propagators respectively. They are defined as follows:

np.linspace returns a NumPy array with N evenly spaced numbers between xMin and xMax, whereas np.arrange returns a NumPy array of all integers between -N/2 and N/2 with a default step size of 1.

'''spatial grid'''

xMin=0

xMax=500

x=np.linspace(xMin, xMax, N)

'''momentum grid'''

p=np.arange(-N/2, N/2)*((2*np.pi*hbar)/(N*((xMax-xMin)/(N-1))))

Now that we have our constants and spatial/momentum grids, we can start our algorithm by creating the initial wavefunction of the particle.

The initial wavefunction is defined by the following equation:

where sigma can be interpreted as controlling the width of the initial wave, x0 as the initial position, and k0 as the initial momentum. Coding this equation is as simple as typing exactly what you see above.

'''wavefunction: guassian wavepacket'''

k0=m/2 #initial momentum

x0=xMax/2 #initial position

sigma=(xMax-xMin)/30 #width

psi=(1/(sigma*np.sqrt(2*np.pi)))*np.exp(-.5*((x-x0)/sigma)**2)*np.exp(1j*k0*x)

Graphing psi with matplotlib gives us the following:

Next, we have to define the propagators used in each iteration of the algorithm, beginning with the potential propagator. The potential energy of the system can be defined any way you like. To simulate a free particle set the potential energy to 0, and to create barriers set the potential energy to a certain value within the interval in space you would like the barrier to exist. The half step of the potential propagator is defined by the exponential derived in the first section of this article: exp(-iVt/2h).

'''potential operator+propogator'''

Vhat=np.zeros_like(x) #free particle

Vhat[400:499]=1 #add well between x=[400,499] (optional)

Vprop=np.exp(-1j*dt*Vhat/(2*hbar)) #half step

Graphing psi and V gives us the following:

Next, we define the kinetic propagator, given by the exponential derived in the first section: exp(-iTt/h) where T=p²/m.

'''kinetic operator+propogator'''

That=p**2/(2*m)

Tprop=np.exp(-1j*dt*That/hbar)

Finally, we define one time-step of our algorithm using the equation derived in the first section. A 1/2 step of the potential propagator, Fourier transform, a full step of the kinetic propagator, inverse Fourier transform, and finally, 1/2 step of the potential propagator is applied to the wavefunction psi.

np.fft.fft and np.fft.ifft apply a fast Fourier transform and inverse fast Fourier transform respectively.

'''function for one step of split operator method'''

def splitOperator(psi,Vprop=Vprop,Tprop=Tprop):

  psi*=Vprop #1/2 step of potential propagator

  psi_p=np.fft.fft(psi) #shift to momentum basis

  psi_p*=Tprop #kinetic propagator

  psi=np.fft.ifft(psi_p) #shift back to spatial basis

  psi*=Vprop #1/2 step of potential propagator

  return psi

The algorithm is finished! Taking the initial wavefunction and updating it with the splitOperator() function for the desired number of iterations will simulate the evolution of the quantum state ψ. The following code animates the evolution of ψ in Python:

'''animate'''

# First set up the figure, the axis, and the plot element we want to animate

fig, ax = plt.subplots()

plt.close()

### parameters for plot

ax.set_xlim(( 0, 500))

ax.set_ylim((-0.001, 0.001))

line, = ax.plot([], [], lw=2)

lineV, = ax.plot([], [], lw=2)

# initialization function: plot the background of each frame

def init():

  line.set_data([], [])

  lineV.set_data([], [])

  return (line, lineV,)

def animate(i):

  global psi

  psi=splitOperator(psi)

  line.set_data(x, np.conj(psi)*psi)

  lineV.set_data(x, Vhat)

  return(line, lineV,)

anim = animation.FuncAnimation(fig, animate, init_func=init,

frames=400, interval=10, blit=True)

# Note: below is the part which makes it work on Colab

rc('animation', html='jshtml')

anim

Using Qiskit to Code the Algorithm on a Quantum Computer

The algorithm on a quantum computer is similar to the algorithm we just coded, except we do not split the potential propagator into two half steps. The steps are listed below:

1. Initialize the wavefunction discretized into 2^N gridpoints, where N is the number of qubits (excluding ancillary) used in the circuit.
2. Apply the potential propagator exp(-iVt).
3. Apply a Quantum Fourier Transform (QFT)
4. Apply the kinetic propagator exp(-iTt)
5. Apply an inverse QFT
6. Repeat steps 2–5 for the desired number of iterations
7. Measure the circuit

Hardware on current quantum computers is extremely limited. Thus, we can’t casually create 500 grid points (using 9 qubits) in our spatial grid without incurring a large amount of error. For this code, we are using 7 qubits, allowing for 2⁶ (64) grid points and 1 ancillary qubit.

Here are all the libraries we import to run the code. Qiskit is a library that allows us to code on real or simulated quantum computers. Usually, pylatexenc isn’t required as an import, however, on Google Colab I needed to write a separate import statement to be able to visualize my quantum circuits. (specifically running circuit.draw(‘mpl’) where the circuit is just any quantum circuit object)

from qiskit import *

import numpy as np

from matplotlib import pyplot as plt

from qiskit.visualization import plot_histogram

from qiskit.circuit.library import QFT

import pylatexenc

Next, we define some constants:

'''constants'''

n=6 #number of qubits

N=2**n #grid points

phi=0.1 #time step

iterations=50

and the potential energy:

'''potential'''

#V=0 free particle

V=1.75

Note controlling the location of any wells/barriers is done by controlling what gates you apply the potential propagator to.

To apply exp(i*V*phi) to a qubit, we apply a phase gate parameterized by the value V*phi.

For example, to create a well in the second half of the spatial grid apply the potential propagator on the last qubit of the circuit. This is essentially applied to all values between 100000–111111, or x[32:64].

*Note that the first qubit is the ancillary qubit

To create a barrier from 001110 to 001111, we can apply a series of Toffoli and a controlled phase gate to apply the potential propagator on the 3rd, 4th, and 5th qubits.

Next, we must determine how to represent the kinetic propagator, exp(-iTt), where T=p²/m. We can write p as follows:

Thus the whole propagator exp(-ip²t) can be written as follows:

where Z is a phase gate that applies the following operation onto qubit j:

By expanding the squared term in the previous equation it is shown that Z operators are acting on all individual qubits (excluding ancillary) and commuting Z operators acting on all qubit pairs as well. With a phi value of 0.1 and a 7 qubit circuit (q0 is an ancillary qubit), the kinetic propagator looks like this:

The next step is to code a single time step of the split operator algorithm using the propagators we defined above:

qubits=QuantumRegister(n+1)

splitOp=QuantumCircuit(qubits,name="splitOp")

'''potential operator'''

#adding a barrier from 001110 to 001111

splitOp.ccx(3,4,0)

splitOp.cp(V*phi,0,5)

splitOp.ccx(3,4,0)

splitOp.barrier()

'''QFT'''

splitOp.append(QFT(n),qubits[1:])

'''momentum operator'''

for i in range(n):

  splitOp.p(phi/2**(n-3+i), n-i)

for i in range(n):

  for j in range(i+1,n):

    splitOp.cx(n-j,0)

    splitOp.cx(n-i,0)

    splitOp.p(phi*(2**(2-i-j)),0)

    splitOp.cx(n-i,0)

    splitOp.cx(n-j,0)

'''inverse QFT'''

splitOp.append(QFT(n,inverse=True),qubits[1:]) #inverse QFT

splitOp.barrier()

#splitOp.draw('mpl')

We then build our final circuit based on the number of iterations defined at the beginning of the code. First, we initialize the gaussian wavepacket onto our qubits and then add the splitOp circuit for each time step. Each qubit (minus the ancillary) is measured onto a classical bit. The circuit is run on Qiskit’s qasm_simulator and stored in the answer dictionary:

q=QuantumRegister(n+1)

c=ClassicalRegister(n)

circuit=QuantumCircuit(q,c)

'''initialization'''

circuit.initialize(psi,q[1:])

circuit.barrier()

'''time steps'''

for i in range(iterations):

  circuit.append(splitOp,q[:])

'''measurement'''

for i in range(1,n+1):

  circuit.measure(i,i-1)

#circuit.draw('mpl')

answer = execute(circuit, backend=BasicAer.get_backend('qasm_simulator'), shots=5000).result().get_counts()

The following code plots the results on a histogram:

for a in range(N):

  s = bin(a)[2:]

  while len(s)!=6:

    s='0'+s

  if s not in answer.keys():

    answer[s] = 0

plot_histogram(answer, figsize = [20,10])

Above we can see a particle tunneling through a barrier from 001110 to 001111.

What’s Next?

After learning the basics of how to simulate one particle moving with the split operator method, the next step is looking at interactions between particles and chemical dynamics. Research in particle simulation has applications in drug development, condensed matter physics, material science, etc.

Thank you for reading my article! If you enjoyed reading, press the clap button below. Here are links to connect with me and see what I am up to:
Linkedin
Github
Email: lohitpotnuru@gmail.com

References

https://www.youtube.com/watch?v=o96K8fkOrG8&t=327s

https://www.youtube.com/watch?v=7Bsx_4hOU3g&t=4470s

https://fount.aucegypt.edu/cgi/viewcontent.cgi?article=1020&context=capstone

https://drive.google.com/viewerng/viewer?url=https://repositorium.sdum.uminho.pt/bitstream/1822/59739/1/Afonso-Miguel-Fernandes-Rodrigues-disserta%25C3%25A7%25C3%25A3o.pdf

More content at plainenglish.io. Sign up for our free weekly newsletter. Get exclusive access to writing opportunities and advice in our community Discord.

Simulation of Quantum Particles with Python and Qiskit was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Github repo with my code

This article gets a bit technical. Some background in linear algebra or quantum mechanics may be helpful for better understanding. If you don’t have that, no worries. Don’t be scared of the math, as most of it I tried explaining simply. For some basics of quantum mechanics and quantum computing, read this article.

My project is based on this paper

“Nature isn’t classical, dammit, and if you want to make a simulation of nature, you’d better make it quantum mechanical, and by golly it’s a wonderful problem, because it doesn’t look so easy.”-Richard Feynman

One of the key problems that quantum computers aim to solve is being able to model quantum systems, which are notoriously hard for classical computers to handle. After all, what better way is there to model quantum particles than with a computer that runs on quantum particles?

To model n particles in a quantum system, it would take 2^n bits. Simulating just 40 particles would take around 10¹² bits — rivaling some of the biggest supercomputers in the world today. Simulating 256 particles would take 10⁸⁰ bits- which is around the number of atoms in the known observable universe.

Luckily for us, because quantum computers are also quantum, representing n particles in a quantu system would take a proportional number of qubits. The number of qubits needed would grow linearly, rather than exponentially, to meet the processing needs of simulating a quantum system. One can quickly see how using 256 qubits to simulate a relatively small number of 256 particles would be vastly more efficient than trying to tackle the problem using 10⁸⁰ bits.

The Quantum Many-Body Problem

Quantum many-body systems are systems of multiple interacting quantum particles. Interacting quantum particles entails wave functions, entanglement between particles, the whole shebang.

“Understanding interacting quantum many body systems and engineering and exploiting such quantum systems for quantum information purposes pose some of the most outstanding challenges in quantum physics.”- Prof. Dr. Immanuel Bloch

The problem of predicting the properties of these systems from the first principles of quantum mechanics is key in fields such as quantum chemistry, condensed matter physics, and material science.

One method of modeling a quantum system is using the Transverse Ising model (TIM), which is what my project revolves around.

The Ising Model

(based on this video)

Before looking at the TIM, it is best to start off at the classical Ising model. Developed to model ferromagnetism, it helps us find the hamiltonian of a given system, and is used by physicists to study things like phase transitions. Simplified, a hamiltonian is just a way to look at the total energy within a system.

(the following explanation is taken from this video)

To understand the Ising model, let’s take two magnets that run antiparallel to each other (since that is naturally its lowest energy configuration).

The equation on the right gives us our hamiltonian. If we assign a spin-up (+1) and spin-down (-1) value to the magnets, we can calculate the hamiltonian by multiplying the two.

Now let's add a third magnet that runs antiparallel to the first.

To find the new hamiltonian we add the product of the spin states of magnets 2 and 3. Thus, the new equation is denoted as a sum over the products of the spin states of the nearest neighbors.

Next, we can add a barrier in between the magnets, signifying an external force that is able to control the strength of the interactions between each magnet.

The barrier is calculated into the spin state product between each nearest neighbor, as shown by the new hamiltonian.

Finally, we can take into account an external field that interferes with the individual magnets.

The external field is taken into account by adding the product of the strength of the external magnet with the magnet that it is manipulating.

Once we swap some of our simpler letters for fancy greek letters, we get the following hamiltonian of the Ising model.

The Transverse Ising Model

(the following explanation is taken from this video)

Similar to how the Ising model looks at ferromagnetic spin states/phase transitions, the same can be applied to quantum systems as well.

By looking at spin states of quantum systems- one can categorize different phases. A ferromagnetic phase means the spins are ordered, and once an external magnetic field (in this case h) increases in strength, the spins start to become disordered in a paramagnetic phase.

To apply the same Ising model to quantum systems, we can first take a look at how a Pauli-Z operator acts on a qubit:

When applied to the |0⟩ and |1⟩ qubit states, it creates a +1 and -1 probability amplitude of their wavefunction:

This is able to replicate the +1, -1 basis that we used in our classical Ising model, which allows us to substitute the Pauli z operator to our previous hamiltonian equation:

However, the terms in this equation commute (doesn’t matter in what order you multiply them), and the equation of this Hamiltonian essentially becomes a classical scalar energy function (read more here).

Thus, we have to add a transverse field interaction, with a sigma x (Pauli x) operator

that doesn’t commute with the sigma z (Pauli z) operator

Thus we can add the sigma x operator to the Hamiltonian equation to give us

How does adding a transverse field give us a “quantum” effect?

First, let’s look at the eigenvectors of the Pauli z and x matrices. An eigenvector of a matrix is a vector that follows the following rule:

A is a (n*n-dimensional) square matrix, v is a (n-dimensional) column vector, and λ is a scalar value.

Here, v is an eigenvector of matrix A, because when you multiply the two you get the same vector v, just multiplied by some scalar value. The scalar value λ is known as the eigenvalue.

For example, we saw the Pauli z matrix beforehand, whose eigenvectors were actually the basis vectors |0⟩ and |1⟩.

Here the eigenvalues for both eigenvectors are 1 and -1 respectively.

Our objective is to look at the ground state energy of the Transverse Ising Model, and the lowest eigenvalue is associated with the lowest energy of a specific operator.

We already have the eigenvectors/values for the first operator in our hamiltonian, the Pauli z operator. The eigenvectors for the Pauli x operator are shown here:

The two eigenvectors essentially represent two states of equal superposition, each with a 1/2 probability of collapsing down to the |0⟩ or |1⟩ states.

Thus, the Pauli z terms in our hamiltonian find their lowest energy states in the classical |0⟩ or|1⟩ states, whereas the Pauli x terms in our hamiltonian find their lowest energy states in a quantum superposition. The addition of this new non-commuting term to our hamiltonian has allowed us to take the classical Ising Model and use it to represent the “quantum-ness” of quantum particles.

For my project, I based the code off of this paper, using the following simplified equation for the hamiltonian of the TIM

where different values of h affect the quantum phase in the following way

Why Find the Ground State Energy of the TIM?

Studying matter at the ground state gives us the low-temperature properties of a system, where quantum effects are the highest.

It is also a really hard problem that is a major objective of fields such as condensed matter physics (considered an NP-hard problem)

In chemistry, it gives insight into the electron configurations of molecules and is key to help simulate them as well.

Using a Variational Quantum Eigensolver (VQE) to Find the Ground State Energy of the TIM

Finding the lowest energy of a hamiltonian can be found by finding its smallest eigenvalue. To reiterate, the eigenvalue (λ) of a matrix (A) is defined as follows:

where v is an eigenvector of the matrix. For the Pauli z operator, its eigenvectors are the |0⟩ and |1⟩ states with eigenvalues 1 and -1 respectively.

Though there are algorithms such as quantum phase estimation that can directly compute the eigenvectors/values of the hamiltonian, the large depth of the circuit needed for practical applications of the algorithm requires longer qubit coherence times that aren’t currently available (a major hurdle in quantum computing is having to eliminate all potential sources of external interference, any environmental interference such as radiation from nearby objects could cause the system to decohere).

Thus, in 2014 the variational quantum eigensolver(VQE) was proposed. A variational quantum algorithm approximates answers to given problems by splitting the computation between a quantum circuit and an optimizer run on a classical computer.

The algorithm is based on the variational principle, which states that the minimum eigenvalue of the hamiltonian will always be less than the expectation value of the hamiltonian

Thus, by parameterizing an arbitrary quantum state ψ, we can optimize those parameters to minimize the expectation value and get as close as we can to the actual minimum eigenvalue of the hamiltonian.

Let's break that down more simply….

Think of the VQE like tuning a guitar:

1. You start with the string you want to tune. In this case, the tone of the string is determined by its tension. Similarly, a VQE starts off with some arbitrary quantum state, parametrized by some values θ. Our goal is to tune this state |ψ(θ)⟩.
2. Next, assuming you have some digital tuner attached to the end of your guitar, you pluck the string and see what note it is currently hitting. A VQE tests the expectation value of the hamiltonian based on the parameterized quantum state ⟨H⟩ψ=⟨ψ|H|ψ⟩. (For those familiar with ML, this is similar to a cost function of a given machine learning algorithm)
3. Once you find out the note you are hitting, you determine if the note is too high or low and slightly change the tension accordingly. Similarly, an algorithm run on a classical computer outputs new values for theta that are estimated to be slightly closer to giving you the lowest expectation value, or the perfect note (very similar to how gradient descent works on a regular ML algorithm )
4. Repeat. On a guitar, you would continue to make incremental changes and continue to look at what note you are hitting until you hit the sweet spot you wanted. On our VQE, you would continue to repeat the initialization of a new circuit parameterized by θ, calculation of the expectation value of the hamiltonian, and the optimization of θ until you converged to the parameters θ that gave you the lowest expectation value. This would approximately give you the minimum eigenvalue and eigenstate that corresponds to the ground state of the quantum system.
5. You are finished! You now have the perfectly tuned guitar string, and the perfectly parameterized quantum state. The state and the eigenvalue it corresponds to give you the ground state of the TIM.

Implications

Studying the properties of ground states of TIMs are extremely valuable in fields such as condensed matter physics, quantum chemistry, molecular physics, and more. Similar to the fruit fly in genetics, ground states of many-body systems are the base of a lot of research in those fields

On the other hand, VQEs are groundbreaking in quantum chemistry- specifically modeling chemical interactions and even speeding up the drug discovery process by allowing for computer simulations. However, VQEs are not only limited to simulating chemistry/physics. They can even be applied in finance for something like portfolio optimization.

Thank you for reading my article! You can connect with me on my LinkedIn or email me at lohitpotnuru@gmail.com. Sign up for my monthly newsletter here.

Feel like you’re about to jump into a rabbit hole of reading these incredible articles?
Don’t worry, we feel the same way.
Not only can you jump into the rabbit hole with us, but we’ve got more than enough articles that’ll help you jump out ;)
For some of the best ideas on Medium from the youngest minds of the generation, visit students x students.

students x students

Finding the Ground State of the Transverse Ising Model was originally published in students x students on Medium, where people are continuing the conversation by highlighting and responding to this story.

In 2019, the global production of plastics reached an annual 368 million metric tons. PET plastic is one of the most widely used, present in your single-use water bottles, clothing, and containers. It is currently being produced at a rate of 73.39 million metric tons per year, and by 2026, that number will be 130 million.

We wondered why this was, considering by 2026, there will be at least 230.02 million tons of PET plastic in our oceans. That’s the same weight as 260 golden gate bridges stacked on top of each other.

Currently, we have almost 2 times the global PET plastic demand just sitting there in our oceans, killing 100,000 marine mammals every year and creating 500 dead zones, which will double every decade.

If you are wondering how that affects you, 1 in 3 fish for human consumption contains plastic, and the average seafood eater eats 11,000 pieces of toxic plastic every year. Suddenly, I love a nice ribeye steak.

However, if we could ensure that just 56% of PET plastic in the ocean was recycled per year, we could meet the entire global demand and eliminate the production of new PET.

According to the PET Resin Association, PET is the world’s packaging choice because it is hygienic, strong, lightweight, shatterproof, retains freshness, resistant. Current biodegradable plastics don’t have enough demand or the characteristics that make them a better alternative. PET is not going away anytime soon — but the Earth can. We want to create a sustainable cycle for PET recycling, giving the Earth a chance to breathe by reducing the demand for new PET to zero.

Plastic recycling is ineffective and too expensive.

There are two main ways that plastic is recycled currently:

1. Mechanical Recycling: this is the simplest and most common method of recycling plastic, and it occurs in 5 steps. The first three are collecting, sorting, and washing the plastic, which are pretty self-explanatory. Next, the plastic is ground up into flakes and can be turned into granulate as well. However, during this process, the quality of plastic may be compromised due to processing and/or lifetime degradation. Compared to a cheap-newly produced virgin plastic, any differences in quality entail fear of ruining a companies brand.
2. Chemical Recycling: this entails depolymerizing plastic into its monomer subcomponents (in the case of PET, it can be broken down into components such as TPA, EG, BHET, or other compounds depending on the method used). These can be used to reinforce new polymers or can be purified and sold independently. The main downfall to this process is its extremely high costs, mostly due to the amount of energy it takes to complete the process.

Our solution targets both problems with chemical recycling, specifically by using biodegradation. This minimizes net energy costs to zero, allowing us to sell recycled plastic at competitive prices with both virgin and recycled PET, while not compromising the plastic’s quality.

Our solution uses Microbial Fuel Cells that utilize biochemical reactions to self-sustain.

Microbial fuel cells (MFCs) are essentially biological batteries, utilizing biochemical reactions to generate electricity. One of the main pitfalls of chemical recycling is the extremely high energy costs when creating high temperatures, pressure, etc. However, MFCs can harvest electricity from PET degradation, creating a self-sustaining system that can continuously generate/use electricity to degrade PET and re-synthesize the monomers into recycled PET resin.

MFCs can achieve this in a few key steps:

1. Enzymes in bacteria can break down a given substrate, releasing electrons in the process. This is done in the anode (negative) compartment of the MFC.
2. In the cathode (positive) compartment of the MFC, a final electron acceptor with a high affinity for electrons (usually oxygen) is stored.
3. A conductive material between the two compartments allows the electrons to move freely to the positively charged cathode compartment, where oxygen atoms await to take them up. The electrons are combined with oxygen and protons to create water as a byproduct.
4. The flow of electrons between the anode and cathode compartments creates an electric current that can be stored.

MFCs require sustained electron release in the anode and electron consumption in the cathode. The attainable metabolic energy gain for bacteria is directly related to the difference between the anode potential and the substrate redox potential. The optimal design for MFC is still under investigation, and different materials for the electrodes as well as more selective membranes for proton exchange are being currently developed to enhance their performance. Small cells connected in series offer higher potentials than bigger reactor volumes.

One of the main applications of MFCs currently is for wastewater treatment, and one has even been shown to power an urban wastewater treatment center successfully. Other applications include small biosensors, renewable electricity, bioremediation, and hydrogen gas production. Currently, the main drawback for the full-scale application of MFC is the cost of materials and the low buffering capacity of domestic wastewater.

The power generated from an MFC is limited by the internal resistance of the system components. Though the anode potential is hard to vary since it depends on the respiratory enzymes of the bacteria, most innovation in system design is designed to maximize cathode potential, through differences in final electron acceptors, cathode architecture, proton exchange membranes, and electrode spacing.

We target a specific bacterial enzyme to break down PET.

As previously mentioned, MFCs rely on bacteria to break down the substrate and release electrons. Thus, to break down PET, we set out to find a bacteria that could break down this seemingly indestructible plastic.

In 2016, Japanese scientists discovered a bacterium, Ideonella sakaiensis, that can break down PET plastic. Specifically, the bacterium developed an enzyme dubbed “PETase” that was able to depolymerize PET into its subcomponents. However, it wasn’t efficient enough to break down PET at an industrial scale. To achieve our goal on a large enough scale, we turned to a similar, yet more effective enzyme to break down PET plastic.

A 2019 report describes a more efficient PET hydrolase, LCC, that vastly outperforms other PET hydrolase enzymes:

After adding some improved modifications to the LCC enzyme, ICCG was engineered that could maximize PET degradation:

“Here we describe an improved PET hydrolase that ultimately achieves, over 10 hours, a minimum of 90 per cent PET depolymerization into monomers, with a productivity of 16.7 grams of terephthalate per litre per hour (200 grams per kilogram of PET suspension, with an enzyme concentration of 3 milligrams per gram of PET).”

As shown in the graph, LCC is more than 10,000 times more effective than Is-PETase. ICCG is 33 times more effective than that, making it the most suitable to break down PET at an industrial scale. The ICCG enzyme breaks down PET into a compound called Terephthalic acid (TPA), and ethylene glycol (EG), both of which can be re-synthesized into PET under large amounts of heat and pressure.

We improve current MFC models by using ICCG and minimizing resistance.

We propose an MFC that utilizes ICC to break down PET, creating an electrical current that can then be reused to make the entire system of PET breakdown and recycling self-sustaining.

When constructing our MFC- we first begin with PET degradation. This is done by taking PET substrate (a mixture of PET pieces and water) and allowing the aforementioned ICCG enzymes to break it down. The products of the chemical reaction (TPA and EG) are then collected.

Next, to be able to harvest energy from this reaction, we need to create two compartments for our microbial fuel cell, the anode (negative) and cathode (positive).

Since the reaction between PET and ICCG releases electrons, once they are released they can be conducted to an external circuit.

As mentioned before, the cathode requires an electron acceptor that has a high affinity for them. That way, electrons would be more “willing” to travel over to the positive cathode compartment, where they are taken up by the electron acceptor. Though most MFCs use oxygen as their acceptor, potassium ferricyanide produces 50–80% higher power than oxygen due to increased mass transfer efficiencies and larger cathode potential (source).

This is a diagram of one module within an MFC, however, our MFC is made up of a stack of multiple parallel modules to maximize surface area, minimize resistance, and increase overall electron output. As mentioned before, minimizing internal resistance is key to boost our energy production.

We take into account factors such as electrode spacing, substrate concentration, anode/cathode material/concentration, and a parallel circuit configuration to altogether minimize resistance and boost power production.

Re-synthesizing TPA and EG to create PET resin provides high-quality product to sell to companies.

We use the TPA and EG generated as a byproduct of the FMC to create PET resin pellets, which is what companies melt and mold into the plastic shapes they want. To create the resin pellets, TPA and EG are combined at high temperatures and low vacuum pressure to create a bowl of “PET spaghetti” that can be cut up into pellets. We then sell these pellets to companies such as water bottle manufacturers, minimizing the production of new PET by using existing PET. Since biodegradable plastics are not going to be replacing PET anytime soon, we leverage existing PET supply chains and resupply the building block PET resin pellets using the waste that is destroying our planet.

The initial study on ICCG showed the results of using PET’s subcomponents to create plastic bottles:

“Bottles blown from this PET had similar mechanical properties (a displacement of 2.9 mm at a maximal top-load force of 176 N) to those of commercial PET bottles (a displacement of 3.0 mm at a maximal top-load force of 181 N). Moreover, their excellent lightness values of 87.5% are better than those of the minimal standard for PET bottles (greater than 85%).”

There are two main incentives why companies would prefer recycled PET resin pellets:

1. There is no compromise in plastic durability/ease to shape into products through our solution. Often, there is stiffness, brittleness, discoloration, and a lack of previous tensile strength in recycled PET.
2. Our solution offers a cheaper alternative to other recycled plastic methods.

We talked to Melanie Condon, Director of Sustainability at Keurig Doctor Pepper to understand the economic incentives, benefits, and challenges for recycled plastics. We learned 3 key points:

1. From Keurig Green Mountain’s merge in 2018 with Dr. Pepper, the company prioritized sustainability because of reputation and pressure from investors. Additionally, climate change added risk to how they got their plastic. Finally, questions and pressure from consumers ultimately pushed KDP to aim higher with their sustainability goals. When asked, Melanie agreed that this followed a current trend, where companies are being pressured, specifically by Gen-Z, into becoming more eco-friendly. At KDP specifically, all Snapple bottles are made with recycled plastic rather than glass, a recent shift following this pressure. This also lightened the load of their trucks, allowing them to take 8500 trucks off the road and further lowering carbon emissions.
2. Companies have conservative claims on the word “recyclable” and “compostable”. In fact, only 3% of companies have access to compostable factories. Big companies also have legal risks to consider when trying to source recycle plastic. KDP missed several sustainable goals, as COVID prevented them from being able to send auditors to ensure responsible sourced recycled plastic.
3. Ocean plastic is a buzzword that if not done correctly, can cause more harm than good. KDP tried to use ocean plastic from a Taiwan supplier. However, the shipping wasn’t worth it for the carbon footprint.

As an alternative avenue that we can pursue, purifying the TPA monomers created it into “ a level higher than 99.8%, with an American Public Health Association (APHA) color number of 2.9”, and also produced 0.6 kg sodium sulfate per kg of TPA. This provides another possible avenue for revenue as the sodium sulfate market is 21.5 million tons a year with a 2.9% annual growth rate.

Our full economic breakdown:

According to the research paper that initially synthesized the ICCG enzyme, 1 ton of the enzyme cost $43.56 to produce. However, this was valued from the first time synthesizing the enzyme. If we can cut this cost by 1/2 by finding a way to synthesize it faster and using less labor, then this cost is $21.78 per ton of PET plastic.

Ocean plastic cleanup groups, such as the Ocean Cleanup, lose $5.00/kilogram for every ton of plastic that they collect from the ocean. It costs them $5.32 per kilogram for something that will, at best, be valued at $0.30 per kilogram. If we offered to make up 5% of this loss for every ton of PET plastic that we take off of their hands, then we will pay $227 per ton of PET plastic (this is 3.34x the amount they will make normally).

Using a case study of a small wastewater treatment MFC, the capital cost of a 200 L MFC system, made up of 96 modules in an array, was $6064 ($23.18 per module). This covered direct and indirect costs, such as materials, land, installation, and engineering. Variable costs would include $94.96/ton of PET plastic through the MFC system.

The total cost per ton through this method is $343.74 per ton of PET plastic. When compared with the current cost of production for recycled PET plastic $1114.64 / ton, we gain money per ton while the recycled plastic industry as a whole loses money, as the current selling price of PET plastic is $1112.50.

This calculation of cost does not capital the costs of re-synthesizing PET. However, the only variable costs in this process would be labor and maintenance. There would be net-zero energy costs due to MFC energy production.

Durata revolutionizes the way we produce plastic.

There would no longer be a reason to produce millions of tonnes of plastic each year. Instead, MFCs would ensure a self-sustaining recycling process, allowing us to eliminate trillions of ocean plastics.

By leveraging MFC technology, we can directly implement our solution to recycle 260 golden gate bridges worth of plastic waste. By just recycling 56% of that, we ensure that no new plastic bottles, or PET products as a whole, are made again.

TL;DR

• By 2026, the weight of PET plastic in our oceans will be equal to 260 golden gate bridges stacked together. However, just 56% of that plastic would be enough to meet global demand.
• Current plastic alternatives are more expensive and are of lower quality than current PET plastic.
• We propose an MFC system that chemically recycles PET plastic, and generates electricity from degradation to power the reformation of PET resin pellets.
• That way, the main cost of the energy needed to create extremely high temperatures and low vacuum pressure is minimized, and the system is self-sustaining.
• We sell this to companies at their current price or even lower- which is much cheaper than current recycling/plastic alternatives.
• If we can expand this to just half of the ocean’s plastic- we could minimize new PET production to zero

Contact Us

Lohit Potnuru | lohitpotnuru@gmail.com | LinkedIn

Lauren Pryor | laurenxpryor@gmail.com | LinkedIn

Zayn Patel | zaynpatelwhs@gmail.com | LinkedIn

Timothy Simmons III | tim-simmons@comcast.net | LinkedIn

Durata- Achieving Complete PET Neutrality: Master Plan was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

In October, I had the privilege of attending the Tough Tech Summit, hosted by MIT’s The Engine. The summit consisted of talks by some of the biggest industry leaders, including the co-founder of Nest Labs, on building technology for real, long-term change.

One talk in the conference that really stumped me was a fireside chat between Mariana Mazzucato and Tom Kalil, where they discussed the role of government in building an innovation economy beneficial to all. As a high-schooler who spends his time both nerding out over quantum computing and competing in policy debate, it amazed me that I never really thought about the obvious intersection between the two. Immersed in the culture of Silicon Valley, interest in tech always implied founding/working at companies with almost no discussion on how that knowledge could be applied to policy.

Mariana Mazucatto (Ph.D.) is a Professor in the Economics of Innovation and Public Value at University College London, and the Founding Director of the UCL Institute for Innovation and Public Purpose. She has authored numerous books such as The Entrepreneurial State: debunking public vs. private sector myths, The Value of Everything: making and taking in the global economy, and more recently MISSION ECONOMY: A MOONSHOT GUIDE TO CHANGING CAPITALISM (which is more in line with what the article will discuss today). She is a member of the UN’s Committee for Development Policy, OECD Secretary General’s Advisory Group on a New Growth Narrative, South African President’s Economic Advisory Council, and the Scottish Government’s Council of Economic Advisors.

Tom Kalil is the Chief Innovation Officer of Schmidt Futures and Entrepreneur-in-Residence at UC Berkeley. He was the previous Deputy Director for Tech and Innovation for the White House Office of Science and Technology Policy and Senior Advisor for Science, Technology, and Innovation for the National Economic Council. He was also appointed by President Clinton to serve on the G-8 Digital Opportunity Task Force (Dot Force).

TL;DR Both are extremely qualified speakers with extensive experience in shaping innovation through the lens of government policy.

Building Back Post-COVID

Following the severe impacts that COVID has brought down upon our economy is an opportunity to restructure recovery funds and the process in which the public sector stimulates the private sector. In the status quo, the perception is that the state funds basic R&D until venture capitalists swoop in and speed up the process. However, according to Mazucatto, the state needs more involvement in the process, such as providing long-term finance to sustain the development of new technology.

The conversation then branched off to tackling higher-level issues and moonshot ideas. Kalil mentioned that these moonshot ideas now seem possible post-COVID. For example, the Obama Administration wanted to reduce the time it took to produce a vaccine, with DARPA looking into antibody-based therapy during the Ebola Outbreak. What seemed like a moonshot idea back then was sped up due to the urgency of the COVID pandemic. The public sector needs this same sense of urgency in tackling long-standing issues like solar energy as well as funding newer ideas/tech (fusion technology).

Now that COVID has increased visibility for high-level issues such as climate change, social justice, and healthcare, the government needs to work with the private sector to set goals and build coalitions in order to solve them.

Issues We Need To Focus On

One issue that both Mazucatto and Kalil agreed on was the fact that the public sector needs to treat social problems with the same urgency as it does with technological problems. This includes issues such as education, workforce development, human services, affordable housing, and reducing the generational transmission of poverty. These social problems aren’t necessarily separate from technology either — for example when addressing stagnant and declining wages of low-skilled workers, one can look into AI tutors to reduce the time/cost to gain a skill that can be applied in a higher-skilled job.

From an implementation standpoint, Mazucatto mentions how tackling the 17 sustainable development goals that every country has signed up for (poverty, hunger, climate change, etc.) should be structured as follows:

where you start off with a “grand challenge” → a specific goal → specific objectives to reach that goal → initiatives to reach those objectives. When creating these objectives, local voices should be heard in order to bring context to the specific region being addressed.

Restructuring Private Partnerships

An example that Kalil gives of a successful public-private partnership is SpaceX. The US Government wanted to limit spending when sending cargo and astronauts to the International Space Station (paying Russia roughly 80 million dollars per seat), so they partnered with private companies (including SpaceX) with the clear objective of a rocket that could cut down on those costs. With this objective in mind, they set up a series of milestone payments that eventually led to the success of the program.

The private sector isn’t exactly made up of philanthropists, and therefore there are a lot of social issues where modest to no work is being done (i.e. providing vaccines for the poor) Therefore, the public sector must incentivize the private sector with systems similar to milestone payments for reaching specific objectives in a way where the public sector takes the demand risk while the private sector takes the performance risk. Additionally, Mazucatto believes the government needs more regulations on things like patents, pricing, etc. while rethinking contracts that explicitly state risk allocation between the two.

Mazucatto calls for more creativity in downstream investment. For example, instead of having told Tesla, “if you don’t pay back your loan we will take 3 million shares of your company,” structure it as “if you do pay back your loan we will get, for a period, 3 million shares in your company.” That sort of structuring allows for an investment portfolio for the public good where you can combine mission-oriented and financial return mindsets.

Commercializing Breakthrough Tech

A huge problem when attempting to commercialize breakthrough tech is the startup costs to do so. For example with fusion tech, it would probably cost a billion dollars in order to build a power plant. Kalil maintains this idea of an objective-oriented milestone payment system as a way to generate a public-private partnership in that sector. Furthering the example of fusion tech, it would need a lot of support getting off the ground when facing incumbent tech (natural gas, fossil fuel).

Another area of concern is maintaining decentralized networks of innovation rather than one centralized institution. Taking our previous example of fusion tech, Mazucatto points to ITER- a megaproject that holds most of the funds and resources for fusion tech research. Taking from the ideals of her father, she voiced her opinion on the necessity for a decentralized network of well-funded labs rather than one big entity like ITER.

Branching off of the idea of decentralized networks for innovation, I recently had the privilege of getting on a call with Chris Morales, Vice President of AI ventures at Point72 Ventures. During the call, one area of discussion was considering working with a large corporation vs. a smaller startup when developing breakthrough tech. Amidst the conversation arose the innovator’s dilemma, where large organizations are calibrated to make decisions based on profits, not innovation. On the other hand, a small startup that has little to lose is able to build infrastructure incorporating the new tech from the ground up- leading to success stories where the smaller company revolutionizes the industry and takes down the incumbent (i.e. Netflix vs. Blockbuster).

In an episode of the Knowledge Project, Shane Parrish and Roger Martin dive into integrative thinking and mention something that I thought applies really well here. They discuss how in every revolutionary idea/breakthrough piece of technology, there has never been any analytical reasoning/confirmation to prove for certain that it would work, because of the inherent fact that it was unprecedented. Similarly, entities that focus too much on scientifically validating the opportunity for their idea are likely to lean towards to never being able to grow and innovate their solutions.

Generating Interest for Policy in the Next Generations

One area of discussion that surprised me was the issue of the lack of scientific knowledge among politicians. Though the problem itself is by no means a surprise, there is a sub-problem at the root of it which is the lack of incentivization for next-generation technologists/scientists to ever go into policy. In the culture that many of the next-generation STEM workers are immersed in, it is always implied that one would join a STEM company, or form their own. In other words, careers in STEM always imply working in the private sector. However, there is almost little to no emphasis on using that knowledge in policy work

Kalil brought attention to an initiative that onboarded STEM workers to focus on policy for a limited period of time. It turns out that many of them decided to stay, as they saw the work that they were doing far more impactful than what they did on a daily basis. It points to an interesting idea to regularly onboard STEM workers to consult the government in a temporary commitment so that more people join and there is a greater sense of urgency to get something done during the shorter term.

Main Takeaways

1. Mission-oriented policy-making financed by long-term investment and/or milestone payments
2. Government key in providing enough funding to properly commercialize breakthrough tech
3. Can generate interest in policy among STEM workers through temporary consulting for the government

Thank you for reading my article! You can connect with me on my LinkedIn or email me at lohitpotnuru@gmail.com. Sign up for my monthly newsletter here.

Shaping Innovation Through the Lens of Government Policy was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

Disclaimer: The latter half of the article gets pretty technical. For casual readers, I suggest looking into the first and second sections for a brief overview of what quantum computers are and some pretty neat quantum mechanics that they manipulate.

An Introduction to Quantum Computing

As a kid, or even as an adult, it’s always fun to grab a maze and try to figure out the correct path between the entry and exit points.

When you look at how you solve a complex puzzle like this one, it would be safe to assume that you most likely explore each path one by one, until you find the correct answer. Now imagine you are able to explore all the paths at the same time. Crazy right… Using the power of quantum mechanics, quantum computers seem to do exactly that- but instead of elementary school maze puzzles, we could eventually use them for high-level problems like simulating interactions between molecules and aiding in drug discovery.

The Need for Quantum Computers

Over the past couple of decades, computing power has grown exponentially year by year. Specifically, Moore’s Law tells us that computing power generally doubles every year, by being able to make transistors smaller.

At this point, going smaller means we inevitably have to face the effects of operating at a quantum scale. Thus, it necessitates the creation of a computer that can operate within the laws of quantum mechanics, or even take advantage of them.

A Brief History

We can attribute the first proposal of a quantum computer to Richard Feynman in 1981. In 1994, Peter Shor introduced Shor’s algorithm, generating a lot of excitement in the field as it gave an application where quantum computers could actually use the laws of quantum mechanics to factor large prime numbers. Last year, Google claimed quantum supremacy (among controversy), as it performed a calculation that would’ve supposedly taken 10,000 years for a supercomputer to compute (IBM disagrees saying it would take 2.5 days) in 200 seconds (still a significant difference either way).

Applications of Quantum Computing

At a high level, the power in quantum computers comes from a qubit’s (quantum bit) ability to be in a superposition state, or multiple states at once. In a classical bit, it functions like a lightbulb where it can either be on (1) or off (0). A qubit, however, can be in a superposition of both 0 and 1, essentially being both at the same time. Using this, among other quantum phenomena, quantum algorithms are able to manipulate multiple states at once, and therefore be exponentially more efficient. Though quantum computers are currently not anywhere near as powerful as they could be, future applications of quantum computers could include:

1. Quantum Simulations (what better way is there to model the randomness of a quantum system than to use the same randomness of another quantum system?)
2. Drug Design/Discovery (able to simulate the effects of drugs to drastically reduce the time it takes for drug discovery)
3. Cryptography/Cybersecurity
4. Optimization
5. Financial Modeling
6. Forecasting
7. Computational Chemistry

Some Spooky Laws of Quantum Mechanics

Wave-Particle Duality

When considering the discovery of wave-particle duality in electrons, one must first take a look at its discovery in light. At first, we had known light to be an electromagnetic wave, characterized by its frequency and wavelength. However, this couldn’t explain the photoelectric effect, which was a phenomenon that occurred when light was directed at a certain metal plate, causing it to eject an electron. However, whether or not an electron was ejected was unchanged by how intense the light was. Instead, it was the frequency of the light that determined whether or not an electron would be ejected.

Planck theorized that energy is quantized, or broken down into discrete packages of energy (Planck’s energy) that couldn’t be broken down into smaller units of energy. Einstein then extended this to light, naming these discrete packages photons (particles of light). Thus, striking the metal plate with a photon with a given amount of energy would eject an electron, regardless of how many photons were directed at it (intensity), explaining the photoelectric effect.

The double-slit experiment is also a prominent example of wave-particle duality. Here, photons were fired through two slits and measured on where they landed on a screen in the back.

When where they landed was recorded, the photons exhibited behaviors of a wave, where interference between waves created a probability distribution in the back screen shown on the right-most side of the image. Even when fired as a singular photon, it was able to interfere with itself to still act as if it was a wave.

Wavefunction of Quantum Particles

Erwin Schrödinger was able to present an equation that described the “wave function” of a particle that is key for our understanding/manipulation of quantum mechanics now.

When you plot Ψ(x), you get a graph that can look like this:

At first, the interpretation of what this actually means in the real world was unclear, and even now we still don't know what this actually looks like. However, what we generally observe and accept is that the amplitudes of this wave function squared gives us the probability of finding a particle at that given location. So, at one point, “measuring” the location of a particle “collapses” its wave function to a single point in space, with the amplitudes of that wave function telling us the likelihood of it collapsing down to a specific point in space.

Superposition

We have been referencing superposition for a while now, but formally a quantum superposition of a particle allows for that particle to be in multiple states at once. The wave function gives us a superposition of different states a particle can be in with varying amplitudes for how likely a particle is likely to be at that point in space. Thus, particles exist in probability clouds that collapse down to one point when measured.

One famous thought experiment that exemplifies this is Schrödinger’s Cat. In the experiment, a cat is placed in a closed “black box” with a radioactive particle. That particle has a 50% chance of decaying, which would release a gas that would kill the cat. If you keep the black box closed and free of “measurement” (collapsing the superposition), it is thought that the cat would then be in a superposition of both alive and dead. However, once the black box is opened you would see either the cat alive or the cat dead. Similarly, if you put a camera inside the black box, then put a human outside with a second black box around him, the human is measuring whether or not the cat died, but since the human is in a closed system it is not being measured. Thus, the human would then be in a superposition of seeing the cat alive and seeing the cat dead.

Schrödinger originally came up with this experiment to display how crazy and nonsensical the current view of what the laws of quantum mechanics are. Ironically, it is widely used today as a way to introduce people to the world of quantum mechanics.

The Measurement Problem

I’ve been referring to the notion that “measuring” a quantum particle collapses down its wavefunction/superposition into a single state. However, what actually constitutes as “measuring” something is completely unknown to scientists.

To show just how confusing this is, we can go back to the example of the double-slit experiment. We saw that measuring where the particles landed displayed signs of interferences patterns similar to waves. Note that this measurement is different from the measurement that collapses down a quantum superposition, as this one measures where they landed after they hit the back screen. In a sense, you could say that the back screen is the object that performed the act of “measurement” and forced the particle to collapse down to a single wave function.

If a human being was there observing the particle being shot to the back screen, however, then the particle would behave like a particle and two slits would appear in the back screen. Alternatively, if a camera was put inside the environment, the “measurement” would still occur, and the particle would behave like a particle by forming two slits in the back screen. Once the camera was unplugged but still kept inside the environment, the particle resumed acting like a wave and interfering with itself to form an interference pattern in the back screen.

To sum up, we have no idea what is causing this wave function to collapse down to one state, and how the world isn’t a probability cloud full of randomness. However, we can still manipulate quantum mechanics for our benefit in quantum computers, without knowing the answer to this measurement problem.

Interpretations of Quantum Mechanics

The most popular/widely taught interpretation of the laws of quantum mechanics is the Copenhagen Interpretation, which is what the article thus far has been talking about. Proposed by Niels Bohr and Schrödinger, the interpretation gives us the best mathematical model for how quantum mechanics functions and how we can manipulate those laws for our own benefit. It ignores the measurement problem and basically tells us to suck it up and do the math.

Another popular interpretation of quantum mechanics is Hugh Everett’s proposal of the Many Worlds Theory. It argues that there is no “collapse” of the wave function, but rather the universe splits/branches out so that each possible state in which the particle could be in actually occurs in parallel universes. With the example of Schrödinger’s cat, there would be two (for the sake of the thought experiment) parallel universes created where the cat is dead or the cat is alive.

There are many other interpretations, but in the case of quantum computing, relying on the Copenhagen interpretation gives us a pretty good toolkit for performing quantum computations.

Quantum Entanglement

Bohr rejected the concept of realism, or that the universe exists independent of our observation of it. Instead, the Copenhagen interpretation maintains that the existence of the universe is only confirmed at the point of observation.

Einstein rejected this, maintaining that there must be some hidden variables or missing pieces to the wave function/the Copenhagen interpretation. In a debate between the two, it was shown that two particles could be entangled in a way that, no matter the distance between the two particles, the two states would always be correlated.

A particle’s spin can be measured based on a measurement basis. For example, a vertical measurement would give you a spin up or spin down and a horizontal measurement would give you a spin left or spin right. When two entangled particles exist, no matter where they are in the universe, measuring them would give you opposite spins. This “spooky action at a distance”, as Einstein described it, hinted at the notion of faster than light communication where the states of both particles were inextricably linked. Whether or not there is actually faster than light communication, or whether or not the Copenhagen interpretation in it of itself is actually true is all up to debate. However, the fact that this relationship exists between two particles allows us to manipulate it for quantum computations.

Quantum Interference

Adding on to the notion of the wave function, two wave functions/superpositions can either destructively interfere or amplify each other, similar to regular waves. An example of this is in noise cancellation headphones, where soundwaves are sent to destructively interfere with soundwaves coming from the outside to cancel the noise around you. Similarly, quantum superpositions can destructively interfere or amplify each other, thus manipulating the probability of collapsing down to a particular state.

This concept, along with quantum superposition, allows us to make exponentially more efficient quantum algorithms. Remember that we can’t just make a superposition of a bunch of different possibilities and measure that, as it will collapse down to one state upon measurement. Instead, one must find a way to make this superposition destructively interfere and amplify the desired answer.

3) Modeling Qubit States in Quantum Computing

Representing a Qubit

A qubit, or quantum bit, is the smallest unit of quantum information. For example, one qubit can be one electron where information can be stored in its spin. Similar to a bit whose states can be 0 or 1, a qubit can have the states |0⟩ and |1⟩. The ket (|⟩) symbol denotes a quantum state.

We can rewrite the states |0⟩ and |1⟩ as mathematical vectors on a unit circle, with the values:

From this, we can represent all other qubit states as a linear combination, or a sum of some multiple of, the two basis vectors.

In other words, any other state vector of a qubit can be rewritten in the form of:

For example, denoting a quantum state in a 50/50 superposition of 0 and 1 could be written as:

Calculating Probability

Now that we have denoted a quantum state as a linear combination of the states |0⟩ and |1⟩, we can now calculate the probability of that superposition to collapse to |0⟩ or |1⟩ by calculating:

where you are trying to find the probability of |psi⟩ collapsing down to |x⟩. For our purposes, we can simplify this equation to find the probability of collapsing down to |0⟩ or |1⟩ as follows:

Taking our previous example of the 50/50 superposition, we can calculate that it does indeed have a 50% chance of being |0⟩ and a 50% chance of it being |1⟩ by plugging it into the equation above:

The Bloch Sphere

When alpha and beta are both real numbers, you can represent them on a 2-dimensional unit circle. However, in quantum computing, you often get alpha and beta to be complex numbers. Thus, you can represent quantum states by plotting the vectors onto a 3-dimensional Block Sphere.

Through some mathematical proof that I won’t cover in this article, we can write the state of

in terms of 2 angles- theta and phi:

and plot those two angles in the block sphere as shown below

Manipulating Single Qubits

Quantum Gates

Similar to the logic gates inside classical computers, quantum gates are able to manipulate qubits and are the building blocks for actually creating quantum algorithms.

Practically, they are ways to manipulate the spin/state of a qubit. There different types of quantum computers, but one popular method is to use single electrons as qubits and microwave pulses to manipulate their spins.

If you are familiar with linear algebra, you know that matrices can be thought of as linear transformations of vectors, or ways to transform one vector to another. Similarly, we can denote quantum gates as matrices that you can apply to quantum states.

Reversibility

Whenever you apply a gate to some information in classical computing, you oftentimes lose the original information. For example, take the AND gate, whose truth table looks like the following:

If we get an output of 0, there is no way for us to determine if the input was 00, 01, or 10. Thus, some information is lost by applying the AND gate to two bits.

Conversely, in quantum computing, gates are reversible, meaning that applying a quantum gate allows you to figure out the original information as well. Though this might not seem as significant right now, it is a lot more prominent once you get deeper into quantum computing.

The Pauli X Gate

This gate is the quantum equivalent of the NOT gate. For those unfamiliar, in classical computing, a NOT gate takes in a single bit (0 or 1) and outputs the opposite of that bit. For example, inputting a 1 would give you an output of 0 and vice versa.

Similarly, a Pauli X Gate takes in either |0⟩ or |1⟩ and outputs the opposite state. We can mathematically represent this given the following matrix:

We can see how this flips a qubit by multiplying the matrix by both the |0⟩ and |1⟩ states:

Geometrically, we can visualize the X gate rotating a quantum state by π radians about the x-axis.

The Pauli Y+Z Gates

Similar to the Pauli X Gate, instead of rotating a quantum state about the x-axis the Y and Z gates rotate a quantum state by π radians about the y and z axes.

Mathematically we can represent the two as follows:

Applying the Y gate to the |0⟩ and |1⟩ states gives us:

Applying the Z gate to the |0⟩ and |1⟩ states gives us:

We can see that applying the Z gate to our basis vectors gives us the same measurement since the negative sign (phase; we can worry about that later) is inconsequential when we measure the quantum state. Thus, |0⟩ and |1⟩ are the eigenstates of the Z gate and are often called the Z-basis.

The Hadamard Gate

In the second section of the article, we talked about quantum superposition, or the state at which an object at the quantum scale is able to exist in multiple different states at once. In a quantum computer, you can create a superposition state in a qubit using the Hadamard Gate.

As a matrix, the Hadamard Gate can be represented as follows:

Applying the H Gate to our Z-basis vectors is also represented using the |+⟩ and |-⟩ symbols:

We can also prove that |+⟩ and |-⟩ are also the eigenvectors for the X gate:

Geometrically the H gate can be visualized as a rotation around the vector [1 0 1] on the block sphere- which lies in between the x and z-axis. This is also a way to transform a state between the X and Z bases.

The 𝑅𝜙 Gate and its Variations

This gate is parameterized by a real number 𝜙 and can be represented as follows:

Geometrically, the R𝜙 Gate can be visualized as rotating a Bloch vector by a value of 𝜙 about the Z-axis

Certain variations of the R𝜙 Gate are labeled as their own gates due to how commonly they are used. For example, the Pauli Z gate is just the R𝜙 Gate where 𝜙=π.

Similarly, the S gate is the R𝜙 Gate where 𝜙=π/2. It is also called the sqrt(Z) gate as SS|q⟩=Z|q⟩

Finally, the T gate is the R𝜙 Gate where 𝜙=π/4 and is the 4th root of the Z gate.

The U3 Gate

This is the most general single qubit quantum gate, and is parameterized by three variables:

Wrapping Up…

In this article we covered 1) a basic history/introduction to quantum computing, 2) basic quantum mechanical principles/interpretations, 3) the qubit and how to represent it, and 4) manipulating single qubits with quantum gates.

In the next article, we will be going over concepts such as phase, manipulating multiple qubits, basics of quantum hardware, and go more in-depth on future applications of quantum computing.

Thank you for reading my article! You can connect with me on my LinkedIn or email me at lohitpotnuru@gmail.com. Sign up for my monthly newsletter here.

Quantum Computing for Dummies- Part 1 was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

In my previous article, I talked about Shor’s Algorithm- a quantum algorithm that can be applied to break current RSA encryption. Luckily for us, current quantum computers have been using Shor’s to factor numbers such as 21, not 512 bit RSA keys. However, this has just been due to the limitations of quantum hardware. As technological advancements occur, we need a way of combatting quantum decryption to properly secure our data.

One way we can do this is by fighting quantum with quantum, using Quantum Key Distribution (QKD).

BB84 Protocol

According to the BB84 protocol, QKD would work as follows:

Let’s say you have two people that are sending data to each other — Alice and Bob. Alice randomly generates the digital key to “unlock” the data, which is a series of 0s and 1s.

For simplicity’s sake — let’s make Alice’s randomly generated key 011010.

Each element of the key is going to be encoded by the polarization of a given photon, and it can either be done on a rectilinear basis or a diagonal basis.

Using a rectilinear basis, a 0 would be encoded by polarizing a photon 0 degrees and a 1 would be encoded by polarizing a photon 90 degrees. The same is for the diagonal basis except it polarizes the photon at 45 and 135 degrees, as shown by the figure below:

When sending out her key, Alice would choose the basis she encodes her protons with at random for each photon.

Using R to represent a Rectilinear Basis and D to represent a Diagonal Basis, let’s say that Alice sends her photons using RRRDRD.

Once Alice has sent her photons, Bob now has to receive and measure them. However, Alice won’t tell Bob the measurement basis by which she chose to encode the electrons. Instead, Bob will choose at random which measurement basis he would use for each photon. Note that choosing a measurement basis that is not the one that Alice chose gives Bob a 50/50 chance of choosing between 0 and 1. Choosing the correct measurement basis means that he gets a 100% chance of measuring what Alice initially meant to send.

For example, Bob chooses to measure the photons using the measurement basis of DRRDDR. Notice how the first, fifth, and sixth photons were measured using the incorrect measurement basis — so they would collapse randomly to measure either 0 or 1.

Now that both have their keys and measurement bases stored, they can announce (publicly, it doesn’t matter) what was the measurement basis that each used. If both used the same measurement basis for a given photon, then the value of that photon is kept as a part of the key. Digits, where different measurement bases are used, are discarded.

What Makes It Unbreakable?

The reason that someone can't eavesdrop on this communication of photons is because of the laws of quantum mechanics. An outsider measuring the photon can make it collapse from its polarized state and lose the original information it was carrying. It is also impossible to make an exact copy of that photon without making it collapse.

Alice and Bob can agree on a small subset of their keys to compare and see whether or not they match. If they don’t, that means that someone interfered with the photons being sent and the key is discarded.

The chances of the eavesdropper going undetected exponentially decrease as the number of digits in the key increases, or more specifically the number of digits that Alice and Bob cross-check. The hacker would have to be extremely lucky so that every photon in that subset that Alice and Bob cross-reference with each other has either been measured with the correct measurement basis or randomly collapsed down to the correct polarization state.

Alternate Solutions

The feasibility of this in the near future is pretty muddy. For something like this to work, we would need a functional quantum internet — which is not necessarily going to come anytime soon. Sending photons across the country while retaining its polarized state is a pretty difficult task.

However, we still have the problem of quantum computers being able to break RSA encryption. What steps can we take to make sure that our data is safe until then?

Currently, the National Institute of Standards and Technology has been directing a process to find one or more quantum-resistant public-key cryptographic algorithms in preparation for when quantum computers can crack RSA encryption. There are mainly three groups of proposed cryptographic algorithms — lattice, code-based, and multivariate.

You can see their 3rd round of finalists here:

https://csrc.nist.gov/projects/post-quantum-cryptography/round-3-submissions

Overall, Quantum Key Distribution is an amazing way of securing your data that relies on the unpredictability of the laws of quantum mechanics. However, it has its own physical limitations now, which is why currently there is a call for encryption algorithms that can combat the rise of quantum computers.

Thank you for reading my article! You can connect with me on my LinkedIn or email me at lohitpotnuru@gmail.com. Sign up for my monthly newsletter here

Well, in reality, breaking current encryption messages isn’t that easy. But could it be?

Currently, RSA protocol is the standard encryption method given by the National Institute of Standards and Technology. At its heart, the encryption method relies on the fact that it is pretty difficult for computers to efficiently find the two prime factors of a large number. Right now, computers basically guess and check until they get the right answer.

However, in 1994 Peter Shor was able to come up with an algorithm that used the power of quantum computers to be able to calculate these prime factors much more efficiently. The algorithm makes use of two useful quantum properties- superposition and destructive interference, to essentially make random guesses into really good guesses.

The rest of the article gets more technical, but if a 15-year-old can write it, you can understand it. (There is a summary of the steps at the bottom of the article)

Given you have the number you want to factor, N, and a guess g where g<N: you can use something called Euclid’s algorithm to find the prime factors as long as g and N share common factors.

We also are given that, if you take two numbers (A and B) who don’t share any common factors, there is a value p where:

I am not going to prove that is the case, but you can pick any two random numbers and there will always be an exponent of the first number that is one more than some coefficient times the second number.

If we substitute A with our guess (g) and B with the number we are trying to factor (N), we can simplify the equation to the following:

For the purpose of this article, let’s define N (the number we want to factor) as 15. Let’s also use a random number less than 15, g=7, as our initial guess.

Once you find p, solving for g will give you a pretty good chance at guessing correctly for a prime factor of N. However, finding p is not an easy task. It’s not any easier, or maybe even harder, for a computer to try to find it compared to just guessing for g. However, this is where quantum magic comes in.

Let us leave that equation in the back of our minds for now. We want to optimize quantum algorithms so that they are more efficient than regular computers. We can’t just input a superposition of a bunch of numbers and receive a bunch of answers- as measuring it would collapse it down to one output. What we need to do is input a superposition of inputs and then make them “destructively interfere” with one another to boost the probability of getting the best answer.

To find p, let's input a guess |x> to our algorithm. The algorithm should take x and find

so its stores |x, +r> for a superposition of a bunch of different x values.

*note that the kit symbol |> signifies a quantum state

For our example of N=15 and g=7, testing different x values gets you the following:

Once you start testing a bunch of x values, you notice a pattern where different x values that have the same remainder are separated by a period, which is our p value:

|x, r>, |x+p,r>, |x+2p,r>..|x+ap, r> where r is the same in all of them.

In the case of our example, from our table above we can see that taking any r value (such as 7) gives you a period of 4. In other words, the remainder repeats every 4 values of x.

This p value is what we are trying to solve for, and we do that by using something called a Quantum Fourier Transform…

Let’s say that you have one number |a> that you input into the Quantum Fourier Transform, the output (graphically) would be a sinewave with a frequency of a and a period of 1/a.

And if you input a superposition of different values, you get a superposition of a superposition where the sinewaves can either destructively interfere with one another or amplify each other.

If you input a superposition of values separated by a value of p, the sinewave destructively interfere with another (note that this is oversimplified) to give you a period of 1/p or a frequency of p

If we input our guesses x and our remainders r from our example with 15, the superpositions of each |x,r> would destructively interfere with one another to get us 1/4, or p=4

Finally, if p is even, you can plug it into our original equation:

to get a number that has a common factor with N.

We can then use Euclid’s algorithm to finally our two prime factors of N and break the RSA encryption.

With our example where N=15, g=7, and p=4, we can simplify the right-hand side of the equation to be 50, and find the GCF(15,50) to be 5. Simply calculating 15/5 gets us our two prime factors: 3 and 5.

Taking a step back we…

1) took our number that we wanted to factor- N

2) Gave a random guess g and derived how to make our guess (g) “better” to make it share a factor with N

3) To find p, we first inputted a superposition of x values and took all the x values with the same remainder

4) We then stuck that into a Quantum Fourier Transform to make the sinewaves of these values destructively interfere to give us the frequency p

5) If the p value was even, we plugged it into the original equation and used Euclid's algorithm to derive the 2 factors of N

• Note that this won’t necessarily give you an answer on the first try- however, it gives you a pretty good chance, making it worth iterating and better than guessing and checking literally every prime number with a computer

Thank you for reading my article! You can connect with me on my LinkedIn or email me at lohitpotnuru@gmail.com. Sign up for my monthly newsletter here