Quantum Computing with Qiskit: A Hands-On Guide

Introduction

Quantum computing is poised to transform the way we solve problems that are intractable or extremely difficult for classical computers. By harnessing the power of quantum mechanics, quantum computers use quantum bits (qubits) that can exist in superpositions of 0 and 1, enabling exponential increases in the state space for certain computations. Unlike classical bits, which can only be in either a 0 or 1 state, qubits can be in both states simultaneously (superposition), and they can also become entangled with each other—leading to a host of new possibilities for faster algorithms, secure communications, and more.

Why Quantum Matters

1. Speed for Certain Problems: Quantum algorithms like Shor’s algorithm can theoretically break many encryption protocols by factoring large numbers much faster than classical computers. Grover’s algorithm can search unsorted databases with quadratic speedup.
2. Cryptography and Security: Quantum cryptography promises new, secure ways to communicate information, leveraging quantum key distribution and other protocols resistant to classical hacking methods.
3. Optimization & Simulation: Quantum computers have the potential to tackle optimization problems and complex simulations (e.g., molecular dynamics, materials science) much faster than classical supercomputers.

In this blog post, you’ll learn how to install and run Qiskit—a robust, open-source quantum computing framework in Python—and walk through five exercises that demonstrate fundamental principles of quantum computing. This article makes the assumption that you already have some familiarity with Python, including creating a virtual environment (e.g., using venv or Conda). Once you have activated your Python environment, you can install Qiskit via:

pip install qiskit

Throughout these exercises, you’ll gain a deeper understanding of quantum concepts like superposition, measurement, and entanglement. We will also use Python tools such as matplotlib for plotting, helping us visualize the results of our quantum experiments.

Exercise 1: Simulating a Coin Flip

A classic introduction to probability in programming is simulating coin flips. We’ll do this first with standard Python to see a probability distribution, and then compare it to a quantum circuit that essentially performs the same “coin flip.”

Classical Coin Flip in Python

Below is a simple script to flip a fair coin multiple times and then visualize the results in Python:

import random
import matplotlib.pyplot as plt

def classical_coin_flip(num_flips=1000):
    """Simulate flipping a fair coin num_flips times."""
    results = []
    for _ in range(num_flips):
        flip = random.choice(['Heads', 'Tails'])
        results.append(flip)
    return results

def plot_coin_flip_distribution(results):
    """Plot the distribution of heads vs tails."""
    labels = ['Heads', 'Tails']
    counts = [results.count('Heads'), results.count('Tails')]
    
    plt.bar(labels, counts, color=['blue', 'green'])
    plt.title('Classical Coin Flip Distribution')
    plt.ylabel('Count')
    plt.show()

if __name__ == "__main__":
    # Flip coin 1000 times
    flips = classical_coin_flip(num_flips=1000)
    # Plot distribution
    plot_coin_flip_distribution(flips)

1. We generate a random flip outcome by choosing between "Heads" and "Tails."
2. We track the results in a list.
3. Finally, we use matplotlib to plot a bar chart of the counts of heads vs. tails.

You should see roughly 50% heads and 50% tails (though not always exact, due to randomness).

Quantum Coin Flip with Qiskit

Now, let’s do a “quantum coin flip.” In quantum computing, a coin flip-like operation can be simulated by applying a Hadamard (H) gate to a qubit. The Hadamard gate places the qubit in an equal superposition of ∣0⟩ and ∣1⟩. Then, measuring the qubit in the computational (Z) basis will give either ∣0⟩ or ∣1⟩ with equal probability (like heads or tails).

Below is a Qiskit program that simulates multiple “coin flips” by repeatedly initializing a qubit, applying the Hadamard gate, and measuring.

from qiskit import QuantumCircuit, execute, Aer
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram

def quantum_coin_flip(num_flips=1000):
    """
    Perform a quantum "coin flip" by applying a Hadamard gate 
    to a qubit, measuring it, and repeating multiple times.
    """
    # We'll store counts across multiple experiments
    qc = QuantumCircuit(1, 1)  # 1 qubit, 1 classical register
    qc.h(0)                    # Apply Hadamard to qubit 0
    qc.measure(0, 0)           # Measure qubit 0 into classical register 0

    # Use the QasmSimulator to simulate the quantum circuit
    simulator = Aer.get_backend('qasm_simulator')

    # Execute the circuit multiple times
    job = execute(qc, simulator, shots=num_flips)
    result = job.result()
    counts = result.get_counts()
    return counts

def plot_quantum_coin_flip_distribution(counts):
    """
    Plot the distribution of quantum coin flip results 
    using Qiskit's built-in histogram function.
    """
    plot_histogram(counts)
    plt.title("Quantum Coin Flip Distribution")
    plt.show()

if __name__ == "__main__":
    counts = quantum_coin_flip(num_flips=1000)
    print("Quantum coin flip counts:", counts)
    plot_quantum_coin_flip_distribution(counts)

Exercise 2: Exploring Single-Qubit Gates

In this exercise, we will explore how different single-qubit gates (X, Y, Z) affect the state of a qubit and how measurement outcomes change. This is a fundamental building block of quantum computing.

Overview of Pauli Gates

• X Gate: Flips ∣0⟩ to ∣1⟩ and ∣1⟩ to ∣0⟩
• Y Gate: Also flips ∣0⟩ to ∣1⟩ and vice versa but introduces a phase of i
• Z Gate: Leaves ∣0⟩ unchanged but adds a phase of −1 to ∣1⟩

Code Example

from qiskit import QuantumCircuit, execute, Aer
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram

def explore_single_qubit_gates(gate_name='X', shots=1000):
    """
    Apply a specified gate (X, Y, or Z) to a qubit initially in state |0>,
    then measure the result.
    """
    qc = QuantumCircuit(1, 1)

    # Apply the requested gate
    if gate_name.upper() == 'X':
        qc.x(0)
    elif gate_name.upper() == 'Y':
        qc.y(0)
    elif gate_name.upper() == 'Z':
        qc.z(0)
    else:
        raise ValueError("Supported gates are X, Y, or Z only.")

    qc.measure(0, 0)

    simulator = Aer.get_backend('qasm_simulator')
    job = execute(qc, simulator, shots=shots)
    result = job.result()
    counts = result.get_counts(qc)
    return counts

def plot_gate_exploration(counts, gate_name):
    """Plot the measurement outcomes after a single-qubit gate is applied."""
    plot_histogram(counts)
    plt.title(f"Measurement after {gate_name} gate")
    plt.show()

if __name__ == "__main__":
    for gate in ['X', 'Y', 'Z']:
        counts = explore_single_qubit_gates(gate_name=gate, shots=1000)
        print(f"Results for {gate} gate: {counts}")
        plot_gate_exploration(counts, gate)

1. When the qubit starts in ∣0⟩ and you apply X:
• You’ll measure ∣1⟩ almost every time
2. If you apply Y:
• You’ll still see ∣1⟩ most of the time when measured in the Z basis, but the phase is different under the hood
3. With Z:
• ∣0⟩ remains ∣0⟩. You’ll see ∣0⟩ upon measurement

Try experimenting by changing the initial state or chaining multiple gates together.

Exercise 3: Creating and Measuring a Bell State (Entanglement)

A Bell state (one of the simplest forms of entanglement) is a two-qubit state in which the qubits are perfectly correlated. The most famous Bell state is:

\[\frac{1}{\sqrt{2}} \bigl( |00\rangle + |11\rangle \bigr)\]

Let’s create and measure this state using Qiskit.

Steps to Create a Bell State

1. Start with two qubits in ∣0⟩.
2. Apply a Hadamard gate to the first qubit (to create a superposition).
3. Apply a CNOT gate, using the first qubit as the control and the second as the target. This creates entanglement.

Code Example

from qiskit import QuantumCircuit, execute, Aer
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram

def create_bell_state(shots=1024):
    """
    Create and measure a Bell state (|00> + |11>) / sqrt(2).
    """
    # 2 qubits, 2 classical bits
    qc = QuantumCircuit(2, 2)

    # Step 1: Hadamard on qubit 0
    qc.h(0)

    # Step 2: CNOT (control=0, target=1)
    qc.cx(0, 1)

    # Step 3: Measure both qubits
    qc.measure([0, 1], [0, 1])

    simulator = Aer.get_backend('qasm_simulator')
    job = execute(qc, simulator, shots=shots)
    result = job.result()
    counts = result.get_counts(qc)
    return counts, qc

def plot_bell_counts(counts):
    """Plot the measurement outcomes of the Bell state."""
    plot_histogram(counts)
    plt.title("Measurement Outcomes for Bell State")
    plt.show()

if __name__ == "__main__":
    bell_counts, bell_circuit = create_bell_state(shots=1024)
    print("Bell state measurement counts:", bell_counts)
    plot_bell_counts(bell_counts)

1. You will likely see outcomes ∣00⟩ and ∣11⟩ with roughly equal probabilities.
2. This indicates your two qubits are entangled and correlated: measuring one qubit as 0 forces the other to be 0, and measuring one qubit as 1 forces the other to be 1.

Exercise 4: Parameterized Circuits and Rotation Gates

Quantum circuits can include parameterized gates, such as rotation gates:

\[R_x(\theta), \quad R_y(\theta), \quad R_z(\theta)\]

These gates allow continuous control over the qubit’s state. Let’s explore rotation gates and see how they affect measurement outcomes.

Code Example

import numpy as np
from qiskit import QuantumCircuit, execute, Aer
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram

def parameterized_rotation(theta, shots=1024):
    """
    Apply a rotation R_y(theta) to a single qubit initially in state |0>
    and measure in the computational basis.
    """
    qc = QuantumCircuit(1, 1)
    # Apply rotation around the Y axis by angle theta
    qc.ry(theta, 0)
    qc.measure(0, 0)

    simulator = Aer.get_backend('qasm_simulator')
    job = execute(qc, simulator, shots=shots)
    result = job.result()
    counts = result.get_counts(qc)
    return counts

def scan_rotations(num_points=10):
    """
    Scan a range of rotation angles from 0 to pi and measure the probability
    of obtaining |0> or |1>.
    """
    angles = np.linspace(0, np.pi, num_points)
    zero_probs = []
    one_probs = []

    for angle in angles:
        counts = parameterized_rotation(angle, shots=1024)
        # Convert counts to probabilities
        shots_total = sum(counts.values())
        prob_zero = counts.get('0', 0) / shots_total
        prob_one = counts.get('1', 0) / shots_total
        
        zero_probs.append(prob_zero)
        one_probs.append(prob_one)

    # Plot results
    plt.figure()
    plt.plot(angles, zero_probs, label='P(|0>)', marker='o')
    plt.plot(angles, one_probs, label='P(|1>)', marker='o')
    plt.title("Rotation around Y-axis (Ry)")
    plt.xlabel("Theta (radians)")
    plt.ylabel("Probability")
    plt.legend()
    plt.show()

if __name__ == "__main__":
    # Example usage: Scan rotation angles from 0 to pi
    scan_rotations(num_points=10)

• As θ goes from 0 to π, you’ll see that the probability of measuring ∣0⟩ decreases, while the probability of measuring ∣1⟩ increases.
• This shows how continuous parameterized gates can shape the qubit’s state.

Exercise 5: Grover’s Search on a Small Database

Grover’s algorithm is a quantum search algorithm that finds a “marked” item in an unsorted database in roughly sqrt(N) queries, compared to N/2 on average classically. Let’s implement a simplified version of Grover’s search on a 2-qubit system (i.e., searching among 4 items).

Code Example

from qiskit import QuantumCircuit, execute, Aer
from qiskit.circuit.library import ZGate
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

def grover_2_qubit(shots=1024, marked_state='11'):
    """
    Implement a small Grover's search algorithm to find the marked state 
    among 4 possible states: 00, 01, 10, 11.
    marked_state can be '00', '01', '10', or '11'.
    """
    # Step 1: Initialization
    qc = QuantumCircuit(2, 2)
    qc.h([0, 1])  # Put both qubits in superposition

    # Step 2: Oracle that flips the phase of the marked state
    qc.barrier()
    oracle = QuantumCircuit(2, name='Oracle')
    if marked_state == '00':
        # Flip amplitude for |00>
        # We'll use an X-gate trick to implement a phase flip on |00>
        oracle.x([0,1])
        oracle.cz(0,1)
        oracle.x([0,1])
    elif marked_state == '01':
        oracle.x([0])
        oracle.cz(0,1)
        oracle.x([0])
    elif marked_state == '10':
        oracle.x([1])
        oracle.cz(0,1)
        oracle.x([1])
    elif marked_state == '11':
        # Directly apply cz to flip the phase of |11>
        oracle.cz(0,1)

    # Convert the oracle to a gate and append
    qc.append(oracle.to_gate(), [0,1])

    # Step 3: Diffuser (inversion about the mean)
    qc.barrier()
    diffuser = QuantumCircuit(2, name='Diffuser')
    diffuser.h([0,1])
    diffuser.x([0,1])
    diffuser.cz(0,1)
    diffuser.x([0,1])
    diffuser.h([0,1])

    # Convert the diffuser to a gate and append
    qc.append(diffuser.to_gate(), [0,1])

    # Step 4: Measurement
    qc.measure([0,1],[0,1])

    # Execute
    simulator = Aer.get_backend('qasm_simulator')
    job = execute(qc, simulator, shots=shots)
    result = job.result()
    counts = result.get_counts(qc)
    return counts, qc

def plot_grover_results(counts, marked_state):
    """Plot the measurement results for Grover's algorithm."""
    plot_histogram(counts)
    plt.title(f"Grover's Search Results (marked = {marked_state})")
    plt.show()

if __name__ == "__main__":
    # Example usage: Marked state is '11'
    marked = '11'
    counts, grover_circuit = grover_2_qubit(shots=1024, marked_state=marked)
    print("Grover's search counts:", counts)
    plot_grover_results(counts, marked)

• We create superposition over 4 states (∣00⟩,∣01⟩,∣10⟩,∣11).
• The oracle flips the phase of the marked state.
• The diffuser inverts amplitudes about the mean.
• After one iteration of Grover’s algorithm (for a 2-qubit system, one iteration is typically enough), the marked state amplitude should dominate.

Try changing the marked_state parameter to '00', '01', or '10' to see how the algorithm identifies different marked states.

Conclusion

Quantum computing offers a revolutionary computational paradigm that leverages the weird and wonderful properties of quantum mechanics. From simulating random coin flips with superpositions to creating entangled Bell states, the possibilities expand our computational toolkit. We’ve walked through five exercises using Qiskit, showing how straightforward it can be to experiment with quantum circuits in Python.

As quantum hardware continues to evolve, it’s an exciting time to get involved. I encourage you to experiment further:

• Try out more complex circuits.
• Investigate error mitigation and quantum error correction methods.
• Contribute to open-source projects like Qiskit.

The journey into quantum computing is just beginning. By learning the fundamentals now, you’ll be well-positioned to contribute to the breakthroughs on the horizon!