On Exact Algorithms for Permutation CSP

In the Permutation Constraint Satisfaction Problem (Permutation CSP) we are given a set of variables $V$ and a set of constraints C, in which constraints are tuples of elements of V. The goal is to find a total ordering of the variables, $\pi\ : V \rightarrow [1,…,|V|]$, which satisfies as many constraints as possible. A constraint $(v_1,v_2,…,v_k)$ is satisfied by an ordering $\pi$ when $\pi(v_1)<\pi(v_2)<…<\pi(v_k)$. An instance has arity $k$ if all the constraints involve at most $k$ elements. This problem expresses a variety of permutation problems including {\sc Feedback Arc Set} and {\sc Betweenness} problems. A naive algorithm, listing all the $n!$ permutations, requires $2^{O(n\log{n})}$ time. Interestingly, {\sc Permutation CSP} for arity 2 or 3 can be solved by Held-Karp type algorithms in time $O^*(2^n)$, but no algorithm is known for arity at least 4 with running time significantly better than $2^{O(n\log{n})}$. In this paper we resolve the gap by showing that {\sc Arity 4 Permutation CSP} cannot be solved in time $2^{o(n\log{n})}$ unless ETH fails.

💡 Research Summary

The paper investigates the exact‑time complexity of the Permutation Constraint Satisfaction Problem (Permutation CSP), focusing on the case where each constraint involves at most four variables (arity 4). In a Permutation CSP instance we are given a set of variables V and a collection C of ordered tuples; a total ordering π of V satisfies a tuple (v₁,…,v_k) iff π(v₁)<π(v₂)<…<π(v_k). For arities 2 and 3, classic Held‑Karp‑style dynamic programming yields algorithms running in O*(2ⁿ) time, dramatically improving over the naïve enumeration of all n! permutations, which costs 2^{Θ(n log n)}. However, for arity 4 and higher no algorithm substantially better than 2^{Θ(n log n)} was known, leaving a gap in our understanding of the problem’s fine‑grained complexity.

The authors close this gap by proving a conditional lower bound based on the Exponential Time Hypothesis (ETH). They construct a polynomial‑time reduction from an ETH‑hard problem—such as 3‑SAT or the k‑Clique problem—to an instance of arity‑4 Permutation CSP. The reduction proceeds in two stages. First, each variable and clause of the source problem is encoded as a “gadget” consisting of a small set of permutation variables. The relative positions of these gadgets in any feasible ordering encode the truth assignment of the original variables and the satisfaction status of the clauses. Second, the authors introduce 4‑element constraints that tie the gadgets together, enforcing that the ordering respects the logical dependencies of the source instance. A typical constraint has the form (v₁, v₂, v₃, v₄) and forces a strict precedence chain among the four involved variables, thereby embedding the logical structure of the original problem into the permutation ordering.

A crucial observation is that the reduction inflates the number of permutation variables from n (the size of the original instance) to Θ(n log n). This blow‑up arises because each original variable must be represented by a binary encoding that requires O(log n) auxiliary variables. Consequently, an algorithm that solves arity‑4 Permutation CSP in time 2^{o(N log N)} (where N ≈ n log n) would translate into a 2^{o(n)} algorithm for the source ETH‑hard problem, contradicting ETH. The paper rigorously proves that the reduction preserves satisfiability, avoids constraint collisions, and can be carried out in polynomial time, thereby establishing the claimed lower bound.

The main theorem states that, unless ETH fails, no algorithm can solve arity‑4 Permutation CSP in time 2^{o(n log n)}. This result delineates a clear complexity dichotomy: arities 2 and 3 admit O*(2ⁿ) algorithms, while arity 4 already requires the full 2^{Θ(n log n)} time of exhaustive permutation enumeration (up to polynomial factors). The authors discuss the implications of this dichotomy, noting that the technique likely extends to higher arities, and they suggest future work on related constrained ordering problems such as partial orders, cyclic constraints, or parameterized versions. In summary, the paper settles a long‑standing open question by proving that arity‑4 Permutation CSP is essentially as hard as enumerating all permutations, assuming the widely believed ETH.