Hands-On Quantum Machine Learning with Python/

...

/

The Measured Qubit

The Measured Qubit

Learn how we can implement and draw the measured qubit.

We'll cover the following...

Let’s have a look at this gate in practice. We use IBM’s quantum computing SDK Qiskit.

The measured qubit implementation

Press + to interact
from qiskit import execute, Aer, QuantumCircuit
from qiskit.visualization import plot_histogram
# Create a quantum circuit with one qubit
qc = QuantumCircuit(1)  
 # Define initial_state
qc.initialize(psi, 0) 
# Apply the X-gate
qc.x(0)
# Tell Qiskit how to simulate our circuit
backend = Aer.get_backend('statevector_simulator') 
# Do the simulation, returning the result
result = execute(qc,backend).result() 
counts = result.get_counts()
plot_histogram(counts)

The fundamental unit of Qiskit is the quantum circuit. A quantum circuit is a model for quantum computation. Our circuit consists of a single qubit in line 5.

We initialize our qubit with the state psi in line 8, and apply the X-gate in line 11.

Qiskit provides the Aer package that we import at line 1. In addition, it offers different backends for simulating quantum circuits. The most common backend is the statevector_simulator in line 14.

The execute function that we imported at line 1 runs our quantum circuit (qc) at the specified backend. In line 17, it returns a job object that has a useful method job.result(). This returns the result object once our program completes it.

Qiskit uses Matplotlib to provide insightful visualizations. A simple histogram will do. The result object provides the get_counts method to obtain the histogram data of an executed circuit in line 18.

The method plot_histogram returns a Matplotlib figure that Jupyter draws automatically in line 19.

We see we have a 75%75\% chance of observing the value 0 and a 25%25\% chance of observing the value 1, the exact opposite of the initial state.

We can run the circuit with different initial states to get a better feeling for this gate.

In general, quantum circuits are not different from classical circuits. We can represent them in a diagram. Qiskit’s QuantumCircuit class provides the draw method that does the job for us.

Draw the measured qubit

Press + to interact
qc.draw('mpl')

We can see our only qubit (q), its initialization with the array [0.5, 0.866], and the applied X-gate.

We’ve completed the first step towards quantum computing mastery without being a mathematician! Getting a conceptual understanding of quantum gates as the quantum peers of classical circuit gates does not depend on math. The combination of plain English and some Python is well-suited. For many, this combination is much more accessible.

Math, however, remains paramount to quantum computing. So, if you want to gain a deep understanding of the concepts, you’ll have to cope with the mathematical formulae sooner or later. And as we said earlier, math is a great way to describe technical concepts.

Let’s look at the underlying math of the X-gate. Don’t worry, we’re not expected to be mathematicians, although a little affinity for algebra, the study of mathematical symbols, and the rules of manipulating them doesn’t hurt.

So far, we’ve used Python’s built-in function reversed. While this is convenient, we don’t see how it works internally. So let’s use another function: a self-made function.

Self‐made reverse function

Press + to interact
def adjust_weight(state, weights):
    return state[0]*weights[0]+state[1]*weights[1]
print ('reversed psi: [{:.2f}, {:.2f}]'.format(
    adjust_weight(psi, [0,1]),
    adjust_weight(psi, [1,0])
))

In line 1, we define a function, adjust_weight. It takes a quantum state and weights. Both are arrays with two items. It multiplies the values at position 0, which multiplies the values at position 1. It returns the sum of these two products in line 2.

We can use this function to reverse psi. The adjust_weight function returns a single number. We call it twice to get back an array of two items in lines 5 and 6. We don’t explicitly create an array in this example, but we directly print these values to the console in line 4.

In both calls, we provide the original psi as the state parameter. For the first call, whose result is the first number of the reversed psi, we provide [0,1] as weights. It means we get the sum of 0 times the first number of psi and 1 time the second number of psi. This sum is the second number of psi.

For the second call, whose result is the second number of the reversed psi, we provide [1,0] as weights. This is 1 times the first number of psi and 0 times the second number of psi. This equals the first number of psi.

With these weights, we have effectively switched the places of the numbers of psi.

In math, this is matrix multiplication. The general formula for multiplying a matrix MM and a vector υ\upsilon is:

M.∣υ⟩=[abcd].[υ0υ1]=[a.υ0+b.υ1c.υ0+d.υ1]M . |\upsilon\rangle=\begin{bmatrix}a &b\\c & d\end{bmatrix} . \begin{bmatrix}\upsilon_0\\ \upsilon_1\end{bmatrix} =\begin{bmatrix}a.\upsilon_0 +b.\upsilon_1\\c.\upsilon_0 + d.\upsilon_1\end{bmatrix} ...