A First Glimpse of Rigetti’s Quantum Computing Cloud

Quantum computing has been picking up the momentum, and there are many startups and scholars discussing quantum machine learning. A basic knowledge of quantum two-level computation ought to be acquired.

Recently, Rigetti, a startup for quantum computing service in Bay Area, published that they opened to public their cloud server for users to simulate the use of quantum instruction language, as described in their blog and their White Paper. It is free.

Go to their homepage, http://rigetti.com/, click on “Get Started,” and fill in your information and e-mail. Then you will be e-mailed keys of your cloud account. Copy the information to a file .pyquil_config, and in your .bash_profile, add a line

export PYQUIL_CONFIG="$HOME/.pyquil_config"

More information can be found in their Installation tutorial. Then install the Python package pyquil, by typing in the command line:

pip install -U pyquil

Some of you may need to root (adding sudo in front).

Then we can go ahead to open Python, or iPython, or Jupyter notebook, to play with it. For the time being, let me play with creating an entangled singlet state,

The corresponding quantum circuit is like this:

First of all, import all necessary libraries:

import numpy as np
 
from pyquil.quil import Program
import pyquil.api as api
from pyquil.gates import H, X, Z, CNOT

You can see that the package includes a lot of quantum gates. First, we need to instantiate a quantum simulator:

# starting the quantum simulator
quantum_simulator = api.SyncConnection()

Then we implement the quantum circuit with a “program” as follow:

# generating singlet state
# 1. Hadamard gate
# 2. Pauli-Z
# 3. CNOT
# 4. NOT
p = Program(H(0), Z(0), CNOT(0, 1), X(1))
wavefunc, _ = quantum_simulator.wavefunction(p)

The last line gives the final wavefunction after running the quantum circuit, or “program.” For the ket, the rightmost qubit is qubit 0, and the left of it is qubit 1, and so on. Therefore, in the first line of the program, H, the Hadamard gate, acts on qubit 0, i.e., the rightmost qubit. Running a simple print statement:

print wavefunc

gives

(-0.7071067812+0j)|01> + (0.7071067812+0j)|10>

The coefficients are complex, and the imaginary part is described by j. You can extract it as a numpy array:

wavefunc.amplitudes

If we want to calculate the metric of entanglement, we can use the Python package pyqentangle, which can be installed by running on the console:

​​​​​​​​​​​pip install -U pyqentangle

Import them:

from pyqentangle import schmidt_decomposition
from pyqentangle.schmidt import bipartitepurestate_reduceddensitymatrix
from pyqentangle.metrics import entanglement_entropy, negativity

Because pyqentangle does not recognize the coefficients in the same way as pyquil, but see each element as the coefficients of |ji>, we need to reshape the final state first, by:

tensorcomp = wavefunc.amplitudes.reshape((2, 2))

Then perform Schmidt decomposition (which the Schmidt modes are actually trivial in this example):

# Schmidt decomposition
schmidt_modes = schmidt_decomposition(tensorcomp)
for prob, modeA, modeB in schmidt_modes:
   print prob, ' : ', modeA, ' ', modeB

This outputs:

0.5  :  [ 0.+0.j  1.+0.j]   [ 1.+0.j  0.+0.j]
0.5  :  [-1.+0.j  0.+0.j]   [ 0.+0.j  1.+0.j]

Calculate the entanglement entropy and negativity from its reduced density matrix:

print 'Entanglement entropy = ', entanglement_entropy(bipartitepurestate_reduceddensitymatrix(tensorcomp, 0))
print 'Negativity = ', negativity(bipartitepurestate_reduceddensitymatrix(tensorcomp, 0))

which prints:

Entanglement entropy =  0.69314718056
Negativity =  -1.11022302463e-16

The calculation can be found in this thesis.

P.S.: The circuit was drawn by using the tool in this website, introduced by the Marco Cezero’s blog post. The corresponding json for the circuit is:

{"gate":[], 
"circuit": [{"type":"h", "time":0, "targets":[0], "controls":[]}, 
    {"type":"z", "time":1, "targets":[0], "controls":[]},
    {"type":"x", "time":2, "targets":[1], "controls":[0]},
    {"type":"x", "time":3, "targets":[1], "controls":[]}], "qubits":2,"input":[0,0]}

Original post: https://datawarrior.wordpress.com/2017/09/20/a-first-glimpse-of-rigettis-quantum-computing-cloud/

References:

• Kwan-Yuet Ho, “On Quantum Computing,” Everything About Data Analytics, WordPress (2016). [WordPress]
• Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, Seth Lloyd, “Quantum Machine Learning,” Nature 549:195–202 (2017). [Nature][arXiv]
• Rigetti Computing. [Rigetti]
• Madhav Thattai, Will Zeng, “Rigetti Partners with CDL to Drive Quantum Machine Learning,” Rigetti Computing, Medium (2017). [Medium]
• Robert S. Smith, Michael J. Curtis, William J. Zeng, “A Practical Quantum Instruction Set Architecture,” arXiv:1608.03355 (2016). [arXiv] (White Paper)
• Homepage of pyQuil. [RTFD]
• Github: rigetticomputing/pyquil. [Github]
• hahakity, “免费云量子计算机试用指南,” 知乎专栏. (2017) [Zhihu] (in Chinese)
• Homepage of PyQEntangle. [RTFD]
• Github: stephenhky/pyqentangle. [Github]
• Kwan-Yuet Ho, “Quantum Entanglement in Continuous Systems,” BSc Thesis, Department of Physics, Chinese University of Hong Kong. (2004) [ResearchGate]
• Kwan-Yuet Ho, “The Legacy of Entropy,” Everything About Data Analytics, WordPress (2015). [WordPress]
• Marco Cerezo, “Tools for Drawing Quantum Circuits,” Entangled Physics: Quantum Information & Quantum Computation. (2016) [WordPress]