Creation-Metaproblem for Maltsev Polymorphisms

• The paper demonstrates the polynomial-time equivalence between constructing Maltsev polymorphisms and solving uniform heap-CSPs.
• It employs an indicator structure and self-reduction to enforce Maltsev identities and systematically determine operation values.
• This work clarifies that explicit polymorphism construction is the key step for CSP tractability under the heap promise.

The creation-metaproblem for Maltsev polymorphisms concerns the algorithmic construction of an explicit Maltsev polymorphism for a finite relational structure under the global promise that a more restrictive polymorphism, a heap (or coset-generating) polymorphism, exists. The topic lies at the intersection of universal algebra, computational complexity, and constraint satisfaction, and is central to understanding the tractability of constraint satisfaction problems (CSPs) under polymorphism-based algebraic conditions. A key result is the equivalence between polynomial-time solvability of the creation-metaproblem under the heap promise and the existence of a uniform polynomial-time CSP algorithm for finite structures with a heap polymorphism (Bodirsky et al., 31 Jan 2026).

1. Definitions and Formal Statement

Let $\mathcal{B}$ be a finite relational structure with domain $B$ and basic relations given explicitly. A polymorphism is a term operation $f : B^k \to B$ that preserves every basic relation in $\mathcal{B}$. A Maltsev polymorphism is a ternary operation $m : B^3 \to B$ satisfying the identities

$m(x, x, y) \approx y, \qquad m(y, x, x) \approx y.$

A heap (or coset-generating) polymorphism is a ternary operation $h : B^3 \to B$ such that

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

and

$h(u, x, h(v, y, w)) \approx h(h(u, x, v), y, w)$

which algebraically encodes associativity in the form $h(x, y, z) = x y^{-1} z$ with respect to some group structure.

The creation-metaproblem for Maltsev polymorphisms under the heap promise is as follows (Bodirsky et al., 31 Jan 2026): Given: A finite relational structure $\mathcal{B}$. Promise: $\mathcal{B}$ admits a heap polymorphism. Task: Produce an explicit Maltsev polymorphism $m: B^3 \to B$ (satisfying the Maltsev identities), or arbitrary output if the promise is false.

2. Complexity-Theoretic Characterization

The primary result is that the creation-metaproblem for Maltsev polymorphisms under the promise of a heap polymorphism is polynomial-time equivalent to the existence of a uniform polynomial-time algorithm solving CSPs for all structures with a heap polymorphism: $$\text{PCreaMeta}(\Sigma_{\mathrm{heap}}, \Sigma_{\mathrm{Maltsev}}) \in P \iff \text{Uniform-CSP}(\Sigma_{\mathrm{heap}}) \in P,$$ where $\Sigma_{\mathrm{heap}}$ is the set of heap identities, and $\Sigma_{\mathrm{Maltsev}}$ is the set of Maltsev identities (Bodirsky et al., 31 Jan 2026).

This equivalence isolates the core structural barrier to tractability in the coset/heap CSP class: the only obstacle is the explicit construction of polymorphisms.

3. Algorithmic Construction via Indicator Structures

The canonical approach for the creation-metaproblem follows the indicator-structure plus self-reduction paradigm (Bodirsky et al., 31 Jan 2026):

1. Indicator Construction:

For each triple $(a, b, c) \in B^3$, introduce a variable $x_{a, b, c}$ representing the candidate $m(a, b, c)$. Create a new CSP instance $\mathcal{B}'$ over $B$ whose constraints encode the Maltsev identities: - Enforce $m(a, a, b) = b$ and $m(b, a, a) = b$ via unary constraints.

1. Solving via Heap-CSP: Since $\mathcal{B}$ admits a heap polymorphism, one shows $\mathcal{B}'$ also admits one. Use a uniform heap-CSP algorithm to solve $\mathcal{B}'$.
2. Self-Reduction: Use standard CSP self-reduction: for each assignment of $x_{a, b, c}$, test possible values in $B$ and recursively invoke the solver to uniquely determine the value of $m(a, b, c)$.
3. Verification: After extraction, verify that $m$ indeed satisfies the Maltsev identities in $O(n^3)$ time.

The running time is polynomial in $|B|$, given that the heap-CSP solver runs in polynomial time.

4. Connections to the Uniform CSP Dichotomy and Related Work

This metaproblem is closely linked to the algebraic approach to CSP tractability via polymorphisms. Polymorphism existence often implies tractable algorithms, but the reverse need not hold uniformly unless explicit operations can be efficiently constructed. The result for the creation-metaproblem under the heap promise essentially states that the question of uniform tractability for heap-CSPs is reduced to the ability to construct the pertinent polymorphisms algorithmically.

In comparison, testing for the existence of a Maltsev polymorphism in general is polynomial-time tractable in the idempotent case (Kazda et al., 2017), relying on the path-Maltsev framework by Kazda–Valeriote. For arbitrary finite structures (not necessarily idempotent), a reduction to digraph list-homomorphism instances allows polynomial-time solution by leveraging the "rectangle property" of Maltsev polymorphisms (Kinne et al., 2020).

5. Significance and Implications

The equivalence established for the creation-metaproblem and heap-CSP tractability demarcates an exact complexity threshold. If there is a uniform polynomial-time heap-CSP algorithm, then explicit construction of Maltsev polymorphisms under the heap promise is also efficient, and vice versa. This resolves, in the context of polymorphism metaquestions, the role of computational uniformity versus existential tractability.

If $$\text{PCreaMeta}(\Sigma_{\mathrm{heap}}, \Sigma_{\mathrm{Maltsev}}) \in P$$ and a semi-uniform Maltsev solver (e.g., Bulatov–Dalmau’s algorithm) is also available, then the uniform heap-CSP tractability problem is also in $P$ (Bodirsky et al., 31 Jan 2026). This clarifies that in the coset (heap) polymorphism setting, the main complexity-theoretic challenge is not decision, but explicit construction.

6. Related Decision Problems and Counterexamples

Both the metaproblem for the existence of a heap polymorphism and for the existence of a Maltsev polymorphism, without promise, are not known to be in $P$. The creation-metaproblem achieves tractability only under the structural promise. This suggests that the heap-promise is crucial in separating hard metaquestions from those tractable via polymorphism-based algebra.

Additionally, for idempotent finite algebras, the existence of a Maltsev operation can be checked in polynomial time using localized path-based identities in the operation digraph, with an explicit algorithm explained in (Kazda et al., 2017). For general finite relational structures, a reduction to a list-homomorphism satisfaction problem suffices to solve the existence (creation) metaproblem for Maltsev polymorphisms in polynomial time (Kinne et al., 2020), though this does not provide uniformity under arbitrary heap polymorphism promises.

7. Summary Table: Creation-Metaproblems in Context

Metaproblem Type	Complexity Under Structural Promise	Reference
Creation-metaproblem for Maltsev, heap-promise	$P$ iff Uniform heap-CSP in $P$	(Bodirsky et al., 31 Jan 2026)
Maltsev existence (idempotent algebras)	$P$	(Kazda et al., 2017)
Maltsev existence (general finite structure)	$P$ via list-homomorphism reduction	(Kinne et al., 2020)
Heap (coset) polymorphism existence (no promise)	NP-complete	(Bodirsky et al., 31 Jan 2026)

The creation-metaproblem for Maltsev polymorphisms thus forms a critical bridge between CSP tractability dichotomies, algebraic metaquestions, and polymorphism explicit construction. Its resolution delineates the computational landscape for algebraic CSP algorithms under structural polymorphism promises.