Single-Qubit Practice

You have spent several chapters building the single-qubit toolkit. X, Y, Z flip along the three axes. H swaps the computational basis with the plus-minus basis. S and T add phase. R_x(\theta), R_y(\theta), R_z(\theta) rotate by arbitrary continuous angles. On top of that, the Bloch sphere gives you a geometric picture — every state is a point on a unit ball, every gate is a rotation.

Now you practise. The problems below are designed to be solvable — each one clean, each one reinforcing a specific concept — not tricky for the sake of tricky. Work through them with paper and pen. Draw the Bloch sphere. Multiply out the matrices. Check the result against the geometry. If something doesn't match, that is when you learn — a mismatch between algebra and picture usually means you lost a phase or transposed a sign, and fixing it is where the lesson lives.

Two rules for gate-sequence notation you will see throughout this article. The circuit convention is left-to-right in time — a circuit drawn as |\psi\rangle - H - T - means first apply H, then apply T. The algebraic convention multiplies right-to-left — the state after is T H |\psi\rangle, with the gate that fires first sitting closest to the ket. These two conventions disagree on the visual order, and that disagreement is the source of a real fraction of student bugs. Whenever you translate a circuit to an algebra, write the leftmost gate in the circuit on the right in the product.

The eight problems

The problems are arranged in increasing order of composition depth — Problem 1 uses one gate; the later problems chain two, three, or more. By Problem 8, you are building a composite rotation axis from scratch.

Self-test: five states to reach

Now you try. Starting from |0\rangle, find a short gate sequence to reach each of these states. Solutions are not given; compute on paper, then verify with Qiskit (or by matrix multiplication).

1. |-i\rangle = \tfrac{1}{\sqrt 2}(|0\rangle - i|1\rangle) — the -y equator point.
2. -|0\rangle — the same physical state as |0\rangle, but with a global phase of -1. (Think: what sequence produces a global -1?)
3. \tfrac{1}{\sqrt 2}(|0\rangle + e^{-i\pi/4}|1\rangle) — an equator state 45° clockwise from |+\rangle.
4. \tfrac{1}{2}|0\rangle - \tfrac{\sqrt 3}{2}|1\rangle — a state in the xz-plane at polar angle \theta = 2\pi/3 on the negative-x side.
5. A state whose Bloch vector points in the (+x, +y, +z) octant, specifically at (\theta = \pi/3, \varphi = \pi/3).

Each one is reachable with at most four single-qubit gates from \{H, X, Y, Z, S, S^\dagger, T, T^\dagger, R_y(\text{angle})\}. Some need just one gate; some need three; #2 is a famous trick. Give them an honest attempt, then check.

Common confusions about practice

• "Gates compose right-to-left, so the first gate goes on the right of the ket" — yes, this is the single most common algebraic bug. The circuit |\psi\rangle - A - B - C means apply A first, then B, then C — but in algebra it reads CBA|\psi\rangle. The leftmost gate in the circuit is rightmost in the algebra. Always translate carefully.

• "Measure after every gate to see what's happening" — no. A computational-basis measurement collapses the superposition, destroying the amplitudes you wanted to manipulate. In a quantum circuit, measurement happens at the end almost always. Debugging by inserting an intermediate measurement is like debugging by killing the process — you can see the last thing it did, but you cannot then continue the program. If you want intermediate state, use a simulator's "statevector" method (Qiskit: backend.get_statevector(circuit)) — that reads the full quantum state without collapsing it, because the simulator has internal access to the amplitudes.

• "I forgot a global phase" — this is usually fine. A global phase e^{i\alpha}|\psi\rangle is the same physical state as |\psi\rangle — it is invisible to every single-qubit measurement. The one place it matters is inside a controlled operation: the controlled version of a gate with global phase e^{i\alpha} is not the same as the controlled version without it, because the phase becomes a relative phase between the controlled and uncontrolled arms. Controlled gates will come later in the two-qubit chapters; for now, ignore global phases without guilt.

• "Problem 2 says X sends |0⟩ to |1⟩ but problem 5 says Z fixes |0⟩ — aren't both 180° rotations?" — yes, both are 180° rotations, but about different axes. Every gate has two pieces: the axis and the angle. X is 180° about +x; Z is 180° about +z. Rotating 180° about the axis through a state fixes that state (a point on the rotation axis doesn't move). Rotating 180° about an axis perpendicular to a state takes it to its antipode. |0\rangle sits on the +z axis, so Z fixes it and X swaps it with |1\rangle.

• "Why use R_y in Problem 8 and not R_x?" — R_x(\theta)|0\rangle picks up an imaginary amplitude on |1\rangle (specifically -i \sin(\theta/2)), which puts the state off the xz-plane. R_y(\theta)|0\rangle produces real amplitudes, keeping the state in the xz-plane. For a target explicitly in the xz-plane, R_y is the right axis. Both are valid rotations, but they land in different planes.

• "I computed the algebra but the Bloch picture doesn't match" — the most likely culprit is the half-angle. The Bloch sphere angle \theta appears as \theta/2 inside the amplitudes. A state with Bloch polar angle 60° has amplitude \cos(30°) for |0\rangle, not \cos(60°). If your algebra gives \cos(\pi/3) where you expected \cos(\pi/6), you have probably confused the Bloch angle with the amplitude angle. The 2:1 ratio is one of the real subtleties of single-qubit quantum mechanics.

Going deeper

Verifying problems in Qiskit

Qiskit is IBM's open-source quantum computing SDK and it is installable from PyPI in one line: pip install qiskit qiskit-aer. It runs on any laptop and is accessible free for Indian students (no login required for the simulator; IBM Quantum's free tier provides real-hardware access on request).

A minimal Qiskit script to verify Problem 3 (reach |+i\rangle from |0\rangle):

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)       # First gate: H
qc.s(0)       # Second gate: S
state = Statevector(qc)
print(state)  # Expected: (|0⟩ + i|1⟩)/√2, i.e. amplitudes (1, i)/√2

The Statevector class reads the full amplitude vector from the simulator — no measurement collapse. Compare the numerical output to your hand-computed |+i\rangle. For problems where the state has simple real/imaginary amplitudes, a printed statevector is immediate verification.

For simulated measurements at the end (instead of reading the full state), use qc.measure_all() and run on the Aer backend:

from qiskit_aer import AerSimulator
sim = AerSimulator()
qc.measure_all()
result = sim.run(qc, shots=10000).result()
print(result.get_counts())

This runs the circuit 10000 times and reports how often each outcome appeared. For |+i\rangle measured in the computational basis, expect roughly 50-50 counts (since |+i\rangle is 50-50 in the Z-basis); for |+i\rangle measured in the Y-basis, expect +i always. Changing the measurement basis takes a pre-measurement rotation (see Ch.28 on measurement in arbitrary bases).

Using qsphere for complex multi-amplitude visualisation

The Bloch sphere works perfectly for single qubits, but its geometric meaning disappears for multi-qubit states (since two qubits inhabit a 4-complex-dimensional Hilbert space, not a 3D ball). Qiskit provides an alternative visualisation called the qsphere, which plots each basis state as a point on a sphere — with the distance from the centre encoded as amplitude and the rotation angle encoded as phase.

The qsphere is overkill for single-qubit practice (the Bloch sphere is strictly better for one qubit), but it is worth knowing about because it generalises naturally to two, three, or more qubits. When you see qubit counts of 5-10 in later chapters, the qsphere remains readable where the Bloch sphere cannot.

from qiskit.visualization import plot_state_qsphere
plot_state_qsphere(Statevector(qc))

Extending to two-qubit practice

Single-qubit practice sets the stage. The real fun begins with two-qubit circuits: Bell pair creation, CNOT-based entanglement, teleportation, superdense coding, Deutsch's algorithm. For every single-qubit identity here, there is a two-qubit analogue:

• "Reach |+\rangle from |0\rangle" becomes "Reach the Bell state |\Phi^+\rangle from |00\rangle" (answer: apply H to the first qubit, then CNOT with first as control and second as target).
• "Reach a rotation of 30°" becomes "Reach an arbitrary two-qubit gate" — which is much harder, because two-qubit operations don't decompose as cleanly as single-qubit ones.
• The conjugation trick HXH = Z becomes "conjugate a two-qubit gate by Hadamards" — and the analogous identity is CNOT conjugated by H \otimes H becomes a different two-qubit gate (specifically, CNOT with the control and target swapped).

A full two-qubit practice chapter will appear later in the curriculum. For now, finish the single-qubit list — they are the building blocks on top of which every two-qubit circuit sits.

Running on real Indian quantum hardware

Besides the Qiskit simulator, you can run the problems on real quantum hardware through IBM Quantum Platform — free-tier access includes 10 minutes per month on a real superconducting quantum computer. Indian students can create accounts at quantum.ibm.com with an email; the quantum circuits you built for the single-qubit problems run on a physical chip in Yorktown Heights, USA (or sometimes Ehningen, Germany), and the results are sent back in seconds.

For problems like these, a real quantum computer adds noise — you will not get exactly P(0) = 3/4 in Problem 8; you will get something like P(0) = 0.73 after 1024 shots on a NISQ device. That noise is itself a lesson: real quantum hardware is not a flawless simulator, and understanding how to tame the noise is the subject of quantum error correction later in the curriculum.

For students based in India, TIFR Mumbai, IISc Bangalore, IIT Madras, and IIT Bombay all have active quantum computing research groups. The National Quantum Mission (launched 2023, ₹6000 crore over 8 years) funds hardware development domestically — so by the time you reach university, some of this practice may run on superconducting or trapped-ion machines built in India rather than shipped from IBM or Google.

Using Cirq or Q# instead

Qiskit is the most widely used SDK, but Cirq (Google) and Q# (Microsoft) both support the same gate set with nearly identical syntax. A single-qubit problem translates between them by changing qc.h(0) to cirq.H(q0) or H(q0) (Q#). The physics is identical; the APIs are just syntactic sugar.

Where this leads next

• Universal single-qubit decomposition — if you can reach any single-qubit state, you have implicitly been doing ZYZ decomposition. Formalise the pattern.
• Building any rotation from H and T — compile the continuous rotations used above down to fault-tolerant gate sequences.
• Measurement in arbitrary bases — the verification step for Qiskit problems, formalised.
• Two-qubit practice — the next chapter of practice, adding CNOT and entanglement.

References

1. Qiskit Textbook, Single Qubit Gates — interactive examples covering exactly the eight problems in this article.
2. John Preskill, Lecture Notes on Quantum Computation, Ch. 2 (qubits, gates, single-qubit manipulation) — theory.caltech.edu/~preskill/ph229.
3. Nielsen and Chuang, Quantum Computation and Quantum Information — §4.2 on single-qubit operations, §4.4 on quantum circuits — Cambridge University Press.
4. Wikipedia, Quantum logic gate — matrix forms and rotation-axis conventions for every gate in this article.
5. Qiskit Aer simulator documentation — qiskit.org/ecosystem/aer — how to run and read statevectors for verification of the problem answers.
6. IBM Quantum Learning, Introduction to Quantum Computing — free self-paced course with exercises parallel to the problems in this article. </content> </invoke>