“If you are not completely confused by quantum mechanics, you do not understand it.”

~ John Wheeler

## Introduction

i wanted to take advantage of the #socialdistancing to catch up on personal blog writing. One of the areas that i have been meaning to start is my sojourn into the area of Quantum Computing specifically with IBM Q framework Qiskit (pronounced *KIZ-KIT)*. Qiskit is an open-source quantum computing software development framework for leveraging today’s quantum processors in research, education, and business. Having read many of the latest texts (which i will add at the end of the blog) as well as initially implementing some initial *Hello_World* python scripts i decided to put it away due to the fact it made Alice In Wonderland’s Rabbit hole look tame. I did, however, go through some of the initial IBM Learnings and received the following:

So given that i decided to fully re-engage and start the process the first steps as with any language or framework is to create the proverbial “Hello_World”. However, before we get into the code lets address what is in the Qiskit coding framework.

The following components are within the Qiskit framework: Terra, Aer, Aqua, and Ignis:

**Terra**: Within Terra is a set of tools for composing quantum programs at the level of circuits and pulses, optimizing them for the constraints of a particular physical quantum processor, and managing the batched execution of experiments on remote-access backends.- User Inputs (Circuits, and Schedules), Quantum Circuit, Pulse Schedule
- Transpilers and optimization passes
- Providers: Aer, IBM Quantum, and Third Party
- Visualization and Quantum Information Tools (Histogram, State, Unitary, Entanglement)

**Aer :**It contains optimized C++ simulator backends for executing circuits compiled in Qiskit Terra and tools for constructing highly configurable noise models for performing realistic noisy simulations of the errors that occur during execution on real devices.- Noise Simulation (QasmSimulator Only)
- Backends ( QasmSimulator, StatevectorSimulator, UnitarySimulator)
- Jobs and Results: Counts, Memory, Statevector, Unitary, Snapshots

**Aqua**: Libraries of cross-domain quantum algorithms upon which applications for near-term quantum computing can be built. Aqua is designed to be extensible and employs a pluggable framework where quantum algorithms can easily be added.- Qiskit Aqua Translators ( Chemistry, AI, Optimization, Finance )
- Quantum Algorithms ( QPE, Grover, HHL, QSVM, VQE, QAOA, etc… )
- Qiskit Terra ( Compile Circuits)
- Providers: Aer, IBM Quantium and Third Party

**Ignis**: A framework for understanding and mitigating noise in quantum circuits and systems. The experiments provided in Ignis are grouped into the topics of characterization, verification and mitigation.- Experiments: List of Quantum Circuits and Pulse Schedules
- Qiskit Terra: Compile Circuits or Schedules
- Providers: Qiskit Aer, IBM Quantum, Third Party
- Fitters / Filters: Fit to a Model/Plot Results, Filter Noise

As one can see the components are cross-referenced across the entirety of the framework and provide the quantum developer a rich set of tools, algorithms, and methods for code creation.

## Putting Your Toe In The First Quantum World

This section covers very basic quantum theory. There are several great textbooks on this subject and i will list some at the end of the blog with brief reviews. Suffice to say you cannot be scared or shy away from “greek letters or strange symbols”. To fully appreciate what is happening you need “the maths”. That said let us first define a qubit. *Classical Computers* operate on ( 0 ) or ( 1 ). Complete binary operations due to the nature of a diode or gate. *Quantum Computers *operate on *quBits* for *Quantum Bits*. These are represented by surrounding a *name* by ” | ” and ” > “. Thus a Qubit “named” “1” can be written as \(| 1\rangle\). This notation is known as *Dirac’s* *bra-ket *notation. Specifically from a mathematical standpoint and this is why the above uses the label “named” it is represented by a two-dimensional vector space over complex numbers \(\mathbb{C}^2\). This means that a Qubit takes two complex numbers to fully describe it. Okay so *think about that… It takes two numbers to describe the state. *Already strange huh? The computational (or standard) basis corresponds to the two levels \(|0\rangle\) and \(|1\rangle\), which corresponds to the following vectors: $$\begin{split}|0\rangle = \begin{pmatrix}1\\ 0 \end{pmatrix}~~~~|1\rangle=\begin{pmatrix}0\\1\end{pmatrix}\end{split}$$ So remember that the state is described by two complex numbers. Well, the qubit does not always have to be in either \(|0\rangle\) or \(|1\rangle\) ; it can be in an arbitrary quantum state, denoted \(|\psi\rangle\), which can be any *superposition* \((|\psi\rangle\ = \alpha|0\rangle + \beta|1\rangle\) of the basis vectors. The superposition quantities \(\alpha\) and (\beta\) are complex numbers; together they obey \(|\alpha|^2 + |\beta| = 1 \) . Interesting things happen when quantum systems are measured, or observed. Quantum measurement is described by the Born rule. In particular, if a qubit in some state \(|\psi\rangle\), is measured in the standard basis, the result **0** is obtained with probability \(|\alpha|^2\), and the result **1** is obtained with the complementary probability \(|\beta|^2\). Interestingly, a quantum measurement takes any superposition state of the qubit, and* projects* it to either the state \(|0\rangle\) or the state \(|1\rangle\), with a probability determined from the *parameters of the superposition*. Whew! What i found really cool was that all of the linear algebra is the same. Here is another really cool thing: To actually create the environment the amazing scientists at IBM In the IBM Quantum Lab keep the temperature cold (15 milliKelvin in a dilution refrigerator) that there is no ambient noise or heat to excite the superconducting qubit. It is beyond the scope of why this is needed but suffices to say it involves making a superconductor, and that is when a material conducts electricity without encountering any resistance, thus without losing any energy.* Ok,* let’s climb out of Alice’s Rabbit Hole and get to some practical code.

## Setting Up The Environment

So we are assuming the reader is familiar with setting up a python virtual environment and able to either pip install or utilize a package manager like anaconda for installing the respective libraries. The complete installation process can be found here: Installing QisKit. For completeness, i will duplicate the cogent items in the following sections. i’ll also be posting a Juypyter Notebook to github.

The simplest way to use environments is by using the `conda`

command,
included with Anaconda. A Conda environment allows you to specify a specific
version of Python and set of libraries. Open a terminal window in the directory
where you want to work.

Create a minimal environment with only Python installed in it.

conda create -n name_of_my_env python=3

source activate name_of_your_env

Next, install the Qiskit package, which includes Terra, Aer, Ignis, and Aqua. ( in this writeup i will only focus on the very basics. i will get to the others in later posts! )

pip install qiskit

*NOTE:* Starting with Qiskit 0.13.0 pip 19 or newer is needed to install `qiskit-aer `

from precompiled binary on Linux. If you do not have pip 19 installed you can run `pip install -U pip`

to upgrade it. Without `pip 19`

or newer this command will attempt to install `qiskit-aer`

from `sdist`

(source distribution) which will try to compile `aer`

locally under the covers.

If the packages installed correctly, you can run `conda list`

to see the active packages in your virtual environment.

There are some optional packages i suggest installing for really cool circuits visualizations and like that work in conjunction with `matplotlib`

. You can install these optional dependencies by with the following command:

pip install qiskit-terra[visualization]

To check if everything is running hop into the python prompt and type:

import Qiskit

## Getting an IBM Q account and API Key

Next, you will need to register for an IBM Q account. Click this link -> Register For IBM Q Account

Here is link just in case:

https://quantum-computing.ibm.com/

IBM Q allows you to interface directly with IBM’s remote quantum hardware and quantum simulation devices. You can execute code locally on a quantum simulator however getting access to the hardware and understanding how noise affects the circuits and measurements are crucial in understanding quantum algorithm development. As with any remote system you need to lock it to an API Key. When you login you will see the following:

Generate the API token and then click on **Copy API Token** to copy your API Token and place into into your Jupyter Notebook. I recommend using **JupyterLab Credential Store** for these types of tokens and login credentials. We will come back to using the API Key so dont misplace it!

So i am assuming you made it this far and have your ` venv `

activated and your Jupyter Lab / Notebook up and running.

Check your installation by performing the following. It should print out the latest version. Also run the following commands to store your API token locally for later use in a configuration file called `qiskitrc`

. Replace `MY_API_TOKEN`

with the API token value that you stored in your text editor or Jupyter Notebook. Note this method saves the credentials and token to disc. It is a matter of taste you can choose in session usage as well. These are some standard imports.

%matplotlib inline import numpy as np from qiskit import * from qiskit import IBMQ from qiskit.tools.visualization import plot_histogram qiskit.__version__ qiskit.__qiskit_version__ IBMQ.save_account('MY_API_TOKEN') # THIS IS YOUR API KEY FROM EARLIER!

`[1]: 0.12.0 `

i appear to be up to date.

Next you want to make sure you are up to date on the latest versioning of the platform. Since November 2019 (and with version `0.4`

of this `qiskit-ibmq-provider`

package), the IBM Quantum Provider only supports the new IBM Quantum Experience, dropping support for the legacy Quantum Experience and Qconsole accounts. The new IBM Quantum Experience is also referred to as `v2`

, whereas the legacy one and Qconsole as `v1`

.

IBMQ.update_account()

Depending on your credentials you will either get a listing of updating credentials or that you are up to date.

IBM Q has various backends to run your code upon. The default is a full-fledged simulator that is invoked locally which is very convenient. The next invocation method is via direct quantum computing hardware access. i must say it is astounding that one can access via open-source quantum computing resources.

By default, all IBM Quantum Experience accounts have access to the same, open project (hub: `ibm-q`

, group: `open`

, project: `main`

). For convenience, the `IBMQ.load_account()`

and `IBMQ.enable_account()`

methods will return a provider for that project. If you have access to other projects, you can use:

provider_2 = IBMQ.get_provider(hub='MY_HUB', group='MY_GROUP', project='MY_PROJECT')

i used the following to check out the available backends that are available. Note: The name is just a name – not the location of the hardware:

provider = IBMQ.get_provider(group='open') provider.backends()

[10:] [<IBMQSimulator('ibmq_qasm_simulator') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmqx2') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_16_melbourne') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_vigo') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_ourense') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_london') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_burlington') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_essex') from IBMQ(hub='ibm-q', group='open', project='main')>, <IBMQBackend('ibmq_armonk') from IBMQ(hub='ibm-q', group='open', project='main')>]

## Running Your First Circuits

There are several ways to run your first circuits. There is online access via in place Jupyter Notebooks as well as a visual circuit designer called IBM Circuit Composer which you can access via your IBM Q account. i will be describing steps using python code and direct Qiskit usage due to flexibility, transparency, and granularity over the environment. This will set it to the ` 'ibmq_qasm_simulator' `

my_provider = IBMQ.get_provider() my_provider.backends() my_provider.get_backend('ibmq_qasm_simulator')

So some terminology* registers *are used to create *circuits. *Circuits act upon registers. Now lets actually look at some code that generates some registers as well as a quantum circuit:

Here we a script that starts off with an input of 2 quantum “0” bits There is no action before it outputs a classical equivalent of bits:

So if you run this you will get the output:

Total count for 00 and 11 are: {'00': 517, '11': 483}

Here is what is happening:

`QuantumCircuit.h(0)`

: A Hadamard gate*𝐻*on qubit 0, which puts it into a**superposition state**.`QuantumCircuit.cx(0, 1)`

: A controlled-Not operation (*𝐶𝑋*) on control qubit 0 and target qubit 1, putting the qubits in an**entangled state**.`QuantumCircuit.measure([0,1], [0,1])`

: if you pass the entire quantum and classical registers to`measure`

, the ith qubit’s measurement result will be stored in the ith classical bit.

So this is an ASCII printout. i was really impressed when i found out this tidbit. You can also pass in “mpl” for matplotlib or “latex” for full on latex beautification!

circuit.draw("mpl") and circuit.draw("latex")

NOTE: The `latex`

and `latex_source`

drawers need `pylatexenc`

installed. Run `"pip install pylatexenc" `

before using the `latex`

or `latex_source`

drawers. Professor Donald Knuth will be pleased.

#Plot a histogram plot_histogram(counts)

The observed probabilities *𝑃𝑟*(00) and *𝑃𝑟*(11) are computed by taking the respective counts and dividing by the total number of shots.

## Next Steps

So this is just a small step into the world of quantum programming. Below i have included several resources for study. If you are interested in pursuing this area i do urge you to take your time. i hope this at least gives you a perspective and provides a vehicle for entry. i personally feel completely humbled every time i start to read or re-read something in this area. Quantum computing is going to change the way view our world. i for one will be going deeper in this area as far as i am intellectually capable of taking the process.

**NOTE**: This the title of this blog refers to the theory of Minowski Multi-Worlds with a pun on Hello_World. The many-worlds interpretation implies that there is a very large—perhaps infinite number of universes. It is one of many multiverse hypotheses in physics and philosophy. MWI views time as a many-branched tree, wherein every possible quantum outcome is realized**.**

## Resources

IBM Q User Guides All of the official IBM Q User Guides – very comprehensive.

IBM Q Wikipedia – A good readers digest of the history of IBM Q

The IBM Quantum Experience – the entry and dashboard experience

IBM Q online book – an amazing interactive experience covers everything from physics, linear algebra to code.

Mastering Quantum Computing with IBMQX – a great practical well-written book on how to get your hands coding on IBM Q

Dancing with Qubits – Written by Dr Bob Sutor of IBM a wonderful text on the mathematics and processes of quantum computing

Practical Quantum for Developers – a multi-disciplinary book that covers all aspects of coding for quantum from python, apis, cryptography, and even game theory.

Quantum Computing – A Gentle Introduction – this book covers the fundamentals of quantum computing in a very pragmatic fashion and focuses on the mathematical aspects.

Quantum Algorithms via Linear Algebra – the title is the content. ready set Linear Algebra – its the same stuff only quantum!

Quantum Computing for Computer Scientists – very close to the Gentle Introduction text however it covers the theory in-depth and also goes over several different types of algorithms.

Minowski Multi Worlds – The many-worlds interpretation implies that there is a very large perhaps infinite number of universes. It is one of many multiverse hypotheses in physics and philosophy. MWI views time as a many-branched tree, wherein every possible quantum outcome is realized. This is intended to resolve some paradoxes of quantum theory, such as the EPR paradox and Schrödinger’s cat since every possible outcome of a quantum event exists in its own universe. If you ask i’ll say the cat is dead.

Until then,

#IWishYouWater