Introducing QCSimulator: A 5-qubit quantum computing simulator in R


Introduction

My 5-qubit Quantum Computing Simulator,QCSimulator, is finally ready, and here it is! I have been able to successfully complete this simulator by working through a fair amount of material. To a large extent, the simulator is easy, if one understands how to solve the quantum circuit. However the theory behind quantum computing itself, is quite formidable, and I hope to scale this mountain over a period of time.

QCSimulator is now on CRAN!!!

The code for the QCSimulator package is also available at Github QCSimulator. This post has also been published at Rpubs as QCSimulator and can be downloaded as a PDF document at QCSimulator.pdf

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

install.packages("QCSimulator")
library(QCSimulator)
library(ggplot2)

1. Initialize the environment and set global variables

Here I initialize the environment with global variables and then display a few of them.

rm(list=ls())
#Call the init function to initialize the environment and create global variables
init()

# Display some of global variables in environment
ls()
##  [1] "I16"     "I2"      "I4"      "I8"      "q0_"     "q00_"    "q000_"  
##  [8] "q0000_"  "q00000_" "q00001_" "q0001_"  "q00010_" "q00011_" "q001_"  
## [15] "q0010_"  "q00100_" "q00101_" "q0011_"  "q00110_" "q00111_" "q01_"   
## [22] "q010_"   "q0100_"  "q01000_" "q01001_" "q0101_"  "q01010_" "q01011_"
## [29] "q011_"   "q0110_"  "q01100_" "q01101_" "q0111_"  "q01111_" "q1_"    
## [36] "q10_"    "q100_"   "q1000_"  "q10000_" "q10001_" "q1001_"  "q10010_"
## [43] "q10011_" "q101_"   "q1010_"  "q10100_" "q10101_" "q1011_"  "q10110_"
## [50] "q10111_" "q11_"    "q110_"   "q1100_"  "q11000_" "q11001_" "q1101_" 
## [57] "q11010_" "q11011_" "q111_"   "q1110_"  "q11100_" "q11101_" "q1111_" 
## [64] "q11110_" "q11111_"
#1. 2 x 2 Identity matrix 
I2
##      [,1] [,2]
## [1,]    1    0
## [2,]    0    1
#2. 8 x 8 Identity matrix 
I8
##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
## [1,]    1    0    0    0    0    0    0    0
## [2,]    0    1    0    0    0    0    0    0
## [3,]    0    0    1    0    0    0    0    0
## [4,]    0    0    0    1    0    0    0    0
## [5,]    0    0    0    0    1    0    0    0
## [6,]    0    0    0    0    0    1    0    0
## [7,]    0    0    0    0    0    0    1    0
## [8,]    0    0    0    0    0    0    0    1
#3. Qubit |00>
q00_
##      [,1]
## [1,]    1
## [2,]    0
## [3,]    0
## [4,]    0
#4. Qubit |010>
q010_
##      [,1]
## [1,]    0
## [2,]    0
## [3,]    1
## [4,]    0
## [5,]    0
## [6,]    0
## [7,]    0
## [8,]    0
#5. Qubit |0100>
q0100_
##       [,1]
##  [1,]    0
##  [2,]    0
##  [3,]    0
##  [4,]    0
##  [5,]    1
##  [6,]    0
##  [7,]    0
##  [8,]    0
##  [9,]    0
## [10,]    0
## [11,]    0
## [12,]    0
## [13,]    0
## [14,]    0
## [15,]    0
## [16,]    0
#6. Qubit 10010
q10010_
##       [,1]
##  [1,]    0
##  [2,]    0
##  [3,]    0
##  [4,]    0
##  [5,]    0
##  [6,]    0
##  [7,]    0
##  [8,]    0
##  [9,]    0
## [10,]    0
## [11,]    0
## [12,]    0
## [13,]    0
## [14,]    0
## [15,]    0
## [16,]    0
## [17,]    0
## [18,]    0
## [19,]    1
## [20,]    0
## [21,]    0
## [22,]    0
## [23,]    0
## [24,]    0
## [25,]    0
## [26,]    0
## [27,]    0
## [28,]    0
## [29,]    0
## [30,]    0
## [31,]    0
## [32,]    0

The QCSimulator implements the following gates

  1. Pauli X,Y,Z, S,S’, T, T’ gates
  2. Rotation , Hadamard,CSWAP,Toffoli gates
  3. 2,3,4,5 qubit CNOT gates e.g CNOT2_01,CNOT3_20,CNOT4_13 etc
  4. Toffoli State,SWAPQ0Q1

2. To display the unitary matrix of gates

To check the unitary matrix of gates, we need to pass the appropriate identity matrix as an argument. Hence below the qubit gates require a 2 x 2 unitary matrix and the 2 & 3 qubit CNOT gates require a 4 x 4 and 8 x 8 identity matrix respectively

PauliX(I2)
##      [,1] [,2]
## [1,]    0    1
## [2,]    1    0
Hadamard(I2)
##           [,1]       [,2]
## [1,] 0.7071068  0.7071068
## [2,] 0.7071068 -0.7071068
S1Gate(I2)
##      [,1] [,2]
## [1,] 1+0i 0+0i
## [2,] 0+0i 0-1i
CNOT2_10(I4)
##      [,1] [,2] [,3] [,4]
## [1,]    1    0    0    0
## [2,]    0    0    0    1
## [3,]    0    0    1    0
## [4,]    0    1    0    0
CNOT3_20(I8)
##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
## [1,]    1    0    0    0    0    0    0    0
## [2,]    0    0    0    0    0    1    0    0
## [3,]    0    0    1    0    0    0    0    0
## [4,]    0    0    0    0    0    0    0    1
## [5,]    0    0    0    0    1    0    0    0
## [6,]    0    1    0    0    0    0    0    0
## [7,]    0    0    0    0    0    0    1    0
## [8,]    0    0    0    1    0    0    0    0

3. Compute the inner product of vectors

For example of phi = 1/2|0> + sqrt(3)/2|1> and si= 1/sqrt(2)(10> + |1>) then the inner product is the dot product of the vectors

phi = matrix(c(1/2,sqrt(3)/2),nrow=2,ncol=1)
si = matrix(c(1/sqrt(2),1/sqrt(2)),nrow=2,ncol=1)
angle= innerProduct(phi,si)
cat("Angle between vectors is:",angle)
## Angle between vectors is: 15

4. Compute the dagger function for a gate

The gate dagger computes and displays the transpose of the complex conjugate of the matrix

TGate(I2)
##      [,1]                 [,2]
## [1,] 1+0i 0.0000000+0.0000000i
## [2,] 0+0i 0.7071068+0.7071068i
GateDagger(TGate(I2))
##      [,1]                 [,2]
## [1,] 1+0i 0.0000000+0.0000000i
## [2,] 0+0i 0.7071068-0.7071068i

5. Invoking gates in series

The Quantum gates can be chained by passing each preceding Quantum gate as the argument. The final gate in the chain will have the qubit or the identity matrix passed to it.

# Call in reverse order
# Superposition states
# |+> state
Hadamard(q0_)
##           [,1]
## [1,] 0.7071068
## [2,] 0.7071068
# |-> ==> H x Z 
PauliZ(Hadamard(q0_))
##            [,1]
## [1,]  0.7071068
## [2,] -0.7071068
# (+i) Y ==> H x  S 
 SGate(Hadamard(q0_))
##                      [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000+0.7071068i
# (-i)Y ==> H x S1
 S1Gate(Hadamard(q0_))
##                      [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000-0.7071068i
# Q1 -- TGate- Hadamard
Q1 = Hadamard(TGate(I2))

6. More gates in series

TGate of depth 2

The Quantum circuit for a TGate of Depth 2 is

Q0 — Hadamard-TGate-Hadamard-TGate-SGate-Measurement as shown in IBM’s Quantum Experience Composer

Untitled

Implementing the quantum gates in series in reverse order we have

# Invoking this in reverse order we get
a = SGate(TGate(Hadamard(TGate(Hadamard(q0_)))))
result=measurement(a)

plotMeasurement(result)

fig0-1

7. Invoking gates in parallel

To obtain the results of gates in parallel we have to take the Tensor Product Note:In the TensorProduct invocation the Identity matrix is passed as an argument to get the unitary matrix of the gate. Q0 – Hadamard-Measurement Q1 – Identity- Measurement

# 
a = TensorProd(Hadamard(I2),I2)
b = DotProduct(a,q00_)
plotMeasurement(measurement(b))

fig1-1

a = TensorProd(PauliZ(I2),Hadamard(I2))
b = DotProduct(a,q00_)
plotMeasurement(measurement(b))

fig1-2

8. Measurement

The measurement of a Quantum circuit can be obtained using the measurement function. Consider the following Quantum circuit
Q0 – H-T-H-T-S-H-T-H-T-H-T-H-S-Measurement where H – Hadamard gate, T – T Gate and S- S Gate

a = SGate(Hadamard(TGate(Hadamard(TGate(Hadamard(TGate(Hadamard(SGate(TGate(Hadamard(TGate(Hadamard(I2)))))))))))))
measurement(a)
##          0        1
## v 0.890165 0.109835

9. Plot measurement

Using the same example as above Q0 – H-T-H-T-S-H-T-H-T-H-T-H-S-Measurement where H – Hadamard gate, T – T Gate and S- S Gate we can plot the measurement

a = SGate(Hadamard(TGate(Hadamard(TGate(Hadamard(TGate(Hadamard(SGate(TGate(Hadamard(TGate(Hadamard(I2)))))))))))))
result = measurement(a)
plotMeasurement(result)

fig2-1

10. Evaluating a Quantum Circuit

The above procedures for evaluating a quantum gates in series and parallel can be used to evalute more complex quantum circuits where the quantum gates are in series and in parallel.

Here is an evaluation of one such circuit, the Bell ZQ state using the QCSimulator (from IBM’s Quantum Experience)

pic3

# 1st composite
a = TensorProd(Hadamard(I2),I2)
# Output of CNOT
b = CNOT2_01(a)
# 2nd series
c=Hadamard(TGate(Hadamard(SGate(I2))))
#3rd composite
d= TensorProd(I2,c)
# Output of 2nd composite
e = DotProduct(b,d)
#Action of quantum circuit on |00>
f = DotProduct(e,q00_)
result= measurement(f)
plotMeasurement(result)

fig3-1

11. Toffoli State

This circuit for this comes from IBM’s Quantum Experience. This circuit is available in the package. This is how the state was constructed. This circuit is shown below

pic2

The implementation of the above circuit in QCSimulator is as below

  # Computation of the Toffoli State
    H=1/sqrt(2) * matrix(c(1,1,1,-1),nrow=2,ncol=2)
    I=matrix(c(1,0,0,1),nrow=2,ncol=2)

    # 1st composite
    # H x H x H
    a = TensorProd(TensorProd(H,H),H)
    # 1st CNOT
    a1= CNOT3_12(a)

    # 2nd composite
    # I x I x T1Gate
    b = TensorProd(TensorProd(I,I),T1Gate(I))
    b1 = DotProduct(b,a1)
    c = CNOT3_02(b1)

    # 3rd composite
    # I x I x TGate
    d = TensorProd(TensorProd(I,I),TGate(I))
    d1 = DotProduct(d,c)
    e = CNOT3_12(d1)

    # 4th composite
    # I x I x T1Gate
    f = TensorProd(TensorProd(I,I),T1Gate(I))
    f1 = DotProduct(f,e)
    g = CNOT3_02(f1)

    #5th composite
    # I x T x T
    h = TensorProd(TensorProd(I,TGate(I)),TGate(I))
    h1 = DotProduct(h,g)
    i = CNOT3_12(h1)

    #6th composite
    # I x H x H
    j = TensorProd(TensorProd(I,Hadamard(I)),Hadamard(I))
    j1 = DotProduct(j,i)
    k = CNOT3_12(j1)

    # 7th composite
    # I x H x H
    l = TensorProd(TensorProd(I,Hadamard(I)),Hadamard(I))
    l1 = DotProduct(l,k)
    m = CNOT3_12(l1)
    n = CNOT3_02(m)

    #8th composite
    # T x H x T1
    o = TensorProd(TensorProd(TGate(I),Hadamard(I)),T1Gate(I))
    o1 = DotProduct(o,n)
    p = CNOT3_02(o1)
    result = measurement(p)
    plotMeasurement(result)

fig4-1

12. GHZ YYX measurement

Here is another Quantum circuit, namely the entangled GHZ YYX state. This is

pic1

and is implemented in QCSimulator as

# Composite 1
a = TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),PauliX(I2))
b= CNOT3_12(a)
c= CNOT3_02(b)
# Composite 2
d= TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),Hadamard(I2))
e= DotProduct(d,c)
#Composite 3
f= TensorProd(TensorProd(S1Gate(I2),S1Gate(I2)),Hadamard(I2))
g= DotProduct(f,e)
#Composite 4
i= TensorProd(TensorProd(Hadamard(I2),Hadamard(I2)),I2)
j = DotProduct(i,g)
result=measurement(j)
plotMeasurement(result)

fig5-1

Conclusion

The 5 qubit Quantum Computing Simulator is now fully functional. I hope to add more gates and functionality in the months to come.

Feel free to install the package from Github and give it a try.

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
  2. Quantum Computing in Python by Dr. Christine Corbett Moran
  3. Lecture notes-1
  4. Lecture notes-2
  5. Quantum Mechanics and Quantum Computationat edX- UC, Berkeley

My other posts on Quantum Computing

  1. Venturing into IBM’s Quantum Experience 2.Going deeper into IBM’s Quantum Experience!
  2. A primer on Qubits, Quantum gates and Quantum Operations
  3. Exploring Quantum Gate operations with QCSimulator
  4. Taking a closer look at Quantum gates and their operations

You may also like
For more posts on other topics like Cloud Computing, IBM Bluemix, Distributed Computing, OpenCV, R, cricket please check my Index of posts

Exploring Quantum Gate operations with QCSimulator


Introduction: Ever since I was initiated into Quantum Computing, through IBM’s Quantum Experience I have been hooked. My initial encounter with domain made me very excited and all wound up. The reason behind this, I think, is because there is an air of mystery around ‘Quantum’ anything.  After my early rush with the Quantum Experience, I have deliberately slowed down to digest the heady stuff.

This post also includes my early prototype of a Quantum Computing Simulator( QCSimulator) which I am creating in R. I hope to have a decent Quantum Computing simulator available, in the next couple of months. The ideas for this simulator are based on IBM’s Quantum Experience and the lectures on Quantum Mechanics and Quantum Computation by Prof Umesh Vazirani from University of California at Berkeley at edX. This calls to this simulator have been included in R Markdown file and has been published at RPubs as Quantum Computing Simulator

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

In this post I explore quantum gate operations

A) Quantum Gates
Quantum gates are represented as a n x n unitary matrix. In mathematics, a complex square matrix U is unitary if its conjugate transpose Uǂ is also its inverse – that is, if
U ǂU =U U ǂ=I

a) Clifford Gates
The following gates are known as Clifford Gates and are represented as the unitary matrix below

1. Pauli X
\begin{pmatrix}0&1\\1&0\end{pmatrix}

2.Pauli Y
\begin{pmatrix}0&-i\\i&0\end{pmatrix}

3. Pauli Z
\begin{pmatrix}1&0\\0&-1\end{pmatrix}

4. Hadamard
1/√2 \begin{pmatrix}1 & 1\\ 1 & -1\end{pmatrix}

5. S Gate
\begin{pmatrix}1 & 0\\ 0 & i\end{pmatrix}

6. S1 Gate
\begin{pmatrix}1 & 0\\ 0 & -i\end{pmatrix}

7. CNOT
\begin{pmatrix}1 & 0 & 0 &0 \\ 0 & 1 & 0 &0 \\  0& 0 &  0&1 \\ 0 & 0 & 1 & 0\end{pmatrix}

b) Non-Clifford Gate
The following are the non-Clifford gates
1. Toffoli Gate
T = \begin{pmatrix}1 & 0\\ 0 & e^{^{i\prod /4}}\end{pmatrix}

2. Toffoli1 Gate
T1 = \begin{pmatrix}1 & 0\\ 0 & e^{^{-i\prod /4}}\end{pmatrix}

B) Evolution of a 1 qubit Quantum System
The diagram below shows how a 1 qubit system evolves on the application of Quantum Gates.

Untitled

C) Evolution of a 2 Qubit  System
The following diagram depicts the evolution of a 2 qubit system. The 4 different maximally entangled states can be obtained by using a Hadamard and a CNOT gate to |00>, |01>, |10> & |11> resulting in the entangled states  Φ+, Ψ+, Φ, Ψrespectively

Untitled

D) Verifying Unitary’ness
XXǂ = XǂX= I
TTǂ = TǂT=I
SSǂ = SǂS=I
The Uǂ  function in the simulator is
Uǂ = GateDagger(U)

E) A look at some Simulator functions
The unitary functions for the Clifford and non-Clifford gates have been implemented functions. The unitary functions can be chained together by invoking each successive Gate as argument to the function.

1. Creating the dagger function
HDagger = GateDagger(Hadamard)
HDagger x Hadamard
TDagger = GateDagger(TGate)
TDagger x TGate

H
##           [,1]       [,2]
## [1,] 0.7071068  0.7071068
## [2,] 0.7071068 -0.7071068
HDagger = GateDagger(H)
HDagger
##           [,1]       [,2]
## [1,] 0.7071068  0.7071068
## [2,] 0.7071068 -0.7071068
HDagger %*% H
##      [,1] [,2]
## [1,]    1    0
## [2,]    0    1
T
##      [,1]                 [,2]
## [1,] 1+0i 0.0000000+0.0000000i
## [2,] 0+0i 0.7071068+0.7071068i
TDagger = GateDagger(T)
TDagger
##      [,1]                 [,2]
## [1,] 1+0i 0.0000000+0.0000000i
## [2,] 0+0i 0.7071068-0.7071068i
TDagger %*% T
##      [,1] [,2]
## [1,] 1+0i 0+0i
## [2,] 0+0i 1+0i

2. Angle between 2 vectors – Inner product
The angle between 2 vectors can be obtained by taking the inner product between the vectors

#1. a is the diagonal vector 1/2 |0> + 1/2 |1> and b = q0 = |0>
diagonal <-  matrix(c(1/sqrt(2),1/sqrt(2)),nrow=2,ncol=1)
q0=matrix(c(1,0),nrow=2,ncol=1)
innerProduct(diagonal,q0)
##      [,1]
## [1,]   45
#2. a = 1/2|0> + sqrt(3)/2|1> and  b= 1/sqrt(2) |0> + 1/sqrt(2) |1>
a = matrix(c(1/2,sqrt(3)/2),nrow=2,ncol=1)
b = matrix(c(1/sqrt(2),1/sqrt(2)),nrow=2,ncol=1)
innerProduct(a,b)
##      [,1]
## [1,]   15

3. Chaining Quantum Gates
For e.g.
H x q0
S x H x q0 == > SGate(Hadamard(q0))

Or
H x S x S x H x q0 == > Hadamard(SGate(SGate(Hadamard))))

# H x q0
Hadamard(q0)
##           [,1]
## [1,] 0.7071068
## [2,] 0.7071068
# S x H x q0
SGate(Hadamard(q0))
##                      [,1]
## [1,] 0.7071068+0.0000000i
## [2,] 0.0000000+0.7071068i
# H x S x S x H x q0
Hadamard(SGate(SGate(Hadamard(q0))))
##      [,1]
## [1,] 0+0i
## [2,] 1+0i
# S x T x H x T x H x q0
SGate(TGate(Hadamard(TGate(Hadamard(q0)))))
##                      [,1]
## [1,] 0.8535534+0.3535534i
## [2,] 0.1464466+0.3535534i

4. Measurement
The output of Quantum Gate operations can be measured with
measurement(a)
measurement(q0)
measurement(Hadamard(q0))
a=SGate(TGate(Hadamard(TGate(Hadamard(I)))))
measurement(a)
measurement(SGate(TGate(Hadamard(TGate(Hadamard(I))))))

measurement(q0)
##   0 1
## v 1 0
measurement(Hadamard(q0))
##     0   1
## v 0.5 0.5
a <- SGate(TGate(Hadamard(TGate(Hadamard(q0)))))
measurement(a)
##           0         1
## v 0.8535534 0.1464466

5. Plot the measurements

plotMeasurement(q1)

unnamed-chunk-5-1

plotMeasurement(Hadamard(q0))

unnamed-chunk-5-2

a = measurement(SGate(TGate(Hadamard(TGate(Hadamard(q0))))))
plotMeasurement(a)

unnamed-chunk-5-3

6. Using the QCSimulator for one of the Bell tests
Here I compute the following measurement of  Bell state ZW  with the QCSimulator
Untitled

When this is simulated on IBM’s Quantum Experience the result is
Untitled

Below I simulate the same on my R based QCSimulator

# Compute the effect of the Composite H gate with the Identity matrix (I)
a=kronecker(H,I,"*")
a
##           [,1]      [,2]       [,3]       [,4]
## [1,] 0.7071068 0.0000000  0.7071068  0.0000000
## [2,] 0.0000000 0.7071068  0.0000000  0.7071068
## [3,] 0.7071068 0.0000000 -0.7071068  0.0000000
## [4,] 0.0000000 0.7071068  0.0000000 -0.7071068
# Compute the applcation of CNOT on this result
b = CNOT(a)
b
##           [,1]      [,2]       [,3]       [,4]
## [1,] 0.7071068 0.0000000  0.7071068  0.0000000
## [2,] 0.0000000 0.7071068  0.0000000  0.7071068
## [3,] 0.0000000 0.7071068  0.0000000 -0.7071068
## [4,] 0.7071068 0.0000000 -0.7071068  0.0000000
# Obtain the result of CNOT on q00
c = b %*% q00
c
##           [,1]
## [1,] 0.7071068
## [2,] 0.0000000
## [3,] 0.0000000
## [4,] 0.7071068
# Compute the effect of the composite HxTxHxS gates and the Identity matrix(I) for measurement
d=Hadamard(TGate(Hadamard(SGate(I))))
e=kronecker(I, d,"*")

# Applying  the composite gate on the output 'c'
f = e %*% c
# Measure the output
g <- measurement(f)
g
##          00        01        10        11
## v 0.4267767 0.0732233 0.0732233 0.4267767
#Plot the measurement
plotMeasurement(g)

aaunnamed-chunk-6-1
which is exactly the result obtained with IBM’s Quantum Experience!

Conclusion : In  this post I dwell on 1 and 2-qubit quantum gates and explore their operation. I have started to construct a  R based Quantum Computing Simulator. I hope to have a reasonable simulator in the next couple of months. Let’s see.

Watch this space!

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

References
1.  IBM Quantum Experience – User Guide
2. Quantum Mechanics and Quantum Conputing, UC Berkeley

Also see
1.  Venturing into IBM’s Quantum Experience
2. Going deeper into IBM’s Quantum Experience!
3.  A primer on Qubits, Quantum gates and Quantum Operations

You may also like
1.  My TEDx talk on the “Internet of Things”
2. Experiments with deblurring using OpenCV
3. TWS-5: Google’s Page Rank: Predicting the movements of a random web walker

For more posts see
Index of posts

A primer on Qubits, Quantum gates and Quantum Operations


Introduction: After my initial encounter with IBM’s Quantum Experience, and my playing around with qubits, quantum gates and trying out the Bell experiment I can now say that I am fairly hooked to quantum computing.

So, I decided that  before going any  further,  that I  needed to  spend a little time more, getting to know more about the basics of Dirac’s bra-ket notation, qubits and ensuring that my knowledge is properly “chunked” ( See Learning to Learn: Powerful mental tools to master tough subjects, a really good course!!)

So, I started to look around for material on Quantum Computing, and finally landed on the classic course “Quantum Mechanics and Quantum Computing”, from University of California, Berkeley by Prof Umesh V Vazirani at edX. I have started to audit the course (listen in, without doing the assignments). The Prof is unbelievably good, and makes the topic both interesting and absorbing. This post is based on my notes of week 1 & 2 lectures. I have tried to articulate as best as I can, what I have understood of the lectures, though I would strongly recommend  you to, at least audit the archived course. By the way, I also had to refresh my knowledge of basic trigonometry and linear algebra. My knowledge of the basics of matrix manipulation, vectors etc. were buried deep within the sands of time. Luckily for me, they were reasonably intact.

A) Quantum states
A hydrogen atom has 1 electron in orbit. The electron can be either in the idle state or in the excited state. We can represent the idle state with |0> and the excited state with |1>, which is Dirac’s ‘ket’ notation.

Untitled

This electron will be in a superposition state which is represented by
Ψ = α |0> + β |1> where α & β are complex numbers and obey | α|2 + | β|2 = 1
For e.g. we could have the superposition state
\varphi= \frac{1}{2} + \frac{1i}{2}|0> + \frac{1}{\sqrt{2}}|1>
It can be seen that | α|2 = \frac{1}{2} and | β|2 = = \frac{1}{2}
For a complex number α = a+ bi  == > | α| = \sqrt{a^{2} + b^{2}}

B) Measurement
However, when the electron or the qubit is measured,  the state of superposition collapses to either |0> or |1> with the following probability’s

The resulting state is
|0> with probability | α|2
|1> with probability | β |2

And | α|2 + | β|2 = 1 because the sum of the probabilities must add up to 1  i.e. \sum p_{i} = 1

C) Geometric interpretation
Let us consider a qubit that is in a superposition state
Ψ = α |0> + β |1> where α & β are complex numbers and obey | α|2 + | β|2 = 1

We can write this as a vector  \begin{pmatrix} \alpha\\ \beta \end{pmatrix} representing the state of the electron

It can be seen that if
\alpha=1 and \beta=0 then |0> = \begin{pmatrix}1\\ 0\end{pmatrix}
and
\alpha=0 and \beta=1  then |1> = \begin{pmatrix}0\\ 1\end{pmatrix}
Untitled

Measuring a qubit in standard basis
If we represent the qubit geometrically then the superposition can be represented as a vector which makes an angle theta with |0>
\varphi = cos\theta|0> + sin\theta|1>

Measuring this  \varphi is the projection of on one of the standard basis |0> or |1>
The output is is |0> with probability cos^{2}\theta and
|1> with probability sin^{2}\theta

D) Measuring a qubit in any basis
Untitled
The qubit can be measured in any arbitrary basis. For e.g.  if
Ψ = α |0> + β |1>   and we have the diagonal basis
|u>| and |u’> as shown and Ψ makes an angle \theta with |u> then we can write

|u> with probability cos2Θ
And |u’> with probability sin2Θ

E) K Qubit system
Let us assume that we have a Quantum System with k qubits
|0>, |1>, |2>… |k-1>

The qubit will be in a superimposed state
Ψ = α0 |0>+ α1 |1> + α2|2> + … + αk-1 |k-1>
Where αj is a complex vector with the property ∑ αj = 1

Here Ψ is a unit vector in a K dimensional complex vector space, known as Hilbert Space
For e.g. a 3 qubit quantum system
\varphi = \frac{1}{2}+\frac{i}{2}|0> - \frac{1}{2} |1> + \frac{1}{2}|2>
Then P(0) = ½ P(1) = ¼ and P(2) = ¼   ∑Pj = 1

We could also write
\varphi = \begin{pmatrix} \alpha_{0}\\ \alpha_{1}\\ .. \\\alpha_{k-1}\\\end{pmatrix}
Or
Ψ = α0 |0>+ α1 |1> + α2|2> + … + αk-1 |k-1>

F) Measuring the angle between 2 complex vectors
To measure the angle between 2 complex vectors
\varphi = \begin{pmatrix} \alpha_{0}\\ \alpha_{1}\\\alpha_{2}\\\end{pmatrix}
And
\phi = \begin{pmatrix} \beta_{0}\\ \beta_{1}\\\beta_{2}\\\end{pmatrix}
we need to take the inner product of the complex conjugate of the 1st vector and the 2nd
cosΘ = inner product  => \bar{\varphi} . \phi
cos\theta = \bar\alpha_{0}\beta_{0} + \bar\alpha_{1}\beta_{1} + \bar\alpha_{2}\beta_{2}

For e.g.
If \varphi = \frac{1}{2} |0> + \frac{\sqrt 3}{2}|1> which makes 60 degrees with the |0> basis
And
\phi = \frac{1}{\sqrt 2} |0> + \frac{1}{\sqrt 2}|1> which is the diagonal |+> basis
Then the angle between these 2 vectors are obtained by taking the inner product
cosΘ =  ½ * 1/√2 + √3/2 * ½

G) Measuring Ψ in |+> or |-> basis
For e.g. if
\varphi = \frac{1}{2} |0> + \frac{\sqrt 3}{2}|1>   – (A)

Then we can specify/measure Ψ in |+> or |-> basis as follow
|+> = 1/√2(|0> + |1>) and |-> = 1/√2(|0> – |1>)
Or |0> = 1/√2(|+> + |->)   and |1> = 1/√2(|+> – |->)

We can write
Ψ= α|+> + β|->

Substituting for |0> and |1>  in (A) we get
\varphi = \frac{1+ \sqrt 3}{2 \sqrt 2} |+> \frac{1 - \sqrt 3 }{2 \sqrt 2} |->

H) Quantum gates
I) Clifford gates
Pauli gates
a) Pauli X
The Pauli X gate does a bit flip
|0> ==>  X|0> ==> |1>
|1> ==>  X|1> ==> |0>
and is represented
\begin{pmatrix}0&1\\1&0\end{pmatrix}

b) Pauli Z
This gates does a phase flip and is represented as the 2 x 2 unitary matrix
\begin{pmatrix}1&0\\0&-1\end{pmatrix}

c) Pauli Y
The Pauli operator Y  does both  a bit and a phase flip. The Y operator is represented as
\begin{pmatrix}0&-i\\i&0\end{pmatrix}

K) Superposition gates
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 \begin{pmatrix}1 & 1\\ 1 & -1\end{pmatrix}

b) S gate
The S gate can be represented as
\begin{pmatrix}1 & 0\\ 0 & i\end{pmatrix}

c) S’ gate
And the S’ gate is
\begin{pmatrix}1 & 0\\ 0 & -i\end{pmatrix}

L) Non-Clifford Gates
The quantum gates discussed in my earlier post Pauli X, Y, Z, H, S and S1 are members of a special group of gates known as the ‘Clifford group’.
The non-Clifford gates, discussed are the T and  Tǂ gates

These are given by
T = \begin{pmatrix}1 & 0\\ 0 & e^{^{i\prod /4}}\end{pmatrix}
Tǂ =\begin{pmatrix}1 & 0\\ 0 & e^{^{-i\prod /4}}\end{pmatrix}

M) 2 qubit system
A 2 qubit system
Untitled

A 2 qubit system is a superposition of all possible 2 qubit states. A 2 qubit system and can be represented as

Ψ = α00 |00> + α01 |01> + α10 |10> + α11 |11>

Measuring the 2 qubit system, as earlier, results in the collapse of the superposition and the result is one of 4 qubit states. The probability of the measure state is the square of the amplitude | αij|2

N) Entanglement
A  2 qubit system in which we have
Ψ = α0 |0> + α1 |1> and Φ= β0 |0> + β1 |1> the superimposed state is obtained by taking the tensor product of the 2 qubits
\chi = (\alpha_{0} |0> + \alpha_{1}|1>)\otimes  (\beta_{0} |0> + \beta_{1} |1>)
Where  \otimes is the tensor product

The state
Ψ = 1/√2|00> + 1/√2|11>
Is called an ‘entangled’ state because it cannot  be reduced to a product of 2 vectors

N) 2 qubit gates

Untitled

A 2 qubit system is a superposition of all possible 2 qubit states. A 2 qubit system and can be represented as
Ψ = α00 |00> + α01 |01> + α10 |10> + α11 |11>

Measuring the 2 qubit system, as earlier, results in the collapse of the superposition and the result is one of 4 qubit states. The probability of the measure state is the square of the amplitude | αij|2
More specifically a 2 qubit system in which we have
Ψ = α0 |0> + α1 |1> and Φ= β0 |0> + β1 |1> the superimposed state is obtained by taking the tensor product of the 2 qubits
\chi = (\alpha_{0} |0> + \alpha_{1}|1>)\otimes  (\beta_{0} |0> + \beta_{1} |1>)

Where \otimes is the tensor product
The state
Ψ = 1/√2|00> + 1/√2|11>
Is called an ‘entangled’ state because it cannot  be reduced to a product of 2 vectors
A quantum gate is a 2 x 2 unitary matrix U such that
α0 |0> + α1 |1>    == > Quantum Gate == > β0|0> + β1 |1>

Unitary functions: In mathematics, a complex square matrix U is unitary if its conjugate transpose U* is also its inverse
If
U=\begin{pmatrix}a & c \\b & d\end{pmatrix}
And U* = \begin{pmatrix}\bar a & \bar b \\ \bar c & \bar d\end{pmatrix}
Then
UU* = I where I is the Identity matrix

2 qubit gates is  4 x 4 unitary matrix
For a 2 qubit that is in the superposition state
Ψ = α00 |00> + α01 |01> + α10 |10> + α11 |11>

A 2 qubit gate’s operation on Ψ is
\begin{pmatrix}a & e & i & m \\ b & f & j & n\\ c & g & k & o\\ d & h & l & p\end{pmatrix} * \begin{pmatrix}\alpha_{00}\\ \alpha_{01}\\ \alpha_{10}\\\alpha_{11}\end{pmatrix}

One important 2 qubit gate is the CNOT gate which is shown  below

Untitled

 

The CNOT gate is represented by the following unitary matrix
\begin{pmatrix}1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0 \\0 & 0  & 0  & 1\\ 0 & 0 & 1 & 0\end{pmatrix}

If 2  2×2 qubit gates were applied to 2 qubits the composite gate would be Tensor product of the 2 matrices

u1 = \begin{pmatrix}a & c\\ b & d\end{pmatrix}
u2 = \begin{pmatrix}e & g\\ f & h\end{pmatrix}
then
U= u1 \otimes u2
U = \begin{pmatrix}a\begin{pmatrix}e & g\\ f & h\end{pmatrix} & c\begin{pmatrix}a & c\\ b & d\end{pmatrix}\\ b \begin{pmatrix}a & c \\ b & d\end{pmatrix}& d\begin{pmatrix}a & c\\ b & d\end{pmatrix}\end{pmatrix}
The above product is also known as the Kronecker product

O) Tensor product of 2 qubits
Ψ = α0 |0> + α1 |1> and Φ= β0 |0> + β1 |1>
$latex \varphi \otimes \phi= α0 β0|0>|0> + α0 β1|0>|1> + α1 β0|1>|0> + α1 β1|1>|1>
= α0 β0|00> + α0 β1|01> + α1 β0|10> + α1 β1|11>
Untitled

If a Z gate and a Hadamard gate H were applied on 2 qubits, it is interest to know what the resulting composite gate would be.

Z = \begin{pmatrix}1 & 0\\ 0 & -1\end{pmatrix} and H = \begin{pmatrix}\frac{1}{\sqrt 2} & \frac{1}{\sqrt 2} \\ \frac{1}{\sqrt 2} & \frac{-1}{\sqrt 2}\end{pmatrix}
The composite gate is obtained by the tensor product of
Z \otimes H
Hence the result of the composite gate is
=\begin{pmatrix}1\begin{pmatrix}\frac{1}{\sqrt 2}   & \frac{1}{\sqrt 2}\\  \frac{1}{\sqrt 2}& \frac{-1}{\sqrt 2}\end{pmatrix} & 0\\ 0 & -1\begin{pmatrix}\frac{1}{\sqrt 2} & \frac{1}{\sqrt 2}\\ \frac{1}{\sqrt 2} &\frac{-1}{\sqrt 2} \end{pmatrix}\end{pmatrix}
=\begin{pmatrix}\begin{pmatrix}\frac{1}{\sqrt 2}   & \frac{1}{\sqrt 2}\\  \frac{1}{\sqrt 2}& \frac{-1}{\sqrt 2}\end{pmatrix} & 0\\ 0 & -\begin{pmatrix}\frac{-1}{\sqrt 2} & \frac{-1}{\sqrt 2}\\ \frac{-1}{\sqrt 2} &\frac{1}{\sqrt 2} \end{pmatrix}\end{pmatrix}

which is the entangled state.

Conclusion: This post includes most of the required basics to get started on Quantum Computing. I will probably add another post detailing the operations of the Quantum Gates on qubits.

Note:
1.The equations and matrices have been created using LaTeX notation using the online LaTex equation creator
2. The figures have been created using the app Bamboo Paper, which I think is cooler than creating in Powerpoint

Also see
1.Venturing into IBM’s Quantum Experience
2. Going deeper into IBM’s Quantum Experience!

You may also like
1.  Sixer – R package cricketr’s new Shiny avatar
2. Natural language processing: What would Shakespeare say?
3. Sea shells on the seashore
4. How to program – Some essential tips
5. Rock N’ Roll with Bluemix, Cloudant & NodeExpress
6. The Many Faces of Latency

Venturing into IBM’s Quantum Experience


UntitledIntroduction: 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 mm2

 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>=\begin{pmatrix}1\\ 0\end{pmatrix}

|1>=\begin{pmatrix}0\\ 1\end{pmatrix}

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 2^{N} 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

1

Simulation in the Quantum Composer

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

2

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

\begin{pmatrix}0&1\\1&0\end{pmatrix}

This can be composed in the Quantum composer as

3

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

4

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

\begin{pmatrix}1&0\\0&-1\end{pmatrix}

Simulation in the Quantum composer
8

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

\begin{pmatrix}0&-i\\i&0\end{pmatrix}

Simulating in the composer gives the following

11

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 \begin{pmatrix}1 & 1\\ 1 & -1\end{pmatrix}

# 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
\begin{pmatrix}1 & 0\\ 0 & i\end{pmatrix}

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
\begin{pmatrix}1 & 0\\ 0 & -i\end{pmatrix}

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
14

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> ==>  |->

Simulating in the Composer
15

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

19

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

22

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

Simulating in Composer
29

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
30

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

25

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

28

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)