⚛️ quantum physics

A Quantum Encoding of Traveling Salesperson Tours via Route Generation, Cost Phases, and a Valid-Permutation

This paper proposes a compact quantum encoding of the Traveling Salesperson Problem using a time-register representation with uniform route generation, validity marking, and cost phase accumulation, achieving polynomial qubit and circuit depth requirements while acknowledging that the exponential scarcity of valid tours prevents the method from overcoming the problem's inherent exponential complexity even with amplitude amplification.

Original authors: Alexander Johannes Stasik, Franz Georg Fuchs

Published 2026-03-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Alexander Johannes Stasik, Franz Georg Fuchs

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 a travel agent trying to solve the ultimate puzzle: The Traveling Salesperson Problem (TSP). You have a map of $n$ cities, and you need to find the shortest possible route that visits every city exactly once and returns home.

The problem is that as you add more cities, the number of possible routes explodes. For just 20 cities, there are more possible routes than there are atoms in the universe. Checking them one by one on a normal computer would take longer than the age of the universe.

This paper proposes a way to use a Quantum Computer to tackle this, not by magically solving it instantly, but by organizing the chaos in a very clever way. Here is the breakdown using simple analogies.

1. The Setup: The "Time-Traveling" Notebook

Instead of drawing lines between cities on a map (which is how most computer programs do it), the authors suggest a different approach: A Time-Traveling Notebook.

The Analogy: Imagine you have a notebook with $n-1$ pages. On page 1, you write down the first city you visit. On page 2, the second city, and so on.
The Quantum Trick: A normal computer has to write one specific route in the notebook (e.g., "London, Paris, Berlin..."). A quantum computer, however, can write every possible combination of cities in the notebook at the same time. It creates a "superposition," which is like a magical cloud containing every possible itinerary simultaneously.

2. The Three Magic Tools (The Ingredients)

To make this cloud of possibilities useful, the authors built three specific "tools" (or circuits) to manipulate the quantum state:

A. The Uniform Generator (The "Shuffler")

First, the computer fills the notebook with random city names. It doesn't care if the route makes sense yet; it just ensures every possible combination of cities is represented in the quantum cloud.

Metaphor: It's like a machine that randomly shuffles a deck of cards and deals them out to every possible player at once.

B. The Validity Oracle (The "Strict Librarian")

This is the most important filter. In our random notebook, many routes are nonsense (e.g., visiting "Paris" three times and skipping "Berlin" entirely).

How it works: The computer checks every route in the cloud. If a route visits every city exactly once, the "Librarian" gives it a special "Valid" stamp. If a route is messy (repeats a city or misses one), it gets a "Trash" stamp.
The Catch: The authors point out a harsh reality. In a random shuffle, valid routes are incredibly rare. It's like trying to find a specific winning lottery ticket in a pile of billions of losing tickets. Even with quantum magic, finding the valid ones is still very hard because the "winning tickets" are so few.

C. The Cost Oracle (The "Price Tagger")

Once a route is stamped "Valid," the computer needs to know how long the trip is.

How it works: The computer calculates the total distance of the trip. Instead of writing the number down, it changes the phase (a hidden wave property) of that specific route.
Metaphor: Imagine the valid routes are musical notes. The Cost Oracle plays a high-pitched note for short trips and a low-pitched note for long trips. The computer doesn't "see" the price; it "hears" the pitch.

3. The Result: A Symphony of Routes

After running these tools, the quantum computer holds a giant, complex wave.

The "Invalid" routes are marked as trash.
The "Valid" routes are marked as good.
Among the good routes, the short ones have a different "pitch" than the long ones.

The computer now has a coherent superposition: a single quantum state that contains all valid tours, with their costs encoded in their wave patterns.

4. The Reality Check: Why It's Not a Magic Bullet

The paper is honest about the limitations. While this is a beautiful and compact way to represent the problem, it doesn't solve the "Exponential Wall."

The Problem: Because valid routes are so rare (like finding a needle in a haystack the size of a galaxy), you still have to search through a massive amount of "garbage" data to find the valid ones.
The Analogy: Imagine you have a magic flashlight that can shine on all the needles in a haystack at once. However, because the haystack is so huge and the needles are so few, you still have to sweep the flashlight over the whole thing many times to find the best needle. The quantum computer speeds up the search (quadratically), but it can't turn the exponential difficulty into a simple one.

Summary

This paper presents a blueprint for how to organize the Traveling Salesperson Problem on a quantum computer.

Encode: Write routes as time-ordered lists.
Filter: Use a "Librarian" to stamp out invalid routes.
Tag: Use a "Price Tagger" to mark the cost of valid routes.

The Takeaway: It's a very efficient way to store the problem in quantum memory, but it doesn't yet provide a shortcut to solve it instantly. It's a solid foundation for future researchers to build upon, perhaps by combining it with other advanced quantum techniques to finally crack the code of the Traveling Salesperson.

1. Problem Statement

The paper addresses the Traveling Salesperson Problem (TSP), a classic NP-hard combinatorial optimization problem. The goal is to find a minimum-cost Hamiltonian cycle in a weighted graph of $n$ cities that visits every city exactly once and returns to the start.

Challenge: The number of valid tours grows factorially ( $(n-1)!$ ), while the total search space of possible city sequences grows exponentially ( $(n-1)^{n-1}$ ).
Context: While quantum algorithms (e.g., Grover's algorithm, QSVT) offer superposition-based search, standard edge-based encodings (used in QUBO/Ising models) often struggle with constraint enforcement. This paper proposes a route-based encoding within a quantum circuit model to explicitly handle the permutation structure of the problem.

2. Methodology: Quantum Encoding Construction

The authors propose a compact quantum circuit that encodes candidate tours as time-ordered sequences of city labels. The construction consists of three primary components:

A. State Representation (Route Register)

Encoding Scheme: Instead of encoding edges, the algorithm uses a time-register representation.
- One city (e.g., city $n-1$ ) is fixed as the start/end point.
- The remaining $n-1$ cities are encoded as a sequence $x_1, x_2, \dots, x_T$ where $T = n-1$ .
- Each city label requires $b = \lceil \log_2(n-1) \rceil$ qubits.
Qubit Count: The total route register size is $T \times b \approx n \log_2(n)$ qubits.
Initial State: A uniform superposition $|\psi_{unif}\rangle$ is created over all possible $2^{bT}$ binary strings using Hadamard gates. This represents all possible sequences of cities, including invalid permutations (where cities are repeated or omitted).

B. Validity Oracle ( $O_{valid}$ )

To distinguish valid tours (permutations) from invalid assignments, a reversible oracle is constructed:

Logic: A tour is valid if and only if every non-start city label appears exactly once in the sequence.
Implementation:
1. Parity Accumulation: For each city label $i \in \{0, \dots, n-2\}$ , an ancilla qubit tracks the parity of its occurrence across all time steps. This is done by comparing the register $|x_t\rangle$ with the binary encoding of $i$ at each step and flipping the corresponding ancilla if they match.
2. Flag Generation: A final flag qubit is set to $|1\rangle$ if and only if all parity ancillas indicate an odd count (specifically, exactly one occurrence). This is achieved via a multi-controlled X (MCX) gate.
Complexity: Requires $(n-1)^2$ comparison gates and one final MCX gate.

C. Cost Oracle ( $O_{cost}$ )

This oracle encodes the total tour length into the phase of the quantum state:

Cost Function: $L(x) = C_{0,x_1} + \sum_{t=1}^{T-1} C_{x_t, x_{t+1}} + C_{x_T, 0}$ .
Implementation: Controlled phase rotations are applied based on the edge weights.
- Start/End Edges: Controlled by the first and last city labels.
- Intermediate Edges: Controlled by pairs of adjacent city labels $(x_t, x_{t+1})$ .
Phase: The state transforms as $|x\rangle \to e^{i L(x)/\Lambda}|x\rangle$ , where $\Lambda$ is a scaling factor (upper bound on tour length).

3. Key Contributions

Compact Route-Based Encoding: The paper introduces a direct time-ordered encoding of TSP tours, making the permutation structure explicit and avoiding the complex constraints often required in edge-based formulations.
Modular Oracle Design: It provides a concrete construction for:
- A valid-permutation oracle that uses parity checks to verify Hamiltonian cycles.
- A cost phase oracle that accumulates edge weights into a global phase.
Resource Analysis: The authors provide a rigorous asymptotic analysis of the circuit resources required for these oracles.

4. Results and Complexity Analysis

The paper quantifies the resource requirements for the proposed encoding:

Metric	Complexity	Notes
Qubits	$O(n \log_2 n)$	Route register + ancillas for parity and flags.
CX Gates (Count)	$O(n^3 \log_2 n)$	Dominated by the cost oracle's multi-controlled phase gates.
T Gates (Count)	$O(n^3 (\log_2 n + \log_2(1/\epsilon)))$	Depends on precision $\epsilon$ for phase rotations.
Circuit Depth	$O(n^2 \log_2 n)$	Achieved by parallelizing operations on disjoint time steps.

Amplification Limitations:
The authors analyze the feasibility of using Amplitude Amplification (Grover's algorithm) to find the optimal tour:

Success Probability: The fraction of valid tours in the superposition is $\frac{(n-1)!}{(n-1)^{n-1}}$ . By Stirling's approximation, this scales as $\sim e^{-(n-1)}$ .
Complexity Consequence: The number of iterations required to amplify the valid subspace scales as $O(1/\sqrt{p}) \approx O(e^{(n-1)/2})$ .
Conclusion: Even with quantum speedup, the overall complexity remains exponential in $n$ due to the exponentially small fraction of valid states. The method does not yield a polynomial-time quantum algorithm for TSP.

5. Significance and Future Directions

Baseline for Simulation: The primary value of this work is providing a clear, reproducible baseline encoding suitable for small-scale quantum simulations and testing of spectral filtering techniques (like QSVT).
Hybrid Strategies: The paper suggests that while pure amplitude amplification is inefficient, the encoding is compatible with spectral filtering or polynomial filtering methods that might bias the state toward low-cost tours without strictly isolating the valid subspace first.
Future Work: The authors identify the need for:
- More efficient oracle constructions (e.g., using reversible arithmetic or block-encoding) to reduce the $O(n^3)$ gate count.
- Alternative encodings that increase the density of valid states in the Hilbert space.
- Exploring spectral methods (QSVT) to handle the cost function and feasibility constraints simultaneously.

In summary, the paper presents a theoretically sound but computationally expensive quantum circuit for TSP. It serves as a foundational building block for exploring how quantum spectral methods might eventually tackle combinatorial optimization problems where the solution space is sparse.