Coset-Generating Polymorphisms in CSP

• Coset-generating polymorphisms are ternary operations that generalize group cosets via heap identities, satisfying both Maltsev and associativity-type equations.
• They play a pivotal role in the algebraic theory of CSPs, linking the structure of relational templates to their computational tractability through polynomial-time reductions.
• While recognizing these polymorphisms is NP-complete in general, under specific promises, constructing Maltsev operations becomes feasible, highlighting a distinct complexity dichotomy.

Coset-generating polymorphisms, also known as heap operations, constitute a class of term operations of central importance in the algebraic theory of constraint satisfaction problems (CSPs) and universal algebra. A coset-generating (heap) polymorphism is a ternary operation $h : A^3 \to A$ that emulates the group-theoretic expression $h(x, y, z) = x \cdot y^{-1} \cdot z$ for some group operation $(\cdot, ^{-1}, 1)$ on $A$, possibly with respect to a structure-defining group law. The study of the existence and computability of such polymorphisms for finite relational structures is tied to both the structural theory of polymorphism clones and the computational complexity of CSPs over corresponding templates.

1. Algebraic Identities Characterizing Coset-Generating Polymorphisms

A heap operation $h : A^3 \to A$ is defined by the satisfaction of three fundamental identities:

• Maltsev identities:

$h(x, x, y) = y, \qquad h(y, x, x) = y$

• Heap (associativity-type) identity:

$h(u, x, h(v, y, w)) = h(h(u, x, v), y, w)$

For any group $(A, \cdot, ^{-1}, 1)$, the operation $h(x, y, z) = x \cdot y^{-1} \cdot z$ satisfies all three identities. The class of clone-theoretic operations defined by these identities is precisely the class of coset-generating, or heap, operations (Bodirsky et al., 31 Jan 2026).

2. Meta- and Promise Metaproblems: Decidability and Complexity

The metaproblem for coset-generating polymorphisms asks, for a given finite relational structure $\mathfrak{A} = (A; R_1, ..., R_k)$, whether there exists a ternary operation $h$ on $A$ that is a polymorphism of $\mathfrak{A}$ and satisfies the heap identities. Bodirsky and Weiß show that this metaproblem is NP-complete (Bodirsky et al., 31 Jan 2026). This resolves a question of Chen and Larose and establishes the hardness of algorithmically recognizing coset-generating polymorphisms from relational presentations.

A parametric generalization, the promise metaproblem, is introduced: Let $\Sigma_1, \Sigma_2$ be two sets of polymorphism identities (e.g., those axiomatizing Maltsev or heap operations). The promise metaproblem for $(\Sigma_1, \Sigma_2)$, analogously to promise CSPs, is to decide, for a relational structure $\mathfrak{A}$ promised to admit a polymorphism for $\Sigma_2$, whether $\mathfrak{A}$ admits a polymorphism for $\Sigma_1$. Sufficient conditions on $(\Sigma_1, \Sigma_2)$ place such problems in $\mathrm{P}$ or render them NP-hard. A key result is that if $\Sigma_1$ is the existence of a Maltsev polymorphism and $\Sigma_2$ is the existence of an abelian heap polymorphism, then the promise metaproblem is in $\mathrm{P}$—even though the individual metaproblems for either $\Sigma_1$ or $\Sigma_2$ remain outside current polynomial-time algorithms (Bodirsky et al., 31 Jan 2026).

3. Creation-Metaproblem for Maltsev Polymorphisms under Heap Promise

Let $\Sigma_H$ be the set of heap/heap identities and $\Sigma_M$ the Maltsev identities. The Creation-Metaproblem $\mathrm{PCreaMeta}(\Sigma_H, \Sigma_M)$ is, given $\mathfrak{A}$ promised to admit a heap polymorphism $h$, to either construct a Maltsev polymorphism $m$ (satisfying the two Maltsev identities and preserving all $R_i$) or correctly report that none exists (which can only happen if the promise is violated).

The principal theorem of Bodirsky–Weiß asserts:

$$\mathrm{PCreaMeta}(\Sigma_H, \Sigma_M) \in \mathrm{P} \Longleftrightarrow \text{there exists a uniform polynomial-time algorithm for CSPs on templates with a heap polymorphism.}$$

(Bodirsky et al., 31 Jan 2026)

This characterizes the tractability of constructing Maltsev polymorphisms from heap settings as being computationally equivalent to the tractability of uniform heap-CSPs. Algorithmically, under the heap promise, one reduces the construction to a polynomial number of calls to a uniform heap-CSP solver, using indicator structures, equality and singleton constraints, and self-reduction to build and pin the desired $m$. The converse—showing that uniform heap-CSP tractability implies the tractability of the promise creation-metaproblem—uses the Bulatov–Dalmau semiuniform Maltsev-CSP algorithm, bootstrapped by previously constructed Maltsev polymorphisms (Bodirsky et al., 31 Jan 2026).

4. Relation to Maltsev Polymorphisms and Algorithmic Complexity

Maltsev polymorphisms themselves are ternary operations $m$ satisfying $m(x, x, y) = y$ and $m(y, x, x) = y$. These are strictly weaker than heap operations; every heap operation is a Maltsev operation but not the reverse. The systematic study of Maltsev polymorphisms' existence and recognition algorithms is closely related. Notably, Kinne, Murali, and Rafiey (Kinne et al., 2020) provide a reduction of the Maltsev polymorphism-detection problem to a digraph list-homomorphism problem, yielding a polynomial-time recognition algorithm for Maltsev polymorphisms using the rectangle property and recursive minority elimination. Analogous characterizations and reductions are not possible for coset-generating polymorphisms due to the inherent hardness of their metaproblem as indicated above.

5. Algorithmic Approaches and Known Barriers

For relational structures with a heap polymorphism, the creation of Maltsev polymorphisms can be realized in polynomial time if, and only if, all heap-CSPs can be solved uniformly in polynomial time (i.e., there is a uniform, template-independent, polynomial-time CSP solver for heap-polymorphic templates) (Bodirsky et al., 31 Jan 2026). The process involves indicator-structure constructions and the use of templates both as instance and target, together with repeated self-reductions by pinning argument values.

In contrast, the general recognition of coset-generating polymorphisms—without such promises—is NP-complete. There is currently no efficient (polynomial time) recognition or creation algorithm for heap polymorphisms for arbitrary finite structures; any improvement on this front would impact the global complexity dichotomy for CSPs whose templates admit coset-generating polymorphisms.

6. Broader Context and Significance in CSP and Universal Algebra

Coset-generating polymorphisms delineate a tractable fragment of CSPs under the algebraic dichotomy conjecture framework. The existence of such a polymorphism implies coset-structure is present in the solution space, enabling powerful algebraic reductions. The equivalence between the computational difficulty of constructing relevant Maltsev operations under heap/heap promises and the global tractability of heap-CSPs underscores the tight connection between polymorphism metaproblems and CSP complexity geography. Any negative result for the tractability of heap-CSPs precludes the extraction of a Maltsev operation even under strong structural promises, and any positive result would automatically yield uniform solution strategies for the entire class of coset-CSPs (Bodirsky et al., 31 Jan 2026).

7. Table: Complexity Landscape for Polymorphism Decision Problems

Problem	General Complexity	Efficient under Promise?
Recognize heap (coset-generating) polymorphism	NP-complete	$\mathrm{P}$ if promise + CSP tractable
Recognize Maltsev polymorphism	Polynomial time	—
Create Maltsev (under heap promise)	—	$\mathrm{P}$ if and only if uniform heap-CSP is in P

All claims and complexity classifications as stated are taken directly from the corresponding references (Bodirsky et al., 31 Jan 2026, Kinne et al., 2020).

---

In summary, coset-generating polymorphisms encapsulate a central divide in constraint satisfaction complexity and function identification. The explicit NP-completeness of heap metaproblems and the matched tractability of creation-metaproblems—conditional on the existence of uniform CSP algorithms—underline their pivotal role in the metatheory of algebraic CSP algorithms and complexity (Bodirsky et al., 31 Jan 2026, Kinne et al., 2020).