Superposition Simplified: Qiskit Experiments in Python#

Installation#

First, ensure you have an updated version of Python (preferably Python 3.8 or above). Then, open your terminal or command prompt and install Qiskit:

1
pip install qiskit

This installs the core Qiskit framework. Optionally, you can install additional packages (like the Qiskit optimization module) using:

1
pip install qiskit[all]

Creating an IBM Quantum Account#

If you want to run your experiments on a real quantum processor, sign up for a free IBM Quantum account:

1. Go to the IBM Quantum website.
2. Sign up or log in.
3. Locate your API token on your profile page.
4. Run IBMQ.save_account('YOUR_API_TOKEN') in a Python shell or Jupyter notebook.

You can then load your account using:

1
from qiskit import IBMQ
2

3
IBMQ.load_account()

This ensures you can access IBM Quantum devices in your scripts or notebooks.

The Qubit#

A qubit is analogous to a classical bit but adheres to quantum mechanical rules. Generally, a qubit can be written in Dirac notation (commonly used in quantum computing) as:

[ \vert \psi \rangle = \alpha \vert 0 \rangle + \beta \vert 1 \rangle ]

where ( \alpha ) and ( \beta ) are complex numbers constrained by:

[ \vert \alpha \vert^2 + \vert \beta \vert^2 = 1. ]

When you measure a qubit:

• You get 0 with probability ( \vert \alpha \vert^2 ).
• You get 1 with probability ( \vert \beta \vert^2 ).

The Concept of Superposition#

Superposition means the qubit’s state can be a combination of both (\vert 0 \rangle) and (\vert 1 \rangle). This property becomes powerful when dealing with multiple qubits, creating the potential for parallel computations. However, once measured, the superposition collapses to a definite state (0 or 1).

Bloch Sphere Representation#

You can visualize a single qubit on the Bloch sphere, where:

• The north pole represents (\vert 0 \rangle).
• The south pole represents (\vert 1 \rangle).
• Any point on the surface of this sphere can represent a potential qubit state.

The angles on the Bloch sphere define ( \alpha ) and ( \beta ). Quantum gates essentially rotate the state vector around various axes on this sphere.

Step 1: Import Required Libraries#

1
from qiskit import QuantumCircuit, Aer, execute

• QuantumCircuit allows you to build circuits.
• Aer is a high-performance simulator for quantum circuits.
• execute runs the circuit on a specified backend.

Step 2: Create a Quantum Circuit#

1
# Create a Quantum Circuit with 1 qubit and 1 classical bit
2
qc = QuantumCircuit(1, 1)
3

4
# Apply the Hadamard gate (H-gate) to the qubit
5
qc.h(0)
6

7
# Measure the qubit
8
qc.measure(0, 0)
9

10
# Draw the circuit
11
print(qc.draw())

Output:

1
     ┌───�? ┌─�?q_0: �?H ├──┤M�?     └───�? └╥�?c_0: ═════════╩�?              0

1. We create a circuit with 1 qubit and 1 classical bit.
2. The Hadamard (H) gate puts (\vert 0 \rangle) into superposition ((\frac{\vert 0 \rangle + \vert 1 \rangle}{\sqrt{2}})).
3. We measure the qubit so we can observe the collapse of superposition.

Step 3: Execute the Circuit on a Simulator#

1
# Choose a simulator
2
backend = Aer.get_backend('qasm_simulator')
3

4
# Execute the circuit
5
job = execute(qc, backend, shots=1024)
6

7
# Get the results
8
result = job.result()
9
counts = result.get_counts()
10

11
print("Counts:", counts)

This will typically print something like:

1
Counts: {'0': 520, '1': 504}

Because of the random nature of quantum measurement, you can expect approximately half of the measurements to be 0 and half to be 1. The exact ratios vary slightly because of statistical fluctuations.

Choosing the Right Gate#

• Hadamard: Vital for creating superposition.
• Pauli Gates (X, Y, Z): The building blocks of qubit state manipulation.
• Controlled Gates (CNOT, Toffoli): Essential for entanglement and multi-qubit operations.

Qiskit offers many more gates (e.g., sdg, t, u3), but these are often derived from the simpler ones shown above.

Performing Measurements in Qiskit#

In Qiskit, measurement is done using qc.measure(qubit_index, classical_bit_index). Behind the scenes, this collapses the specified qubit’s state when run on a backend (simulator or real hardware). For each qubit measured, you need a corresponding classical bit to store the result.

An Example of a More Complex Circuit#

Below is the code for a two-qubit circuit where we set the first qubit to a superposition using the Hadamard gate, then use a CNOT gate (controlled on the first qubit) that targets the second qubit:

1
from qiskit import QuantumCircuit, Aer, execute
2

3
qc2 = QuantumCircuit(2, 2)
4
qc2.h(0)
5
qc2.cx(0, 1)
6
qc2.measure(0, 0)
7
qc2.measure(1, 1)
8

9
backend = Aer.get_backend('qasm_simulator')
10
job2 = execute(qc2, backend, shots=1024)
11
result2 = job2.result()
12
counts2 = result2.get_counts()
13
print("Counts:", counts2)

This circuit often leads to correlated outcomes: if qubit 0 is 0, qubit 1 is 0; if qubit 0 is 1, qubit 1 is 1.

Multi-Qubit Superposition#

Consider two qubits, initially both in (\vert 0 \rangle). Apply a Hadamard gate on each of them. You get:

[ \left(\frac{\vert 0 \rangle + \vert 1 \rangle}{\sqrt{2}}\right) \otimes \left(\frac{\vert 0 \rangle + \vert 1 \rangle}{\sqrt{2}}\right) = \frac{\vert 00 \rangle + \vert 01 \rangle + \vert 10 \rangle + \vert 11 \rangle}{2} ]

In Qiskit:

1
qc_multi = QuantumCircuit(2, 2)
2
qc_multi.h(0)
3
qc_multi.h(1)
4
qc_multi.measure(0, 0)
5
qc_multi.measure(1, 1)
6

7
backend = Aer.get_backend('qasm_simulator')
8
job_multi = execute(qc_multi, backend, shots=1024)
9
result_multi = job_multi.result()
10
counts_multi = result_multi.get_counts()
11
print("Counts:", counts_multi)

Expect roughly equal counts for 00, 01, 10, and 11.

Creating a Bell State (Entanglement)#

Entanglement involves correlating multiple qubits in such a way that measuring one qubit affects the state of another regardless of distance. A well-known entangled state is the Bell State (\vert \Phi^+ \rangle):

[ \vert \Phi^+ \rangle = \frac{\vert 00 \rangle + \vert 11 \rangle}{\sqrt{2}}. ]

To create (\vert \Phi^+ \rangle):

1. Start with (\vert 00 \rangle).
2. Apply a Hadamard to the first qubit.
3. Apply a CNOT with the first as control and second as target.

1
qc_bell = QuantumCircuit(2, 2)
2
qc_bell.h(0)       # Step 2
3
qc_bell.cx(0, 1)   # Step 3
4
qc_bell.measure(0, 0)
5
qc_bell.measure(1, 1)
6

7
backend = Aer.get_backend('qasm_simulator')
8
job_bell = execute(qc_bell, backend, shots=1024)
9
result_bell = job_bell.result()
10
counts_bell = result_bell.get_counts()
11
print("Counts (Bell State):", counts_bell)

You should see almost all outcomes as 00 or 11.

Parameterized Circuits#

Often, especially in variational quantum algorithms, you want to parameterize your gates. Qiskit allows you to create symbolic parameters:

1
import numpy as np
2
from qiskit.circuit import Parameter
3

4
theta = Parameter('θ')
5
param_qc = QuantumCircuit(1, 1)
6

7
# Use parameter in a rotation gate
8
param_qc.rx(theta, 0)
9
param_qc.measure(0, 0)
10

11
# Bind a specific value to theta
12
bound_qc = param_qc.bind_parameters({theta: np.pi/4})
13

14
backend = Aer.get_backend('qasm_simulator')
15
job_param = execute(bound_qc, backend, shots=1024)
16
result_param = job_param.result()
17

18
counts_param = result_param.get_counts()
19
print("Counts with θ = π/4:", counts_param)

This approach is useful in quantum optimization and machine learning algorithms, where you iterate over different parameter values to minimize a cost function.

Circuit Depth and Optimization#

In quantum computing, circuit depth (the longest chain of gates applied in sequence on any qubit) is important. Qubits decohere over time and are sensitive to errors. Minimizing circuit depth often means less noise.

1
from qiskit.transpiler import PassManager
2
from qiskit.transpiler.passes import Unroller, CXCancellation
3

4
# Example circuit to optimize
5
sample_qc = QuantumCircuit(2)
6
sample_qc.h(0)
7
sample_qc.cx(0, 1)
8
sample_qc.h(0)
9
sample_qc.cx(0, 1)
10

11
pass_manager = PassManager([Unroller(['u3', 'cx']), CXCancellation()])
12
optimized_qc = pass_manager.run(sample_qc)
13

14
print("Before optimization:")
15
print(sample_qc)
16
print("After optimization:")
17
print(optimized_qc)

Transpiling a circuit for real hardware also includes mapping qubits to the physical device’s layout, considering topological constraints.

Noise Models#

IBM Quantum hardware, like all quantum devices, has noise that can affect your results. Qiskit Aer provides noise models to simulate realistic hardware conditions:

1
from qiskit.providers.aer.noise import NoiseModel, errors
2

3
noise_model = NoiseModel()
4
# Add a readout error
5
error_meas = errors.ReadoutError([[0.95, 0.05],[0.05, 0.95]])
6
noise_model.add_readout_error(error_meas, [0])
7

8
noisy_sim = Aer.get_backend('qasm_simulator')
9
job_noisy = execute(qc, noisy_sim, shots=1024, noise_model=noise_model)
10
result_noisy = job_noisy.result()
11
counts_noisy = result_noisy.get_counts()
12
print("Noisy Counts:", counts_noisy)

This can help you test how robust your circuit is under realistic conditions.