Bored with classical computers? – Quantum AI with OpenFermion


In this article I will show how we can prepare and perform calculations on quantum computers
using OpenFermion, Cirq and PySCF.

Before you will continue reading please watch short introduction:

Currently, there are many supercomputing centers, where we can run complicated simulations.
However, there are still problems that are beyond the capabilities of classical computers,
which can be addressed by quantum computers.

materials science

Quantum chemistry and materials science problems which that are described by the laws of
quantum mechanics can be mapped to the quantum computers and projected to qubits.

OpenFermion is the library which can help to perform such calculations on a quantum computer.

Additionally we will use the PySCF package which will help to perform initial structure optimization (if you are interested in PySCF package I have shared the example DFT based band structure calculation of the single layer graphene structure pyscf_graphene.ipynb).

materials science

In our example we will investigate H_2 molecule for simplicity. We will use the PySCF package to find optimal bond length of the molecule.

Thanks to the OpenFermion-PySCF plugin we can smoothly use the molecule initial state obtained from PySCF package run in OpenFermion library (openfermionpyscf_h2.ipynb).

from openfermion.chem import MolecularData
from openfermionpyscf import run_pyscf

geometry = create_molecule(bond_length)
basis = 'sto-3g'
multiplicity = 1

run_scf = 1
run_mp2 = 1
run_cisd = 0
run_ccsd = 0
run_fci = 1

molecule = MolecularData(geometry, basis, multiplicity)

# Run pyscf.
molecule = run_pyscf(molecule,

materials science

Now it is time to compile the molecule to the representation readable by the quantum computer
using OpenFermion and Cirq library.
Currently you can use several methods to achieve this:
* Constructing a Basis Change Circuits
* Constructing a Diagonal Coulomb Trotter Step
* Constructing Trotter Steps With Low-Rank Decomposition

Using one of this methods we get optimized quantum circuit.
In our case the quantum cirquit for H_2 system will be represented by 4 qubits and operations that act on them (moment is collection of operations that act at the same abstract time slice).

materials science

Finally we can use quantum circuit to run the calculations on the cirq simulator or on the real quantum computer.

Quantum teleportation do it yourself with Q#


Quantum computing nowadays is the one of the hottest topics in the computer science world.
Recently IBM unveiled the IBM Q System One: a 20-qubit quantum computer which is touting as “the world’s first fully integrated universal quantum computing system designed for scientific and commercial use”.

In this article I’d like how to show the quantum teleportation phenomenon. I will use the Q# language designed by Microsoft to simplify creating quantum algorithms.

In this example I have used the quantum simulator which I have wrapped with the REST api and put into the docker image.

Quantum teleportation allows moving a quantum state from one location to another. Shared quantum entanglement between two particles in the sending and receiving locations is used to do this without having to move physical particles along with it.

1. Theory

Let’s assume that we want to send the message, specific quantum state described using Dirac notation:


Additionally we have two entangled qubits, first in Laboratory 1 and second in Laboratory 2:


thus we starting with the input state:

|\psi\rangle|\phi^+\rangle=(\alpha|0\rangle+\beta|1\rangle)(\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)) |\psi\rangle|\phi^+\rangle=\frac{\alpha}{\sqrt{2}}|000\rangle + \frac{\alpha}{\sqrt{2}}|011\rangle + \frac{\beta}{\sqrt{2}}|100\rangle + \frac{\beta}{\sqrt{2}}|111\rangle

To send the message we need to start with two operations applying CNOT and then Hadamard gate.

CNOT gate flips the second qubit only if the first qubit is 1.

Applying CNOT gate will modify the first qubit of the input state and will result in:

\frac{\alpha}{\sqrt{2}}|000\rangle + \frac{\alpha}{\sqrt{2}}|011\rangle + \frac{\beta}{\sqrt{2}}|110\rangle + \frac{\beta}{\sqrt{2}}|101\rangle

Hadamard gate changes states as follows:

|0\rangle \rightarrow \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle))


|1\rangle \rightarrow \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle))

Applying Hadmard gate results in:

\frac{\alpha}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle))|00\rangle + \frac{\alpha}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle))|11\rangle + \frac{\beta}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle-|1\rangle))|10\rangle + \frac{\beta}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle-|1\rangle))|01\rangle



which we can write as:


Then we measure the states of the first two qubits (message qubit and Laboratory 1 qubit) where we can have four results:

  • |00\rangle which simplifies equation to: |00\rangle(\alpha|0\rangle+\beta|1\rangle) and indicates that the qubit in the Laboratory 2 is \alpha|0\rangle+\beta|1\rangle

  • |01\rangle which simplifies equation to: |01\rangle(\alpha|1\rangle+\beta|0\rangle) and indicates that the qubit in the Laboratory 2 is \alpha|1\rangle+\beta|0\rangle

  • |10\rangle which simplifies equation to: |10\rangle(\alpha|0\rangle-\beta|1\rangle) and indicates that the qubit in the Laboratory 2 is \alpha|0\rangle-\beta|1\rangle

  • |11\rangle which simplifies equation to: |11\rangle(\alpha|1\rangle-\beta|0\rangle) and indicates that the qubit in the Laboratory 2 is \alpha|1\rangle-\beta|0\rangle

Now we have to send the result classical way from Laboratory 1 to Laboratory 2.

Finally we know what transformation we need to apply to qubit in the Laboratory 2
to make its state equal to message qubit:


if Laboratory 2 qubit is in state:

  • \alpha|0\rangle+\beta|1\rangle we don’t need to do anything.

  • \alpha|1\rangle+\beta|0\rangle we need to apply NOT gate.

  • \alpha|0\rangle-\beta|1\rangle we need to apply Z gate.

  • \alpha|1\rangle-\beta|0\rangle we need to apply NOT gate followed by Z gate

This operations will transform Laboratory 2 qubit state to initial message qubit state thus we moved the particle state from Laboratory 1 to Laboratory 2 without moving particle.

2. Code

Now it’s time to show the quantum teleportation using Q# language. I have used Microsoft Quantum Development Kit to run the Q# code inside the .NET Core application. Additionally I have added the nginx proxy with the angular gui which will help to show the results.
Everything was put inside the docker to simplify the setup.

Before you will start you will need git, docker and docker-compose installed on your machine (

To run the project we have to clone the repository and run it using docker compose:

git clone
cd quantum-teleportation-qsharp
docker-compose -f app/docker-compose.yml up

Now we can run the http://localhost:8020/ in the browser:

Then we can put the message in the Laboratory 1, click the Teleport button, trigger for the teleportation process which sends the message to the Laboratory 2.

The text is converted into array of bits and each bit is sent to the Laboratory 2 using quantum teleportation.

In the first step we encode the incoming message using X gate.

if (message) {

Then we prepare the entanglement between the qubits in the Laboratory 1 and Laboratory 2.

CNOT(here, there);

In the second step we apply CNOT and Hadamard gate to send the message:

CNOT(msg, here);

Finally we measure the message qubit and the Laboratory 1 qubit:

if (M(msg) == One) {

if (M(here) == One) {

If the message qubit has state |1\rangle then we need to apply the Z gate to the Laboratory 2 qubit.
If the Laboratory 1 qubit has state |1\rangle then we need to apply the X gate to the Laboratory 2 qubit. This information must be sent classical way to the Laboratory 2.

Now the Laboratory 2 qubit state is equal to the initial message qubit state and we can check it:

if (M(there) == One) {
    set measurement = true;

This kind of communication is secure because even if someone will take over the information sent classical way it is still impossible to decode the message.