Jordan-Wigner Transformation

The Jordan-Wigner (JW) transformation is a mathematical mapping from fermionic operators to qubit (spin-1/2) operators. It was introduced by Pascual Jordan and Eugene Wigner in 1928 in the context of one-dimensional quantum spin chains, and has become one of the most important tools in quantum computing for chemistry and materials simulation.

The Problem It Solves

Quantum computers operate on qubits, which satisfy Pauli algebra. Electrons and other fermions satisfy a different algebra: fermionic anticommutation relations, which encode the Pauli exclusion principle. To simulate a fermionic system on a quantum computer, you need a way to faithfully represent fermionic operators using qubit operators. The Jordan-Wigner transformation provides exactly this.

The Mapping

In the Jordan-Wigner transformation, each fermionic orbital j is associated with one qubit. The fermionic creation operator a_j^dagger and annihilation operator a_j are mapped to:

a_j^dagger  -->  (Z_0 x Z_1 x ... x Z_{j-1}) x (X_j - iY_j) / 2
a_j         -->  (Z_0 x Z_1 x ... x Z_{j-1}) x (X_j + iY_j) / 2

The key feature is the “Jordan-Wigner string”: a product of Pauli Z operators on all qubits 0 through j-1. This string encodes the ordering of orbitals and ensures that the mapped operators satisfy the fermionic anticommutation relations:

{a_i, a_j^dagger} = delta_ij
{a_i, a_j} = 0

The occupation number operator n_j = a_j^dagger a_j maps to (I - Z_j) / 2, which is the projector onto the |1> state of qubit j. The |0> qubit state corresponds to an unoccupied orbital and |1> to an occupied orbital.

Effect on the Hamiltonian

Applying the Jordan-Wigner transformation to the second-quantized molecular Hamiltonian converts it into a weighted sum of Pauli strings. For a molecule with M orbitals, the resulting qubit Hamiltonian has M qubits and O(M^4) Pauli terms. Each Pauli term is a tensor product of Pauli I, X, Y, Z operators on subsets of qubits.

This Pauli string representation is exactly what is needed for VQE: each term can be measured independently on quantum hardware by rotating to the appropriate basis before measurement.

The Jordan-Wigner String Overhead

The main disadvantage of the Jordan-Wigner transformation is that operators for orbital j require a string of j Pauli Z gates. In a circuit implementation, each Z in the string adds depth. For orbitals near the end of a long chain, this can require O(M) gates per fermionic operator, leading to O(M^5) circuit depth for a full molecular simulation (compared to O(M^4) Pauli terms).

This overhead motivates alternative fermion-to-qubit mappings.

Alternative Mappings

The Bravyi-Kitaev (BK) transformation reorders the qubit register to achieve O(log M) gate overhead per fermionic operator, reducing the circuit depth from O(M^5) to O(M^4 log M). It is more complex to construct but more circuit-efficient for large systems.

The parity basis and superfast encoding are other mappings with different qubit-count and gate-overhead tradeoffs, suited to specific Hamiltonian structures or hardware connectivity.

The choice of fermion-to-qubit mapping is an important practical decision in quantum chemistry simulation and is supported by libraries like OpenFermion, PySCF interface tools, and the quantum chemistry modules in PennyLane and Qiskit Nature.

Practical Example

In PennyLane, the Jordan-Wigner transformation is applied automatically when building a molecular Hamiltonian:

import pennylane as qml
from pennylane import qchem

symbols = ["H", "H"]
coordinates = [[0.0, 0.0, 0.0], [0.0, 0.0, 1.4]]

# This applies Jordan-Wigner internally
H, n_qubits = qchem.molecular_hamiltonian(
    symbols, coordinates, mapping="jordan_wigner"
)
print(f"Number of qubits: {n_qubits}")
print(f"Number of Pauli terms: {len(H.ops)}")

The output Hamiltonian is a linear combination of Pauli operators ready for use in VQE or other quantum algorithms.