Hana Emari / Quantum Computing

What is a qubit?

A two-state quantum system that cannot be fully described until observed

A classical bit holds one of two values: 0 or 1. A qubit is different in a fundamental way — it exists in a superposition of both states simultaneously, represented as a weighted sum of |0⟩ and |1⟩. The weights are complex numbers called amplitudes, and their squared magnitudes must sum to one.

The state cannot be read directly. Measurement collapses the superposition to a definite outcome — 0 or 1 — with probability equal to the squared amplitude. Every measurement is destructive. The original superposition is gone.

In Qiskit, the Statevector class stores this exactly. |0⟩ is [1+0j, 0j]. |1⟩ is [0j, 1+0j]. Initializing to a specific state at the start of a circuit means telling the simulator which point on the sphere to begin from.

# Basis states defined as complex vectors
zero = Statevector(np.array([1.0 + 0j, 0j]))
one  = Statevector(np.array([0j, 1.0 + 0j]))

# 5-qubit circuit: 3 data + 2 ancilla
qc = QuantumCircuit(5, 5)
qc.initialize(states[0], 0)   # data qubit q0
qc.initialize(states[1], 1)   # data qubit q1
qc.initialize(states[2], 2)   # data qubit q2

Why noise matters

Unintended rotations shift the qubit off its intended state

Real quantum hardware is noisy. External magnetic fields, temperature fluctuations, stray photons — each pushes the qubit’s state slightly off course. In the Bloch sphere picture, noise is an unintended rotation: a small Rx or Rz operation that nobody asked for.

The consequence is probabilistic. A qubit initialized to |0⟩ that has been rotated by angle θ will now measure as |1⟩ with probability sin²(θ/2). A 45° rotation gives approximately a 15% error rate. A 90° rotation produces a coin flip.

The solution is not to prevent noise — that is an engineering problem that has not been fully solved. The solution is to detect and correct errors after they occur, without ever directly measuring the corrupted qubit. This is quantum error correction.

Injecting random errors

The corrupt() function models what hardware does accidentally

To test an error correction system, one needs a reliable source of errors. In this experiment, noise is simulated by selecting a random qubit, a random rotation plane (YZ via Rx, or XY via Rz), and a random angle between 0° and 90°.

The corrupt() function builds a single-qubit circuit containing only the rotation gate, converts it to a unitary operator via Qiskit’s Operator class, and evolves the qubit’s statevector through it. The corrupted state is then passed into the full circuit as the initialization for that qubit.

def corrupt(angle_deg, q, plane):
    qc_err = QuantumCircuit(1)
    if plane == 'yz':
        qc_err.rx(angle_deg * np.pi / 180, 0)  # Rx rotation
    else:
        qc_err.rz(angle_deg * np.pi / 180, 0)  # Rz rotation
    return q.evolve(Operator(qc_err))

# Random noise parameters chosen before each run:
which_qubit = rng.integers(0, 3)     # which of q0, q1, q2
which_plane = rng.integers(0, 2)     # YZ or XY plane
angle_deg   = rng.uniform(0.0, 90.0) # continuous angle

→ Part 3 of the notebook runs N = 20–40 randomized rounds, cycling between |0⟩³ and |1⟩³ initial states. Each round samples new noise parameters. This stress-tests the correction logic across the full range of possible error scenarios.

Building a correction system

Syndrome measurement identifies the error without collapsing the data

The 3-qubit bit-flip code uses five qubits: three data qubits (q0, q1, q2) and two ancilla qubits (q3, q4). The ancilla qubits are used only for measurement — they are reset and never carry computational information.

The key operation is the CNOT gate. Applied from a data qubit to an ancilla qubit, it flips the ancilla if and only if the data qubit is |1⟩. By applying two CNOTs from different data qubits to the same ancilla, the ancilla ends up encoding the parity of that pair — without revealing either individual value.

The XGate().control(2) instruction creates a Toffoli gate — a NOT gate controlled by two input qubits simultaneously. Three such gates handle the three possible error locations. The ancilla qubits are reset to |0⟩ after correction before the final data readout.

Experimental results

Run the simulation. Record the outcome.

The following reproduces the core experiment from the notebook. Select a qubit, noise plane, initial state, and corruption angle, then record an observation. Each run samples 1024 shots — matching the notebook’s sim.run(qc, shots=1024) calls.