Quantum-Computation-course-Basel/archives/exercises_2022/Exercise6.ipynb

Exercise 6

1

Show that the Hadamard gate can be written in the following two forms

H = \frac{X+Z}{\sqrt{2}} \sim \exp\left(i \frac{\pi}{2} \, \frac{X+Z}{\sqrt{2}}\right).

Here \sim is used to denote that the equality is valid up to a global phase, and hence that the resulting gates are physically equivalent.

Hint: it might even be easiest to prove that e^{i\frac{\pi}{2} M} \sim M for any matrix whose eigenvalues are all \pm 1, and that such matrices uniquely satisfy M^2=I.

2

The Hadamard can be constructed from rx and rz operations as

R_x(\theta) = e^{i\frac{\theta}{2} X}, ~~~ R_z(\theta) = e^{i\frac{\theta}{2} Z},\\ H \equiv \lim_{n\rightarrow\infty} \left( ~R_x\left(\frac{\theta}{n}\right) ~~R_z \left(\frac{\theta}{n}\right) ~\right)^n.

For some suitably chosen \theta. When implemented for finite n, the resulting gate will be an approximation to the Hadamard whose error decreases with n.

The following shows an example of this implemented with Qiskit with an incorrectly chosen value of \theta (and with the global phase ignored).

• Determine the correct value of \theta.

• Show that the error (when using the correct value of \theta) decreases quadratically with n.

In [2]:

from qiskit import *
from qiskit.tools.visualization import plot_histogram
import numpy as np

In [3]:

q = QuantumRegister(1)
c = ClassicalRegister(1)

error = {}
for n in range(1,11):

    # Create a blank circuit
    qc = QuantumCircuit(q,c)
    
    # Implement an approximate Hadamard
    theta = np.pi # here we incorrectly choose theta=pi
    for j in range(n):
        qc.rx(theta/n,q[0])
        qc.rz(theta/n,q[0])
      
    # We need to measure how good the above approximation is. Here's a simple way to do this.
    # Step 1: Use a real hadamard to cancel the above approximation.
    # For a good approximatuon, the qubit will return to state 0. For a bad one, it will end up as some superposition.
    qc.h(q[0])
    
    # Step 2: Run the circuit, and see how many times we get the outcome 1.
    # Since it should return 0 with certainty, the fraction of 1s is a measure of the error.
    qc.measure(q,c)
    shots = 20000
    job = execute(qc, Aer.get_backend('qasm_simulator'),shots=shots)
    try:
        error[n] = (job.result().get_counts()['1']/shots)
    except:
        pass
        
plot_histogram(error)

Out [3]:

3

An improved version of the approximation can be found from,

H \equiv \lim_{n\rightarrow\infty} \left( ~ R_z \left(\frac{\theta}{2n}\right)~~ R_x\left(\frac{\theta}{n}\right) ~~ R_z \left(\frac{\theta}{2n}\right) ~\right)^n.

Implement this, and investigate the scaling of the error.

4

Write a circuit to implement the following unitary with perfect precision, using only rx, rz and Clifford gates

U = \exp\left[i \frac{\theta}{2} \, \left( X\otimes X + Z\otimes Z \right) \right].

Apply this to the initial state |10\rangle and determine the final state for the following values of \theta.

• (a) \theta=\pi/4
• (b) \theta=\pi/2
• (c) \theta=\pi

You can use the following as a starting point.

In [4]:

theta = np.pi/2

q = QuantumRegister(2)

# Create a blank circuit
qc = QuantumCircuit(q)

# prepare the |10> state
qc.x(1)

# do things!

# get the final statevector
job = Aer.get_backend('statevector_simulator').run(qc)
statevector = job.result().get_statevector()
print(statevector)

Statevector([0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
            dims=(2, 2))

5. Effects of garbage in quantum circuits

The CX gate performs the mapping (i,j) \rightarrow (i,i+j \mod 2) from an input on two bits to an output on two bits.

It is interesting to note (though not relevant to the problem) that this mapping is not of the form (z,0) \rightarrow (z,f(z)), as considered last week, since the function f(i,j) = i+j \mod 2 does not require the whole input to be present for reversibility.

Here are two circuits with a CX gate.

• (a) The first circuit is composed of both a quantum part and an irreversible classical part. Determine the final output bit .

• (b) Show that the second circuit effectively acts as a CX between the first and third qubits, but with the additional effect of producting a garbage qubit on the second.

• (c) Replace the true CX in the first circuit with the garbage producing one from the second. Show that this changes the output bit.

• (d) Show how the garbage producing CX can be corrected by uncomputation.

In [ ]: