$n$-permutability and linear Datalog implies symmetric Datalog

We show that if $\mathbb A$ is a core relational structure such that CSP($\mathbb A$) can be solved by a linear Datalog program, and $\mathbb A$ is $n$-permutable for some $n$, then CSP($\mathbb A$) can be solved by a symmetric Datalog program (and thus CSP($\mathbb A$) lies in deterministic logspace). At the moment, it is not known for which structures $\mathbb A$ will CSP($\mathbb A$) be solvable by a linear Datalog program. However, once somebody obtains a characterization of linear Datalog, our result immediately gives a characterization of symmetric Datalog.

💡 Research Summary

The paper investigates the interplay between two restricted forms of Datalog—linear Datalog and symmetric Datalog—and an algebraic property of relational structures known as n‑permutability. The authors focus on a finite relational structure A that is a core (i.e., every unary polymorphism of A is an automorphism). For such a structure, the non‑uniform Constraint Satisfaction Problem CSP(A) asks whether a given instance, consisting of variables and constraints drawn from the basic relations of A, admits a homomorphism into A.

Linear Datalog programs are those in which each rule’s body contains each variable at most once; they are known to be equivalent to having bounded‑pathwidth duality. Symmetric Datalog is an even more restrictive fragment where the set of rules is closed under swapping the left‑ and right‑hand sides, and any problem solvable by symmetric Datalog lies in deterministic logarithmic space (L). The central question is: under what algebraic conditions does the existence of a linear Datalog program for CSP(A) imply the existence of a symmetric Datalog program?

The algebraic condition considered is n‑permutability of the variety generated by the polymorphism algebra of A. An algebraic variety V is n‑permutable if for any two congruences α, β in any algebra of V we have α ∨ β = α ∘ β ∘ α ∘ … (n − 1 compositions). Equivalently, V admits a sequence of Hagemann‑Mitschke terms p₀,…,pₙ satisfying certain identities. When n = 2 this is the classic congruence permutability; the paper works with arbitrary n ≥ 2.

The proof proceeds in four main stages:

1. Embedding Symmetric Datalog Inside Itself (Section 3). The authors show that a symmetric Datalog program can be invoked as a sub‑routine within another symmetric Datalog program. This “nested” execution allows one to derive new CSP instances from an existing one while preserving the symmetric Datalog framework.

2. Path CSP Instances (Section 4). They introduce the notion of a path instance, where variables are arranged linearly and each constraint involves only adjacent variables. Path instances are a natural testbed because their structure is simple enough to be analyzed combinatorially, yet they capture the essential difficulty of general CSPs when combined with reductions.

3. Restrictions Imposed by n‑Permutability (Sections 5–6). Using the existence of Hagemann‑Mitschke terms, the authors prove that in any n‑permutable variety only a limited family of path instances can be “hard”. Lemma 4.5 (which relies on Ramsey theory) shows that any sufficiently long path must contain a regular sub‑pattern that can be collapsed using the Hagemann‑Mitschke identities. Consequently, for any n‑permutable A there exists a symmetric Datalog program that decides all path instances of CSP(A).

4. From Path Instances to General Instances via Linear Datalog (Section 7). Linear Datalog’s power is precisely to reduce an arbitrary CSP instance to a collection of bounded‑width (in particular, path‑like) sub‑instances. The authors combine this reduction with the symmetric Datalog solver for path instances constructed in step 3. The composition yields a symmetric Datalog program that decides CSP(A) outright.

The crucial technical bottleneck is Lemma 4.5, where a Ramsey‑type argument forces an exponential blow‑up in the size of the constructed symmetric Datalog program. The authors acknowledge that while the result is theoretically sound, the resulting program is far from practical for implementation.

The main theorem (Theorem 1.1) can be stated succinctly: If A is a core relational structure such that CSP(A) is solvable by a linear Datalog program and the variety generated by the polymorphisms of A is n‑permutable for some n, then CSP(A) is solvable by a symmetric Datalog program. As a corollary, CSP(A) lies in deterministic logspace.

The significance of this result lies in its bridging of two previously separate lines of research. Earlier work by Dalmau and Larose showed that 2‑permutability together with full Datalog solvability implies symmetric Datalog solvability. The present paper weakens the algebraic requirement (allowing any n) while strengthening the algorithmic requirement (requiring linear Datalog rather than full Datalog). Thus it identifies a new, broader class of CSPs that are guaranteed to be in L.

Finally, the authors discuss the broader program of classifying CSPs by the Datalog fragment that solves them. Since a full characterization of the structures whose CSPs are solvable by linear Datalog is still open, the theorem provides a conditional classification: once the linear‑Datalog frontier is known, the symmetric‑Datalog frontier follows immediately for all n‑permutable varieties. In particular, if it turns out that only structures whose varieties admit the Boolean type (type 3 in tame congruence theory) have bounded‑pathwidth duality, then exactly those CSPs would be in L, confirming a long‑standing conjecture. The paper thus contributes both a concrete technical result and a roadmap for future complexity classifications in the algebraic CSP framework.