Succinct QUBO formulations for permutation problems by sorting networks

Quadratic Unconstrained Binary Optimization (QUBO) is a standard NP-hard optimization problem. Recently, it has gained renewed interest through quantum computing, as QUBOs directly reduce to the Ising model, on which quantum annealing devices are based. We introduce a QUBO formulation for permutations using compare-exchange networks, with only $O(n \log^2 n)$ binary variables. This is a substantial improvement over the standard permutation matrix encoding, which requires $n^2$ variables and has a much denser interaction graph. A central feature of our approach is uniformity: each permutation corresponds to a unique variable assignment, enabling unbiased sampling. Our construction also allows additional constraints, including fixed points and parity. Moreover, it provides a representation of permutations that supports the operations multiplication and inversion, and also makes it possible to check the order of a permutation. This can be used to uniformly generate permutations of a given order or, for example, permutations that commute with a specified permutation. To our knowledge, this is the first result linking oblivious compare-exchange networks with QUBO encodings. While similar functionality can be achieved using permutation matrices, our method yields QUBOs that are both smaller and sparser. We expect this method to be practically useful in areas where unbiased sampling of constrained permutations is important, including cryptography and combinatorial design.

💡 Research Summary

The paper introduces a novel QUBO (Quadratic Unconstrained Binary Optimization) encoding for permutations that leverages oblivious compare‑exchange (CE) sorting networks. Traditional QUBO formulations of permutations rely on the one‑hot (permutation‑matrix) representation, which requires n² binary variables and creates a dense interaction graph because each variable interacts with O(n) others. The authors observe that the information‑theoretic lower bound for encoding a permutation is Ω(n log n) bits, and they aim to approach this bound while keeping the quadratic structure required by QUBO solvers.

The key idea is to view a fixed sequence of compare‑exchange gates—used in classic sorting networks such as Batcher’s odd‑even merge sort—as a deterministic circuit that maps an input vector of n integers (each represented with k = ⌈log₂ n⌉ bits) to a sorted output. Each gate’s correct behavior can be expressed as a relation among its input bits, output bits, and a control bit. By constructing quadratic polynomial representations of these relations (a process called quadratization), the authors obtain a set of 2‑degree polynomials whose sum is zero if and only if every gate behaves correctly.

Two elementary gate types are treated in detail:

1. Greater‑Than (GT) gate – compares two k‑bit numbers x and y and produces a single control bit c indicating whether x > y. The authors introduce auxiliary variables p₀,…,p_k to identify the most significant differing bit, enforce a “exactly‑one” constraint on the p’s, and use a small quadratic penalty to ensure consistency. The resulting quadratic representation uses 3k + 1 auxiliary variables and is uniform, meaning that for any valid (x,y) the auxiliary variables are uniquely determined.

2. Controlled‑Swap (CS) gate – swaps two k‑bit numbers x₁ and x₂ when the control bit c = 1, otherwise leaves them unchanged. For each bit position a 1‑bit controlled swap is built using a linear selector g_s(x₁,x₂,c) = (1‑c)x₁ + c x₂, and the equality constraints (y₁ – g_s)² + (y₂ – g_s′)² enforce the correct output. Quadraticization introduces 2k auxiliary variables, again preserving uniformity.

A CE gate is simply the composition of a GT gate and a CS gate sharing the same control bit. Its quadratic representation therefore uses 5k + 1 auxiliary variables.

The authors prove (Theorem 1) that a network with n inputs, each k bits, and m gates can be encoded with O(k·(n + m)) binary variables. Since optimal sorting networks have m = O(n log n) gates, the total variable count becomes O(n log² n). Moreover, each variable participates in only O(log n) quadratic terms, yielding a very sparse interaction graph compared with the dense n²‑variable matrix encoding.

Beyond the basic permutation encoding, the framework naturally accommodates a variety of additional constraints, all expressed as extra quadratic penalties:

• Fixed points – enforce that a particular position i maps to itself by adding a CE gate that forces equality of the corresponding input and output bits.
• Parity (even/odd) – use a Hamming‑weight polynomial with O(log n) auxiliary bits to ensure the sum of the permutation’s one‑hot representation has the desired parity.
• Permutation order – to require π^ℓ = id, the authors chain ℓ copies of the same sorting network and add a penalty that the final output equals the original input.
• Multiplication and inversion – by concatenating two networks (representing π₁ and π₂) one can model the product π₁ ∘ π₂; inversion is obtained by feeding the output of a network back into a reversed copy.
• Commutativity – construct two products π₁π₂ and π₂π₁ using separate subnetworks and penalize any mismatch, enabling uniform sampling of permutations that commute with a given one.

Because each feasible permutation corresponds to exactly one zero‑energy assignment (the auxiliary variables are uniquely forced), the QUBO is uniform. Consequently, any solver that samples low‑energy states uniformly (e.g., quantum annealers, simulated annealing, or specialized QUBO solvers) will produce a uniformly random permutation, or uniformly random permutations satisfying the added constraints. This property is crucial for applications such as cryptographic key generation, S‑box design, Latin square completion, and randomized algorithms where unbiased sampling is required.

The paper also discusses limitations. Encoding graph‑theoretic problems like the Traveling Salesperson Problem is not straightforward, because representing vertices as binary strings and checking edge existence would require additional non‑local constraints, leading to a blow‑up in variables and interactions. Thus the method is best suited for problems where the primary combinatorial object is a permutation itself.

In summary, the authors present a systematic method to translate oblivious compare‑exchange networks into sparse, near‑optimal QUBO formulations. The approach reduces the variable count from Θ(n²) to O(n log² n), maintains quadratic structure, and preserves uniformity, thereby enabling efficient, unbiased sampling of permutations and constrained permutation families on both classical and quantum optimization hardware.