Rotate a qubit by any angle

The X gate flipped a qubit all the way. The Hadamard spread it exactly in half. In what they do to a fresh qubit, both are stops on one dial: a gate that takes an angle and moves the qubit part of the way.

With it, a circuit stops being a list of yes-or-no operations and becomes something you tune. That is what a rotation gate is for, and it is how a circuit gets odds other than all-or-nothing.

A gate with a dial

ry(theta, 0) rotates qubit 0 by the angle theta, in radians. At 0 it does nothing and the qubit stays at 0. At pi it flips a fresh qubit all the way to 1, the same tally the X gate gave in lesson 1.

At pi / 2, halfway, it gives the same even split the Hadamard gave in lesson 2. In between, it sets the odds anywhere you like.

The rule is short. After ry(theta) on a fresh qubit, the share of shots that read 1 is sin²(θ/2): take the sine of half the angle and square it.

The foundations course derives it from the geometry of the qubit. Here it is the thing to check against real runs, in code, one press per angle.

The circuit, then the code

One qubit, one rotation, one measurement. The angle sits at the top of the file so it can be changed without touching the circuit:

theta = pi / 4

qc = QuantumCircuit(1, 1)
qc.ry(theta, 0)               # rotate qubit 0 by theta
qc.measure(0, 0)

The plumbing gains two lines at the end. One pulls the measured share of 1 out of the dict, which was lesson 1's last assignment. The other computes what the rule says for this angle, so the console shows both side by side.

​# 'backend' already exists when this runs: it is whatever you pick in the Run Experiment dialog.
​from math import pi, sin
​from qiskit import QuantumCircuit
​from qiskit.providers.jobstatus import JobStatus
​import time
​​
​shots = 1000
1theta = pi / 4
​​
​qc = QuantumCircuit(1, 1)
2qc.ry(theta, 0)
​qc.measure(0, 0)
​print(qc)
​​
​job = backend.run(qc, shots=shots)
​while job.status() not in (JobStatus.DONE, JobStatus.ERROR, JobStatus.CANCELLED):
​    time.sleep(5)
​​
​counts = job.result().get_counts()
​print(counts)
3measured = counts.get("1", 0) / shots
4expected = sin(theta / 2) ** 2
​print(f"theta = {theta:.4f}   share of 1: measured {measured:.3f}   rule says {expected:.3f}")
1the dial: change this, press Run, compare. 0 is no rotation, pi is a full flip
2rotate qubit 0 by theta around the Y axis
3the share of shots that read 1, from lesson 1's last task
4the rule this lesson is about

Run the circuit, five times

The listing runs one angle per press. Predict the share of 1 for pi / 4 first, then open the project, press Run on Qollab, choose IonQ Aria 1, and press Run.

Then fork the project, as in lesson 1, and in your fork set theta to 0, pi / 2, 3 * pi / 4 and pi, one press each.

Our five presses on 15 September 2026, on the Aria 1 noise model:

The measured shares track the rule to within a few hundredths, which is lesson 2's scatter at 1,000 shots. At the two ends, where the ideal share is exactly 0 or 1, the noise model adds its small tail: one stray shot at pi, none at 0 this time.

theta = pi / 3

Rotations add

Two rotations in a row rotate by the sum of their angles. ry(pi / 2) twice is ry(pi), a full flip, even though each half on its own would give an even split.

This is the same fact as lesson 1's two X gates, with a dial: gates compose, and the answer depends on the whole sequence.

It is also why the Hadamard and ry(pi / 2) give the same tally but are not the same gate. Two Hadamards in a row gave every shot 0 in lesson 2; two ry(pi / 2) in a row give every shot 1, in the assignment below. Same first step, different second step.

The share after one gate is not the whole state, only the part a measurement can see.

qc.ry(theta, 0)
qc.ry(theta, 0)

A rotation you cannot see

Picture the qubit as an arrow from the centre of a globe: fresh, it points at the north pole, 0, and the south pole is 1. That globe has a name, the Bloch sphere, and you can drag the arrow around one on Qollab.

RY tilts the arrow south, and the measurement reads how far it tilted.

RZ spins the arrow around the pole instead. The north-south position does not change, so the share of 1 does not change either. The spin changes only the arrow's position around the pole, and that position is the qubit's phase.

In lesson 2 a weight carried a sign, plus or minus. A phase is that sign made continuous: any angle rather than two. Two paths with the same phase add up, two with opposite phases cancel, and anything between does part of each. Lesson 5 turns that into a tally.

On a fresh qubit that spin changes nothing at all, not even in principle: there is only one path, and turning it leaves nothing to compare it with.

Lesson 5 puts a Hadamard before the spin, so there are two paths and the spin becomes a difference between them. A Hadamard after it turns that difference into odds you can read.

qc.rz(theta, 0)

A spin around the pole showed nothing on a fresh qubit. The next lesson gives the qubit two paths first, and the same spin becomes something you can read, and then a search.