The Bravyi–Kitaev Transform

The Jordan–Wigner transform pays for its simplicity with long Pauli strings: a single fermionic operator on orbital $p$ drags a string of $Z$ gates across all $p$ earlier qubits. For large molecules these $O(n)$ -weight strings inflate circuit depth and measurement cost. The Bravyi–Kitaev (BK) transform is an alternative encoding that balances two competing bookkeeping tasks so that each fermionic operator touches only $O(\log n)$ qubits.

Two pieces of bookkeeping

Every fermion-to-qubit mapping must store two kinds of information:

Occupation — does orbital $p$ contain an electron? This is needed by the number operator.
Parity — how many electrons occupy orbitals $0, \dots, p-1$ ? This supplies the fermionic sign when an operator acts on orbital $p$ .

Jordan–Wigner stores occupation locally (qubit $p$ holds $n_p$ directly) but computes parity non-locally, reading $p$ qubits via the $Z$ string. The opposite extreme, the parity encoding, stores running parity locally but then needs a long string to recover occupation. Both are linear in $n$ for one of the two tasks.

The Bravyi–Kitaev idea

Bravyi and Kitaev observed that you do not have to store either raw occupation or raw parity at a single qubit. Instead, store partial sums of occupation numbers on a binary tree of qubits, so that both the occupation of any orbital and the parity of any prefix can be reconstructed from only a logarithmic number of qubits.

Concretely, qubit $j$ stores a sum

b_j = \sum_{k \in S(j)} n_k \pmod 2

over a carefully chosen index set $S(j)$ derived from the binary representation of $j$ . Three index sets organize the reconstruction:

the update set $U(j)$ — qubits whose stored sum changes when $n_j$ flips,
the parity set $P(j)$ — qubits needed to compute the parity of orbitals before $j$ ,
the flip set $F(j)$ — qubits needed to determine the occupation of orbital $j$ .

Each of these sets has size $O(\log n)$ , so the Pauli string for $a_j$ or $a_j^\dagger$ acts on only $O(\log n)$ qubits rather than $O(n)$ .

Worked small case

For $n = 4$ orbitals the BK basis vectors differ from JW. For example, the number operator on orbital 1 is no longer simply $\tfrac{1}{2}(I - Z_1)$ ; in the standard BK ordering it becomes a two-qubit operator involving $Z_0$ and $Z_1$ , because qubit 1 stores the partial sum $n_0 + n_1$ . The total particle number, $\sum_p \hat n_p$ , however, remains diagonal in both encodings.

Choosing an encoding in practice

| Property | Jordan–Wigner | Bravyi–Kitaev | |---|---|---| | Occupation lookup | local ( $O(1)$ ) | $O(\log n)$ | | Parity lookup | $O(n)$ | $O(\log n)$ | | Operator Pauli weight | up to $O(n)$ | $O(\log n)$ | | Conceptual clarity | high | lower | | Qubit count | $n$ | $n$ |

Both use the same number of qubits ( $n$ , one per spin-orbital) and produce a Hamiltonian that is a weighted sum of Pauli strings. The choice is a trade-off: JW for clarity and small systems, BK (or more recent low-weight encodings such as ternary-tree mappings) for scaling. Software libraries such as OpenFermion implement both behind a single interface, so a chemistry workflow can switch encodings by changing one argument.

In this module we proceed with Jordan–Wigner, whose Hamiltonian for $\text{H}_2$ we build explicitly in the next lesson.