**Introduction**: IBM opened the doors of its Quantum Computing Environment, termed “Quantum Experience” to the general public about 10 days back. The access to IBM’s Quantum Experience is through Bluemix service , IBM’s PaaS (Platform as a Service). So I signed up for IBM’s quantum experience with great excitement. So here I am, an engineer trying to enter into and understand the weird,weird world of the quantum physicist!

*Disclaimer: This article represents the author’s viewpoint only and doesn’t necessarily represent IBM’s positions, strategies or opinions*

The idea of Quantum computing was initially mooted by Nobel Laureate Richard Feynman, Yuri Manning and Paul Benioff in the 1980s. While there was some interest in the field for the next several years, work in Quantum computing received a shot in the arm after Peter Shor’s discovery of an efficient quantum algorithm for integer factorization and discrete logarithms.

Problems that are considered to be computationally hard to solve with classical computers can be solved through quantum computing with an exponential improvement in efficiency. Some areas that are supposed to be key candidates for quantum computing, are quantum money and cryptography.

Quantum computing will become predominant in our futures owing to 2 main reasons. The 1st reason, as already mentioned, is extraordinary performance improvements. The 2nd is due to the process of miniaturization. Ever since the advent of the transistor and the integrated circuit, the advancement in computing has led the relentless pursuit of miniaturization., In recent times the number of transistors has increased to such an extent, that quantum effects become apparent, at such micro levels, while making the chips extremely powerful and cheap. The 18 core Xeon Haswell Inel processoir packs 5.5 billion transistor in 661 mm^{2}

^{ }In classical computers the computation is based on the ‘binary digit’ or ‘bit’ which can be in either state 0 or 1. In quantum computing the unit of computation is the ‘quantum bit’ or the qubit. The quantum bit can be in the states of 0, 1 and both simultaneously by the principle of superposition.

A qubit is a quantum system consisting of two levels, labeled |0⟩ and |1⟩ (using Dirac’s bracket notation) and is represented by a two-dimensional vector space.

|0>=

|1>=

Consider some physical system that can be in N different, mutually exclusive classical states. Then in the classical computing the system can be in one of the states. For e.g. if we had 3 bits the classical computer could be in one of {000,001,010,011,100,101,110,111} states.

A quantum computer takes advantage of a special kind of superposition that allows for exponentially many logical states at once, all the states from |00…0⟩ to |11…1⟩

Hence, the qubit need not be |0> or |1> but can be in any state |Ψ> which can be any superposition |ψ⟩=α|0⟩+β|1⟩, where α and β are the amplitudes. The superposition quantities α and β are complex numbers and obey |α|^{2}+|β|^{2}=1

Let us consider a system which had N different mutually exclusive states. Using Dirac’s notation these states can be represented as |1>, |2>. . . |N>.

A pure quantum state is a superposition of all these states

Φ = α_{1 }|1> + α_{2 }|2> + …. + α_{N }|N>

Where α_{i }is the amplitude of qubit ‘I’ |i> in Φ. Hence, a system in quantum state |φi is in all classical states at the same time. It is state |1> with an amplitude of α1, in state |2> with an amplitude α2 etc.

A quantum system which is in all states at once can be either measured or allowed to evolve unitarily without measuring

**Measurement**

The interesting fact is that when we measure the quantum state Φ, the measured state will not be the quantum state Φ, but one classical state |j> , where |j> is one of the states |1>,|2,.. |N>. The likelihood for the measured state to be |j> is dependent on the probability |α_{j} |^{2}, which is the squared norm of the corresponding amplitude αj. Hence observing the quantum state Φ results in the collapse of the quantum superposition state Φ top a classical state |j> and all the information in the amplitudes α_{j }I

Φ = α1 |1> + α2 |2> + … + αN |N>

**Unitary evolution**

The other alternative is instead of measuring the quantum state Φ, is to apply a series of unitary operations and allow the quantum system to evolve.

In this post I use IBM’s Quantum Experience. The IBM’s Quantum Experience uses a type of qubit made from superconducting materials such as niobium and aluminum, patterned on a silicon substrate.

For this superconducting qubit to behave as the abstract notion of the qubit, the device is cooled down considerably. In fact, in the IBM Quantum Lab, the temperature is maintained at 5 milliKelvin, in a dilution refrigerator

The Quantum Composer a Graphical User Interface (GUI) for programming the quantum processor. With the quantum composer we can construct quantum circuits using a library of well-defined gates and measurements.

The IBM’s Quantum Composer is designed like a musical staff with 5 horizontal lines for the 5 qubits. Quantum gates can be dragged and dropped on these horizontal lines to operate on the qubits

Quantum gates are represented as unitary matrices, and operations on qubits are matrix operations, and as such require knowledge of linear algebra. It is claimed, that while the math behind quantum computing may not be too hard, the challenge is that certain aspects of quantum computing are counter-intuitive. This should be challenge. I hope that over the next few months I will be able to develop at least some basic understanding for the reason behind the efficiency of quantum algorithms

**Pauli gates**

The operation of a quantum gate can be represented as a matrix. A gate that acts on one qubit is represented by a 2×2 unitary matrix. A unitary matrix is one, in which the conjugate transpose of the matrix is also its inverse. Since quantum operations need to be reversible, and preserve probability amplitudes, the matrices must be unitary.

*To understand the operations of the gates on the qubits, I have used R language to represent matrices, and to perform the matrix operations. Personally , this made things a lot clearer to me!*

**Performing measurement**

The following picture shows how the qubit state is measured in the Quantum composer

**Simulation in the Quantum Composer**

When the above measurement is simulated in the composer by clicking the ‘Simulate’ button the result is as below

This indicates that the measurement will display qubit |0> with a 100% probability or the qubit is in the ‘idle’ state.

**A) Pauli operators**

A common group of gates are the Pauli operators

**a) The Pauli X**

|0> ==> X|0> ==> |1>

The Pauli X gate which is represented as below does a bit flip

This can be composed in the Quantum composer as

When this simulated the Pauli X gate does a bit flip and the result is

which is qubit |1> which comes up as 1 (100% probability)

**Pauli operator X using R code**

```
# Qubit '0'
q0=matrix(c(1,0),nrow=2,ncol=1)
q0
```

```
## [,1]
## [1,] 1
## [2,] 0
```

```
# Qubit '1'
q1=matrix(c(0,1),nrow=2,ncol=1)
q1
```

```
## [,1]
## [1,] 0
## [2,] 1
```

```
# Pauli operator X
X= matrix(c(0,1,1,0),nrow=2,ncol=2)
X
```

```
## [,1] [,2]
## [1,] 0 1
## [2,] 1 0
```

```
# Performing a X operation on q0 flips a q0 to q1
a=X%*%q0
a
```

```
## [,1]
## [1,] 0
## [2,] 1
```

**b) Pauli operator Z**

The Z operator does a phase flip and is represented by the matrix

**Simulation in the Quantum composer**

**Pauli operator Z using R code**

```
# Pauli operator Z
Z=matrix(c(1,0,0,-1),nrow=2,ncol=2)
Z
```

```
## [,1] [,2]
## [1,] 1 0
## [2,] 0 -1
```

```
# Performing a Z operation changes the phase and leaves the bit
a=Z%*%q0
a
```

```
## [,1]
## [1,] 1
## [2,] 0
```

**c) Pauli operator Y**

The Pauli operator Y does both a bit and a phase flip. The Y operator is represented as

Simulating in the composer gives the following

**Pauli operator Y in R code**

```
# Pauli operator Y
Y=matrix(c(0,-1i,1i,0),nrow=2,ncol=2)
Y
```

```
## [,1] [,2]
## [1,] 0+0i 0+1i
## [2,] 0-1i 0+0i
```

```
# Performing a Y operation does a bit flip and changes the phase
a=Y%*%q0
a
```

```
## [,1]
## [1,] 0+0i
## [2,] 0-1i
```

**B) Superposition**

Superposition is the concept that adding quantum states together results in a new quantum state. There are 3 gates that perform superposition of qubits the H, S and S’ gate.

**a) H gate (Hadamard gate)**

The H gate, also known as the Hadamard Gate when applied |0> state results in the qubit being half the time in |0> and the other half in |1>

The H gate can be represented as

1/√2

```
# Superposition gates
# H, S & S1
H=1/sqrt(2) * matrix(c(1,1,1,-1),nrow=2,ncol=2)
H
```

```
## [,1] [,2]
## [1,] 0.7071068 0.7071068
## [2,] 0.7071068 -0.7071068
```

**b) S gate**

The S gate can be represented as

```
S=matrix(c(1,0,0,1i),nrow=2,ncol=2)
S
```

```
## [,1] [,2]
## [1,] 1+0i 0+0i
## [2,] 0+0i 0+1i
```

**c) S’ gate**

And the S’ gate is

```
S1=matrix(c(1,0,0,-1i),nrow=2,ncol=2)
S1
```

```
## [,1] [,2]
## [1,] 1+0i 0+0i
## [2,] 0+0i 0-1i
```

**d) Superposition (+)**

Applying the Hadamard gate H to |0> causes it to become |+>. This is the standard superposition state

Where |+> = 1/√2 (|0> + |1>)

|0> ==> H|0> ==> |+>

Where the qubit is one half of the time in |0> and the other half of the time in |1>

**Simulating in the Composer**

**Superposition(+) in R code**

Superposition of qubit |0> results in |+> as shown below

|0> ==> H|0> ==> |+>

```
# H|0>
a <- H%*%q0
a
```

```
## [,1]
## [1,] 0.7071068
## [2,] 0.7071068
```

```
# This is equal to 1/sqrt(2) (|0> + |1>)
b <- 1/sqrt(2) * (q0+q1)
b
```

```
## [,1]
## [1,] 0.7071068
## [2,] 0.7071068
```

**e) Superposition (-)**

A new qubit state |-> is obtained by applying the H gates to |0> and then applying the Z gate which is known as the diagonal basis. The H makes the above superposition and then the Z flips the phase (|1⟩ to −|1⟩)

Where |-> = 1/√2 (|0> – |1>)

|0> ==> Z*H*|0> ==> |->

**Superposition(-) in R code**

```
# The diagonal basis
# It can be seen that a <==>b
a <- Z%*%H%*%q0
a
```

```
## [,1]
## [1,] 0.7071068
## [2,] -0.7071068
```

```
b <- 1/sqrt(2) * (q0-q1)
b
```

```
## [,1]
## [1,] 0.7071068
## [2,] -0.7071068
```

**C) Measuring superposition**

But when we measure the superposition states the result is always a 0 or 1. In order to distinguish between the |+> and the |-> states we need to measure in the diagonal basis. This is done by using the H gate before the measurement

**a) Superposition (+) measurement**

**Superposition(+) in R code**

```
# Superposition (+) measurement
a <- H%*%H%*%q0
# The result is |0>
a
```

```
## [,1]
## [1,] 1
## [2,] 0
```

**b) Superposition (-) measurement**

**Simulating in composer**

**Simulating Superposition(-) in R code**

```
# Superposition (-) measurement
a <- H%*%Z%*%H%*%q0
#The resultis |1>
a
```

```
## [,1]
## [1,] 0
## [2,] 1
```

**D) Y basis**

A third basis us the circular or Y basis

|ac*> = 1/√2(|0> + i|1>)

ac* – the symbol is an anti-clockwise arrow

And

|c*> = 1/√2(|0> – i|1>)

c* – the symbol for clockwise arrow

**a) Superposition (+i)Y**

**Superposition (+i)Y in R code**

```
#Superposition(+i) Y
a <- S%*%H%*%q0
a
```

```
## [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000+0.7071068i
```

```
b <- 1/sqrt(2)*(q0 +1i*q1)
b
```

```
## [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000+0.7071068i
```

**b) Superposition(-i)Y **

**Simulating Superposition (-i)Y in Quantum Composer**

**Superposition (-i)Y in R **

```
#Superposition(-i) Y
a <- S1%*%H%*%q0
a
```

```
## [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000-0.7071068i
```

```
b <- 1/sqrt(2)*(q0 -1i*q1)
b
```

```
## [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000-0.7071068i
```

To measure the circular basis we need to add a S1 and H gate

**c) Superposition (+i) Y measurement**

**Simulation in Quantum composer**

**Superposition (+i) Y in R **

```
#Superposition(+i) Y measurement
a <- H%*%S1%*%S%*%H%*%q0
a
```

```
## [,1]
## [1,] 1+0i
## [2,] 0+0i
```

**d) Superposition (-Y) simulation**

**Superposition (-i) Y in R**

```
#Superposition(+i) Y measurement
a <- H%*%S1%*%S%*%H%*%q0
a
```

```
## [,1]
## [1,] 1+0i
## [2,] 0+0i
```

I hope to make more headway and develop the intuition for quantum algorithms in the weeks and months to come.

Watch this space. I’ll be back!

*Disclaimer: This article represents the author’s viewpoint only and doesn’t necessarily represent IBM’s positions, strategies or opinions*

**References**

1.IBM’s Quantum Experience User Guide

2. Quantum computing lecture notes

**Also see**

1. Natural language processing: What would Shakespeare say?

2. Literacy in India – A deepR dive

3. Re-introducing cricketr! : An R package to analyze performances of cricketers

4. Design Principles of Scalable, Distributed Systems

5. A closer look at “Robot Horse on a Trot” in Android

6. What’s up Watson? Using IBM Watson’s QAAPI with Bluemix, NodeExpress – Part 1

7. Introducing cricket package yorkr: Part 1- Beaten by sheer pace!

8. Experiments with deblurring using OpenCV

9. Architecting a cloud based IP Multimedia System (IMS)

Pingback: Going deeper into IBM’s Quantum Experience! | Giga thoughts …

Pingback: A primer on Qubits, Quantum gates and Quantum Operations | Giga thoughts …

Pingback: Exploring Quantum Gate operations with QCSimulator | Giga thoughts …

Pingback: Taking a closer look at Quantum gates and their operations | Giga thoughts …

Pingback: Introducing QCSimulator: A 5-qubit quantum computing simulator in R | Giga thoughts …