Measurement in Arbitrary Bases

In short

To measure a qubit in a basis \{|v_0\rangle, |v_1\rangle\}, build the unitary U = |0\rangle\langle v_0| + |1\rangle\langle v_1| that maps the basis you want onto the computational basis. Apply U to the state, then do an ordinary Z-basis measurement. Outcome i means "your state was in the |v_i\rangle component"; the post-measurement state is |i\rangle. X-basis measurement is H followed by Z-measurement. Y-basis measurement is S^\dagger H followed by Z-measurement. Every exotic-basis measurement on real hardware is one rotation away from the default.

The projective-measurement chapter handed you the machinery for the computational basis. Born rule, collapse, renormalisation — all of it in the \{|0\rangle, |1\rangle\} basis, because that is the basis real hardware actually reads out. A superconducting qubit's ground state is |0\rangle; its excited state is |1\rangle; the microwave readout resonator distinguishes those two and nothing else.

But the states |+\rangle and |-\rangle are perfectly orthogonal too. They form a valid basis. So why not measure in that basis? You can. You just have to be clever about how — because the hardware stubbornly insists on reading out |0\rangle vs |1\rangle. The trick is old, beautiful, and it underlies nearly every interesting quantum protocol: rotate the basis you want onto the computational basis, then measure.

This chapter walks through that recipe in full. You will build the rotation unitary for any orthonormal basis, see it collapse to the Hadamard in the X case and to S^\dagger H in the Y case, and end with a clear operational picture: "measure in basis B" is never more than a single gate away from "measure in Z."

The recipe — rotate, then measure

Suppose you want to measure a qubit in some orthonormal basis

B = \{|v_0\rangle, |v_1\rangle\}

where \langle v_0 | v_1 \rangle = 0 and \langle v_i | v_i \rangle = 1. The outcomes should be labelled 0 and 1, with outcome i meaning "the state was in the |v_i\rangle component." Hardware reads in the computational basis; you need to do the rest in software.

The strategy is one line:

Build a unitary U that carries each |v_i\rangle to |i\rangle. Apply U to the state. Measure in the computational basis.

Now a computational-basis measurement gives outcome 0 with probability |c_0|^2 and outcome 1 with probability |c_1|^2 — exactly the same probabilities as the basis-B measurement you wanted. The hardware has done your bidding by default, because you pre-rotated.

Constructing U by the outer-product formula

There is one clean formula for the rotation. Use outer products:

\boxed{\; U \;=\; |0\rangle\langle v_0| \;+\; |1\rangle\langle v_1|. \;}

Check: apply this to |v_0\rangle and use \langle v_0 | v_0 \rangle = 1, \langle v_1 | v_0 \rangle = 0 (orthonormality):

Likewise U|v_1\rangle = |1\rangle. Exactly what was wanted.

Why outer products do this job: the operator |0\rangle\langle v_0| is a projector-like object that picks out the |v_0\rangle component of whatever you feed it and returns it pointing in the |0\rangle direction. Think of it as "take the part along |v_0\rangle, relabel it as |0\rangle." Sum the two such relabellings (one per basis element) and you have the full relabelling operation — which is the unitary U.

Post-measurement state, in the basis-B picture

After you read outcome i on the hardware, the qubit's state is |i\rangle in the rotated frame. Pushed back into the original frame (the one the rest of the circuit lives in), the physical state is U^\dagger |i\rangle = |v_i\rangle. So the post-measurement interpretation is clean:

Outcome i means the state is now |v_i\rangle.

You have learned one bit of classical information — which |v_i\rangle — at the cost of projecting the full superposition onto one of the two basis vectors. Exactly the same content as a projective measurement in the computational basis, but expressed in the basis you actually cared about.

X-basis measurement — the Hadamard does it

The most common non-computational basis is the X basis, \{|+\rangle, |-\rangle\}. Recall

|+\rangle = \tfrac{1}{\sqrt{2}}(|0\rangle + |1\rangle), \qquad |-\rangle = \tfrac{1}{\sqrt{2}}(|0\rangle - |1\rangle).

Apply the formula: the rotation unitary is

U_X \;=\; |0\rangle\langle +| + |1\rangle\langle -|.

Expand \langle +| = \tfrac{1}{\sqrt 2}(\langle 0| + \langle 1|) and \langle -| = \tfrac{1}{\sqrt 2}(\langle 0| - \langle 1|):

U_X \;=\; \tfrac{1}{\sqrt 2}\!\left[\, |0\rangle(\langle 0| + \langle 1|) \;+\; |1\rangle(\langle 0| - \langle 1|) \,\right] \;=\; \tfrac{1}{\sqrt 2}\!\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}.

Why this is the Hadamard: you have just derived U_X = H. The matrix in the last step is exactly the Hadamard you met in the Hadamard chapter. So "the unitary that sends the X basis to the computational basis" is literally H.

The X-basis recipe. To measure a qubit in the X basis, apply a Hadamard and then do the default computational-basis measurement.

X-basis measurement as a circuit. The Hadamard rotates the X basis onto the computational basis; the meter then reads out the outcome.

This is the first time you have seen a gate used not to compute but to change what a measurement measures. A Hadamard on its own produces a superposition; a Hadamard right before a meter turns the meter into an X-basis detector. Same gate, entirely different pedagogical role.

Y-basis measurement — a little more work

The Y basis is

|+i\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + i|1\rangle), \qquad |-i\rangle = \tfrac{1}{\sqrt 2}(|0\rangle - i|1\rangle).

These are the states on the +y and -y equator points of the Bloch sphere. Apply the same formula:

U_Y \;=\; |0\rangle\langle +i| + |1\rangle\langle -i|.

Expand \langle +i| = \tfrac{1}{\sqrt 2}(\langle 0| - i\langle 1|) (the bra of |+i\rangle has the complex conjugate of the i amplitude) and \langle -i| = \tfrac{1}{\sqrt 2}(\langle 0| + i\langle 1|):

U_Y \;=\; \tfrac{1}{\sqrt 2}\!\left[\, |0\rangle(\langle 0| - i\langle 1|) \;+\; |1\rangle(\langle 0| + i\langle 1|) \,\right] \;=\; \tfrac{1}{\sqrt 2}\!\begin{pmatrix} 1 & -i \\ 1 & i \end{pmatrix}.

Why the i's flip sign between the ket and the bra: the bra is the conjugate transpose of the ket. If |+i\rangle has amplitude +i on the |1\rangle component, then \langle +i| has amplitude -i on the \langle 1| component. This is the "complex conjugate" part of "conjugate transpose." Forget this and you get the wrong Y-basis rotation every single time.

That matrix is not a gate you have a one-letter name for. But it factors into familiar pieces:

U_Y \;=\; S^\dagger H

where S is the phase gate \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix} and S^\dagger = \begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix}. Verify:

S^\dagger H \;=\; \begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix} \cdot \tfrac{1}{\sqrt 2}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} \;=\; \tfrac{1}{\sqrt 2}\begin{pmatrix} 1 & 1 \\ -i & i \end{pmatrix}.

That is not quite U_Y as written — look at the rows. The difference is a column-swap that lives in how you choose to label outcomes. Different textbooks pick different sign conventions; the standard Qiskit convention is exactly "apply S^\dagger then H, then measure in the computational basis." The physical content — 50-50 probabilities for a Y-eigenstate input, deterministic outcomes when the state is |+i\rangle or |-i\rangle — is identical either way.

The Y-basis recipe. To measure a qubit in the Y basis, apply S^\dagger, then H, then do the default computational-basis measurement.

Y-basis measurement circuit. Two gates and a meter. The $S^\dagger$ rotates the $y$-axis of the Bloch sphere onto the $x$-axis; the $H$ then rotates the $x$-axis onto the $z$-axis; the meter reads $z$. Compose the two and you have $y$-basis readout.

On the Bloch sphere the geometry is clean. The computational basis corresponds to the \pm z axis; the X basis to \pm x; the Y basis to \pm y. Any measurement is "find which pole of some axis the state is projected onto." Rotating to the z-axis with the right unitary is how you let the hardware's z-axis meter do the work in any frame you like.

A table of the common bases

Pin this table above your desk when you are writing circuits.

Rotation unitaries for the bases you will meet most often. For an arbitrary basis $B$, the outer-product formula gives $U$ directly; decompose into native gates using the [ZYZ decomposition](/wiki/single-qubit-decomposition).

Every line of this table is one application of the same idea: to measure in basis B, find the unitary that maps B to the computational basis, and apply it before the meter. The rightmost column is the only thing the hardware actually sees.

Worked examples

Example 1: Measure $|+\rangle$ in the X basis

You have prepared a qubit in the state |+\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + |1\rangle). Measure it in the X basis. Work out the probability of each outcome, the post-measurement state, and check against what you would expect from first principles.

Step 1. Write the X-basis circuit: apply H, then measure in the Z basis. Why: the X-basis rotation unitary is U_X = H, as derived above. "Measure in the X basis" is the software name; "apply H then measure in Z" is the hardware-level instruction.

Step 2. Compute what H does to |+\rangle. From the Hadamard chapter, H|+\rangle = |0\rangle. Why: H is self-inverse and H|0\rangle = |+\rangle, so H|+\rangle = H(H|0\rangle) = H^2 |0\rangle = |0\rangle. Alternatively, compute \tfrac{1}{\sqrt 2}(H|0\rangle + H|1\rangle) = \tfrac{1}{\sqrt 2}(|+\rangle + |-\rangle) and expand — the |1\rangle pieces cancel and you are left with |0\rangle.

Step 3. Apply the Born rule in the computational basis. The rotated state is |0\rangle, so

Why: in the computational basis, the probabilities are the squared moduli of the amplitudes. |0\rangle has amplitude 1 on |0\rangle and 0 on |1\rangle, so the outcome is deterministic.

Step 4. Interpret the outcome. The outcome is 0 with probability 1. In the basis-B picture, outcome 0 means "the state was |+\rangle" — which is exactly what you started with. The measurement correctly reports that the state was |+\rangle, with no randomness.

Step 5. Post-measurement state in the original frame. The hardware's post-measurement state is |0\rangle (collapsed in the computational basis). To get the interpretation in the X basis, apply U_X^\dagger = H: H|0\rangle = |+\rangle. So the qubit, after this measurement, is in state |+\rangle — unchanged.

Result. Measuring |+\rangle in the X basis gives outcome 0 (= |+\rangle) with probability 1, deterministically. The state is unchanged.

Contrast with Z-basis measurement of the same state. If instead you had measured |+\rangle in the Z basis, the probabilities would have been p(0) = p(1) = 1/2 — a fair coin flip. The same state gives a deterministic outcome in the X basis and a random outcome in the Z basis. That is not a contradiction; it is the point. A state "has a definite value" only in the basis that is its own eigenbasis. In any other basis, it is a genuine superposition and measurement produces a random outcome governed by the amplitudes.

Example 2: Measure $|0\rangle$ in the Y basis

Now the other direction. Take a qubit in the classical-looking state |0\rangle and measure it in the Y basis. Walk the recipe and see what you get.

Step 1. Apply the Y-basis rotation unitary U_Y = S^\dagger H to |0\rangle. First the Hadamard: H|0\rangle = |+\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + |1\rangle). Then S^\dagger, which multiplies the |1\rangle amplitude by -i:

S^\dagger |+\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + (-i)|1\rangle) = \tfrac{1}{\sqrt 2}(|0\rangle - i|1\rangle) = |-i\rangle.

Why S^\dagger multiplies the |1\rangle amplitude by -i: the matrix S^\dagger = \begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix} leaves the |0\rangle amplitude alone and sends the |1\rangle amplitude through a -\pi/2 phase rotation. Applied to \tfrac{1}{\sqrt 2}(|0\rangle + |1\rangle), you get \tfrac{1}{\sqrt 2}(|0\rangle - i |1\rangle) = |-i\rangle.

Step 2. Note the geometry. The rotated state is |-i\rangle. But you want to know the Z-basis probabilities of this — which depend on its amplitudes on |0\rangle and |1\rangle. Those amplitudes are \tfrac{1}{\sqrt 2} and -\tfrac{i}{\sqrt 2}.

Step 3. Apply the Born rule in the computational basis.

p(0) = \left|\tfrac{1}{\sqrt 2}\right|^2 = \tfrac{1}{2}, \qquad p(1) = \left|-\tfrac{i}{\sqrt 2}\right|^2 = \tfrac{1}{2}.

Why |-i/\sqrt 2|^2 = 1/2: the modulus of a complex number a + bi is \sqrt{a^2 + b^2}. For -i/\sqrt 2, a = 0 and b = -1/\sqrt 2, giving modulus 1/\sqrt 2. Squared, that is 1/2.

Step 4. Interpret. The Y-basis measurement of |0\rangle produces outcome 0 (= |+i\rangle) with probability 1/2 and outcome 1 (= |-i\rangle) with probability 1/2 — a fair coin flip.

Result. Measuring the classical-looking state |0\rangle in the Y basis is a genuine 50-50 quantum coin flip.

Why this matters. The state |0\rangle sits on the +z pole of the Bloch sphere. The Y basis lives on the \pm y axis, which is perpendicular to z. A state on a pole projects onto a perpendicular axis's two cardinal directions with equal probability — that is literally the geometry of projection. Here it gets expressed as "|0\rangle is a superposition of |+i\rangle and |-i\rangle with equal squared amplitudes."

You can also see this by decomposing directly:

|0\rangle = \tfrac{1}{\sqrt 2}\big(|+i\rangle + |-i\rangle\big).

Why: use the definitions of |+i\rangle and |-i\rangle and add. The |1\rangle pieces cancel (one has +i, the other -i) and the |0\rangle pieces add to \tfrac{2}{\sqrt 2} \cdot \tfrac{1}{\sqrt 2} = 1. So |0\rangle = \tfrac{1}{\sqrt 2}(|+i\rangle + |-i\rangle) — an equal superposition in the Y basis. Born rule then gives 50-50.

So the same state |0\rangle is:

deterministic in the Z basis (always outcome 0);
deterministic in the X basis? Let's check: |0\rangle = \tfrac{1}{\sqrt 2}(|+\rangle + |-\rangle), so in X basis it is 50-50;
50-50 in the Y basis (as just derived).

One state, three wildly different measurement statistics, depending on what you point the meter at. This is the lesson of the chapter, concretely.

Arbitrary bases — the general recipe in practice

For any orthonormal basis \{|v_0\rangle, |v_1\rangle\}, the rotation unitary U = |0\rangle\langle v_0| + |1\rangle\langle v_1| is a 2\times 2 unitary matrix. On a real quantum computer, though, you cannot just "apply an arbitrary matrix" — the hardware only has a finite native gate set. What you do is decompose U into a product of the native gates.

The ZYZ decomposition from the previous chapter is exactly the tool for this. Every single-qubit unitary is e^{i\alpha} R_z(\beta) R_y(\gamma) R_z(\delta) for some four angles — find those angles for U, emit the corresponding R_z and R_y pulses, and you have measured in the basis you wanted. The compiler sitting between your code and the hardware does this automatically; all you have to do in code is write measure.in_basis(U) or its equivalent in Qiskit/Cirq/PennyLane, and the rotation is inserted on your behalf.

This is what makes arbitrary-basis measurement a practical tool rather than a theoretical curiosity. The device supports two native rotations (R_x and R_z, say); every basis you ever want to measure in is three rotations away. Every quantum experiment that measures expectation values, or does state tomography, or runs a variational algorithm, relies on this compilation pathway behind the scenes.

Indian context — Stern-Gerlach, rotated

In the Stern-Gerlach chapter you saw the original quantum-measurement experiment: a silver atom flies through a non-uniform magnetic field oriented along the z-axis, and its spin is projected onto \pm z. The device is a physical Z-basis meter.

What if you rotate the apparatus 90 degrees, so the magnetic gradient is along x instead of z? You have built a physical X-basis meter. An atom whose spin state is |0\rangle (a "spin-up" state in the original z direction) now enters a detector that projects onto \pm x — and the outcomes are 50-50, because |0\rangle is an equal superposition in the X basis. This is exactly the calculation of Example 2, applied to a physical silver atom.

The mapping is: rotating the Stern-Gerlach apparatus is the physical realisation of applying a basis-change unitary. On a quantum computer you apply the unitary in software; on a spin-1/2 experiment you turn the magnets. Same measurement, same physics — just a different engineering layer.

At IIT Madras, nuclear magnetic resonance (NMR) quantum information experiments have been doing exactly this for decades: the measurement "basis" is picked by choosing the phase and amplitude of the readout radiofrequency pulse, which is mathematically equivalent to prepending an arbitrary single-qubit unitary before a default z-measurement. The quantum-circuit recipe in this chapter is nothing new to experimentalists — it is the abstract statement of what they have been doing on the bench.

Common confusions

"Changing the basis is the same as changing the state." No. The state |\psi\rangle is the same physical object regardless of which basis you choose to represent it in. Changing the basis only changes the labels you use to describe it. When you measure, you have to pick a basis — but picking the basis does not change the pre-measurement state. It only changes what question you are asking the qubit ("along which direction should I project you?"). The state is basis-independent; the measurement is basis-dependent.
"Measuring in the X basis does not disturb the state." False. Any measurement disturbs the state. If the state happens to be an X-basis eigenstate (|+\rangle or |-\rangle), then an X-basis measurement gives a deterministic outcome and leaves the state unchanged — so it looks undisturbed. But if the state is not an X-eigenstate (say, |0\rangle), an X-basis measurement projects it onto |+\rangle or |-\rangle, destroying the Z-basis definiteness it had. There is no "non-disturbing measurement" in projective quantum mechanics. The claim "undisturbed" only holds for states that are already eigenstates of the measurement.
"To measure in basis B, you permanently rotate the state into basis B." No. You apply a rotation U to the state, then measure in the computational basis. The rotation is a temporary software trick to make the hardware's default z-meter ask the right question. If you want to continue the computation in the original frame after the measurement, you apply U^\dagger to rotate back. Or you can simply reinterpret the outcome: "outcome i means the state was |v_i\rangle in the original frame" is the operational content.
"Arbitrary-basis measurement is a different kind of measurement than projective." It is still projective — just with projectors |v_0\rangle\langle v_0| and |v_1\rangle\langle v_1| instead of |0\rangle\langle 0| and |1\rangle\langle 1|. The projectors are different, but the Born rule is the same and the collapse rule is the same. The chapter on projective measurement stated the framework for any orthonormal basis; this chapter is the implementation story.
"Only orthogonal bases can be measured." True for projective measurement. If you want to distinguish states that are not orthogonal — or do measurements with more than d outcomes in a d-dimensional space — you need the more general POVM (positive operator-valued measure) framework introduced briefly at the end of the projective-measurement chapter. POVMs are strictly more general; projective measurements are the subset with orthogonal projectors of the right rank.
"You can learn the amplitudes c_0, c_1 from a single measurement." No. One measurement gives you one bit. To estimate |c_0|^2 and |c_1|^2, you need many runs in one basis. To estimate the phase of c_0 / c_1, you need runs in a different basis (typically X or Y). Reconstructing the full state requires measurements in at least three bases — this is quantum state tomography, previewed in the going-deeper section.

Going deeper

Everything you need to measure in an arbitrary basis is above: build the rotation unitary via the outer-product formula, apply it, measure in Z. The rest of this section goes further: expectation values as averages of measurement outcomes, quantum state tomography, mutually unbiased bases, and connections to the eigenstates of observables.

Observables and expectation values

In physics, observables are Hermitian operators (operators A with A^\dagger = A). The spectral theorem says every Hermitian A can be written as

A \;=\; \sum_m a_m P_m

where the a_m are real eigenvalues and the P_m are the orthogonal projectors onto the eigenspaces. Measuring the observable A means exactly what this chapter has been doing: perform a projective measurement in the basis of eigenvectors of A. The outcome of the measurement is the eigenvalue a_m (not the index m), with probability p(m) = \langle \psi | P_m | \psi \rangle.

The expectation value of A in the state |\psi\rangle is the average outcome you would get over many runs:

\langle A \rangle \;=\; \sum_m a_m \, p(m) \;=\; \sum_m a_m \langle \psi | P_m | \psi \rangle \;=\; \langle \psi | A | \psi \rangle.

For a general (possibly mixed) state described by a density matrix \rho, the formula generalises to \langle A \rangle = \text{Tr}(A \rho). This is the master formula for extracting numbers from a quantum system, and it is the quantity that variational algorithms (VQE, QAOA) minimise. Every VQE step estimates \langle H \rangle for some Hamiltonian H by running the circuit many times and averaging measurement outcomes — one of the most common uses of arbitrary-basis measurement in practice.

If A is the Pauli X operator, its eigenstates are |+\rangle (eigenvalue +1) and |-\rangle (eigenvalue -1), and measuring X means measuring in the X basis. Every run contributes +1 or -1 to the average. For the Pauli Y, same story with the Y basis. For Z, the computational basis. Pauli observables are why the X, Y, and Z bases are the three you meet most often — they are the eigenbases of the three fundamental single-qubit Hermitian operators.

Quantum state tomography

How do you learn an unknown single-qubit state |\psi\rangle (or more generally its density matrix \rho) from experiment? Measure in multiple bases, many times each, and reconstruct \rho from the statistics.

For a single qubit, any density matrix can be written

\rho \;=\; \tfrac{1}{2}\!\left(I + r_x X + r_y Y + r_z Z\right)

where (r_x, r_y, r_z) is the Bloch vector (length at most 1; length 1 for pure states). Measuring X gives \langle X \rangle = r_x; measuring Y gives r_y; measuring Z gives r_z. Three observables, three numbers — Bloch vector reconstructed, density matrix reconstructed.

For n qubits, the same idea extends to measurements in all 3^n tensor-product Pauli bases — which scales exponentially and is why tomography is expensive for anything beyond a few qubits. Modern techniques (compressed sensing tomography, shadow tomography) exploit structure to reduce the sample complexity, but the basic recipe — measure in many bases and fit a density matrix — is the foundation.

Experimental groups at TIFR, IIT Bombay, and the Raman Research Institute have all done state-tomography experiments on small-qubit systems; it is a standard laboratory skill.

Mutually unbiased bases

Two orthonormal bases B_1 = \{|v_i\rangle\} and B_2 = \{|w_j\rangle\} are mutually unbiased if |\langle v_i | w_j \rangle|^2 = 1/d for all i, j, where d is the dimension. Translation: measuring a B_1-eigenstate in the B_2 basis gives a uniformly random outcome — the two bases are "maximally incompatible."

For a qubit (d = 2), the three bases \{Z, X, Y\} = \{|0\rangle/|1\rangle, |+\rangle/|-\rangle, |+i\rangle/|-i\rangle\} are pairwise mutually unbiased. This is why they are the natural choice for tomography: three MUBs capture maximally independent information about the state, minimising the number of measurements needed.

In dimension d that is a prime power, you can find d+1 mutually unbiased bases (for d = 2, that is three — exactly Z, X, Y). Whether d+1 MUBs exist for general d (like d = 6) is a famous open problem in quantum information theory.

Eigenstates and measurement

A state |\psi\rangle is an eigenstate of the measurement basis B if it equals one of the basis vectors |v_i\rangle up to a global phase. In that case, the Born rule gives a deterministic outcome (p(i) = 1 for exactly one i), and the post-measurement state is unchanged (up to global phase).

So the rule is: a measurement is deterministic iff the input state is an eigenstate of the measurement basis. Everything else is a genuine quantum coin flip. The "classical-looking" states |0\rangle, |1\rangle are only classical in the computational basis; they are superpositions in every other basis, and measuring them in other bases gives random outcomes.

This is the operational content of the observation that "a qubit's value" depends on the chosen basis — a point the projective-measurement chapter introduced and this chapter has made concrete.

Where this leads next

Projective measurement — the framework this chapter implements for non-default bases.
The Hadamard gate — the X-basis rotation, repurposed as a measurement tool.
Phase gates S and T — S^\dagger from the Y-basis recipe, and its T^\dagger cousin for \pi/4-axis measurements.
Single-qubit decomposition — the ZYZ angles that compile an arbitrary basis rotation into native hardware gates.
Stern-Gerlach — the physical experiment where rotating the apparatus really is basis-change.
Quantum state tomography — the multi-basis measurement protocol that reconstructs an unknown density matrix.

References

Wikipedia, Measurement in quantum mechanics — projectors, arbitrary observables, and the rotate-then-measure picture in encyclopaedic form.
John Preskill, Lecture Notes on Quantum Computation, Ch. 2 (observables and measurement in arbitrary bases) — theory.caltech.edu/~preskill/ph229.
Nielsen and Chuang, Quantum Computation and Quantum Information (2010), §2.2 — the definitive account of projective measurement in arbitrary bases. Cambridge University Press.
Qiskit Documentation, Measurement in different bases — IBM Quantum Learning, with hands-on code for X- and Y-basis measurements.
Wikipedia, Mutually unbiased bases — the Z/X/Y triple and its generalisation to higher dimensions.
John Watrous, The Theory of Quantum Information — measurement formalism at graduate level; free PDF.