⚛️ quantum physics

Optimal fermion-qubit mappings via quadratic assignment

This paper introduces two computational methods to optimize fermion-qubit mappings by framing label ordering as a quadratic assignment problem and incrementally adding ancilla qubits, effectively balancing qubit count and gate complexity to significantly reduce Pauli weights in quantum simulations.

Original authors: Mitchell Chiew, Cameron Ibrahim, Ilya Safro, Sergii Strelchuk

Published 2026-03-24

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Mitchell Chiew, Cameron Ibrahim, Ilya Safro, Sergii Strelchuk

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to translate a complex story written in a secret language (Fermions, the particles that make up matter) into a language a robot can understand (Qubits, the bits of a quantum computer).

The problem is that the secret language has a very specific rule: if you move one character, it affects the meaning of every character that came before it. In the robot's language, this is like trying to move a single letter in a sentence, but the robot requires you to rewrite the entire paragraph every time. This makes the translation incredibly long, messy, and expensive to run.

This paper is about finding the smartest way to translate this story so the robot can read it quickly and without running out of memory.

Here is the breakdown of their solution using simple analogies:

1. The Two Bad Options (The Old Ways)

Before this paper, scientists had two main ways to do this translation, and both had flaws:

Option A: The "No Helpers" Method (Ancilla-free).
- The Analogy: Imagine you have a tiny notebook with very few pages (limited qubits). You try to write the whole story in it. To save space, you use a very clever code. However, because you are so cramped, every time you want to move a character, you have to flip through half the notebook to find the right spot. It's efficient on space, but slow and messy to read.
Option B: The "Hire Helpers" Method (Local Encodings).
- The Analogy: You hire a team of assistants (ancilla qubits) to help you. Now, you can write the story so that moving a character only affects a few pages. It's very fast to read! But, you need a lot of assistants. Since quantum computers are currently very small and expensive, hiring a huge team is impossible right now.

2. The Paper's First Idea: "Re-arranging the Furniture"

The authors realized that even with the cramped "No Helpers" method, the order in which you write the story matters a lot.

The Analogy: Imagine you are packing a suitcase. If you throw clothes in randomly, you might need to dig through the whole bag to find your socks. But if you pack them in a specific, optimized order (socks here, shirts there), you can grab what you need instantly.
The Math: They treated the problem like a puzzle called the Quadratic Assignment Problem. They used a computer to find the absolute best order to label the particles.
The Result: By simply re-ordering the "furniture" in the suitcase, they made the "No Helpers" method much faster and less messy, without needing any extra space.

3. The Paper's Second Idea: "The Magic Shortcut"

This is the bigger breakthrough. They asked: "What if we only hire a tiny, tiny team of helpers? Just a few?"

The Analogy: Imagine you are stuck in a long line of people (the "string" of operations in the old method). You can't move forward because the line is too long.
- The authors found a way to use just a few extra people (ancilla qubits) standing on the side.
- These extra people act like "magic erasers." They can cancel out the long, messy chains of operations that usually slow everything down.
- Instead of needing a whole army of helpers, they found that 10 extra helpers were enough to cut the workload by 67%.

4. The Big Win

The paper proves that you don't have to choose between "too much space" and "too much work."

Before: You had to pick between a slow, messy translation (no helpers) or a fast one that required a massive, impossible team (many helpers).
Now: You can use a tiny, manageable team (just 10 extra qubits) to get a translation that is faster and cleaner than the best "no helper" methods ever were.

Summary

Think of this paper as a guide for packing a quantum computer's suitcase. They showed us two things:

Pack smarter: If you arrange the items in the perfect order, you save a lot of time.
Bring a few friends: If you bring just a handful of extra friends (ancilla qubits), they can act as "magic erasers" to delete the heavy lifting, making the whole trip much easier than anyone thought possible.

This is huge news because it means we can do complex chemistry and physics simulations on today's small quantum computers, rather than waiting for them to grow much larger.

1. Problem Statement

Simulating fermionic systems (e.g., in quantum chemistry and condensed matter physics) on quantum computers requires mapping fermionic operators to qubit operators. This process, known as fermion-qubit mapping, is non-trivial due to the Pauli weight of the resulting Hamiltonian terms.

Pauli Weight: The number of qubits a specific operator term acts upon. High Pauli weights increase gate complexity, circuit depth, and measurement overhead (crucial for algorithms like VQE).
The Trade-off:
- Ancilla-free mappings (e.g., Jordan-Wigner, Bravyi-Kitaev) use the minimum number of qubits ( $n$ modes $\to$ $n$ qubits) but often result in non-local terms with weights scaling linearly ( $O(n)$ ) or logarithmically ( $O(\log n)$ ) with system size.
- Local encodings (e.g., Bravyi-Kitaev Superfast) use ancilla qubits to achieve constant weight ( $O(1)$ ) but require a number of ancillas scaling linearly with the system size ( $O(n)$ ), which is a scarce resource for near-term devices.
The Gap: There is a need for strategies that balance qubit count and gate complexity without requiring a massive overhead of ancilla qubits. Specifically, the paper addresses how to optimize existing mappings and how to incrementally add a small, constant number of ancillas to reduce Pauli weights significantly.

2. Methodology

The authors propose two distinct computational approaches to optimize fermion-qubit mappings:

A. Fermionic Order Optimization via Quadratic Assignment

The authors observe that the physical ordering of fermionic modes is arbitrary, yet different orderings result in different Pauli weights when mapped to qubits.

Formulation: They frame the problem of finding the optimal fermionic labeling order ( $\sigma$ ) as a Quadratic Assignment Problem (QAP).
Cost Function: They define a cost matrix $D$ representing the Pauli weight contribution of number terms, hopping terms, and interaction terms for any pair of modes. The objective is to minimize the total or maximum Pauli weight:
$\min_{\sigma} \left( \bigoplus_{(i,j) \in E_\sigma} D_{ij} \right) \oplus \left( \bigoplus_{i \in V_\sigma} D_{ii} \right)$
where $\oplus$ represents either summation (for total weight) or maximization (for max weight).
Scope: This method is applied to a class of mappings called "linear encodings," which includes Jordan-Wigner (JW), Bravyi-Kitaev (BK), Ternary Tree (TT), and Parity Basis (PB).
Algorithm: They utilize heuristic solvers (specifically the Hexaly library) to solve the QAP for systems up to 225 fermionic modes.

B. Incremental Addition of Ancilla Qubits

The authors generalize a previous strategy (from [29]) to incrementally add a small number of ancilla qubits to a standard Jordan-Wigner transformation.

Mechanism: Starting with an optimized JW Hamiltonian, they introduce an ancilla qubit. For each hopping term in the Hamiltonian, they have a choice to either:
1. Leave the term unchanged (acting on the ancilla with a local gate).
2. Multiply the term by a Pauli string $Z_I$ (acting on a subset of qubits $I$ ) and a gate on the ancilla.
Optimization: The goal is to select the subset of qubits $I$ and the specific option (1 or 2) for each term to minimize the total Pauli weight. This is formulated as an optimization problem to find the optimal set of qubit subsets $I_k$ for $k$ ancillas.
Theoretical Basis: The method relies on Theorem 1, ensuring that the modified qubit Hamiltonian remains unitarily equivalent to the original fermionic Hamiltonian by preserving commutation relations and Hermiticity.
Extension: This process is applied iteratively. The authors demonstrate that adding up to 10 ancillas can drastically reduce weights without the $O(n)$ scaling of full local encodings.

3. Key Contributions

Generalized Order Optimization: Extended the concept of optimizing fermionic labeling orders (previously limited to JW) to other linear encodings (BK, TT, PB) by casting the problem as a QAP.
Constant-Ancilla Strategy: Developed a scalable method to incrementally add any number of ancilla qubits to Jordan-Wigner transformations, creating "constant-ancilla mappings" that outperform standard ancilla-free methods.
Comprehensive Benchmarking: Provided extensive empirical data comparing JW, BK, TT, and PB across various graph topologies (square grids, hexagonal lattices, random graphs) and system sizes (up to 225 modes).
Reproducibility: Released source code and data to facilitate further research in this domain.

4. Key Results

Order Optimization:
- For small systems, Jordan-Wigner with optimized ordering often yields the best results.
- For larger systems, Ternary Tree and Bravyi-Kitaev generally outperform Jordan-Wigner due to better scaling.
- The optimization successfully recovered the known optimal "Mitchison-Durbin" ordering for square lattices, validating the approach.
Ancilla Addition:
- Adding a small number of ancillas (e.g., 10) to the Jordan-Wigner transformation significantly reduces Pauli weights.
- Reduction Magnitude: In systems with up to 64 modes, adding 10 ancillas reduced the total Pauli weight by up to 67%.
- Performance: The "JW + 10 ancillas" approach outperformed the best-known ancilla-free mappings (specifically the optimized Ternary Tree) in terms of total Pauli weight for various graph structures (e.g., Hex-Lattice, Random 3-Regular).
- Example: On an 8x8 grid, 10 ancillas reduced the JW hopping term weight by 39.3%, making it comparable to or better than the Ternary Tree transformation.

5. Significance

This work bridges the gap between resource-constrained ancilla-free mappings and resource-heavy local encodings.

Near-Term Viability: It demonstrates that near-term quantum computers, which have limited qubit counts, can simulate larger and more complex fermionic systems by using a small, fixed number of ancilla qubits (e.g., 10) rather than a number scaling with the system size.
Cost Reduction: By reducing Pauli weights, the method directly lowers the circuit depth and measurement overhead required for algorithms like VQE and Trotterization, improving the fidelity of simulations on noisy intermediate-scale quantum (NISQ) devices.
Algorithmic Flexibility: The formulation of the ordering problem as a QAP provides a general framework that can be adapted to other cost functions (e.g., gate depth) and future mapping strategies.

In conclusion, the paper establishes that computationally-assisted optimization of fermionic labeling and the strategic use of a constant number of ancillas are powerful, underutilized tools for making fermionic simulations feasible on current and near-future quantum hardware.