Computational Basis Encoding

Classical computers store numbers as strings of bits — 0s and 1s — and quantum computers do the same at the register level. Understanding how integers map to multi-qubit states is essential before you can write any algorithm that processes numerical data.

Binary representation

Every non-negative integer $n$ can be written uniquely in base 2:

n = b_{k-1}\,2^{k-1} + b_{k-2}\,2^{k-2} + \cdots + b_1\,2 + b_0,

where each $b_i \in \{0,1\}$ . The $k$ -bit string $b_{k-1}\ldots b_1 b_0$ is the binary representation of $n$ . For example,

5 = 1 \cdot 4 + 0 \cdot 2 + 1 \cdot 1 = (101)_2.

Computational basis states

An $n$ -qubit register has a computational basis of $2^n$ states, $|0\rangle, |1\rangle, \ldots, |2^n - 1\rangle$ , one for every non-negative integer that fits in $n$ bits. The state $|j\rangle$ is the tensor product of the individual qubit states that spell out the binary digits of $j$ . With qubit 0 as the most significant bit:

|j\rangle = |b_{n-1}\rangle \otimes |b_{n-2}\rangle \otimes \cdots \otimes |b_0\rangle,

where $j = \sum_{i=0}^{n-1} b_i\,2^{n-1-i}$ .

For a 3-qubit register the eight basis states are:

| Integer | Binary | State | |---------|--------|-------| | 0 | 000 | $|000\rangle$ | | 1 | 001 | $|001\rangle$ | | 2 | 010 | $|010\rangle$ | | 3 | 011 | $|011\rangle$ | | 4 | 100 | $|100\rangle$ | | 5 | 101 | $|101\rangle$ | | 6 | 110 | $|110\rangle$ | | 7 | 111 | $|111\rangle$ |

Encoding with X gates

Every qubit starts in $|0\rangle$ . To encode an integer $j$ , apply an $X$ gate to each qubit whose corresponding bit in $j$ is 1. The $X$ gate flips $|0\rangle \to |1\rangle$ (and $|1\rangle \to |0\rangle$ ), so selectively applying it writes 1s in the right positions.

To encode $5 = (101)_2$ in a 3-qubit register (qubit 0 = MSB):

Qubit 0 gets $X$ (bit = 1).
Qubit 1 stays untouched (bit = 0).
Qubit 2 gets $X$ (bit = 1).

The resulting state is $|101\rangle = |5\rangle$ .

General recipe

Given an integer $j$ and a register of $n$ qubits (qubit 0 = MSB, qubit $n-1$ = LSB):

Write $j$ in binary: $b_{n-1}\ldots b_1 b_0$ .
For each position $i$ where $b_i = 1$ , call c.x(i).

The register is then in the pure state $|j\rangle$ with amplitude 1.

Try it

Encode the integer 5 into a 3-qubit register. The grader checks the full statevector, so the amplitude of $|101\rangle$ must be 1 and all others must be 0.

Run your code to see the quantum state.

After running, look at the statevector panel: the only non-zero amplitude should appear at index 5 (the binary string 101), confirming the register holds $|5\rangle$ .