## 1 Introduction

Constraint satisfaction problems (CSPs) with a single binary constraint type have an elegant mathematical formalisation using the language of graph homomorphisms. For a fixed directed graph (short: digraph) $$\mathbb {H}$$, the constraint satisfaction problem for $$\mathbb {H}$$, denoted by $$\text {CSP}(\mathbb {H})$$, is the computational problem of deciding whether a given finite digraph $$\mathbb {G}$$ admits a homomorphism to $$\mathbb {H}$$. Here, the vertices of the graph $$\mathbb {G}$$ play the role of the variables, the vertices of $$\mathbb {H}$$ play the role of the values for the variables, the edges of $$\mathbb {G}$$ are the constraint scopes, and the edges of $$\mathbb {H}$$ define the constraint relation that specifies how the constraints can be satisfied. Homomorphisms from $$\mathbb {G}$$ to $$\mathbb {H}$$ will also be called solutions for the instance $$\mathbb {G}$$ of $$\text {CSP}(\mathbb {H})$$. The CSP for $$\mathbb {H}$$ is also known as the $$\mathbb {H}$$-coloring problem.

If $$\mathbb {H}$$ is finite and symmetric, then $$\text {CSP}(\mathbb {H})$$ can be solved in polynomial time if $$\mathbb {H}$$ is bipartite or contains a loop, and is NP-complete otherwise [41]. The situation if $$\mathbb {H}$$ is a finite but not necessarily symmetric digraph is much more complicated. The Feder-Vardi dichotomy conjecture states that $$\text {CSP}(\mathbb {H})$$ is in P or NP-complete [35]. In fact, the conjecture was phrased not only for digraphs but for the corresponding computational problem for general finite relational structures. However, it is known that every CSP for a finite relational structure is polynomial-time (and even logspace) equivalent to the CSP for a finite digraph [23, 35]. The Feder-Vardi conjecture was proved in 2017 independently by Bulatov [20] and by Zhuk [71, 72]. Prior to their break-through result, the conjecture was open even if $$\mathbb {H}$$ is an orientation of a finite tree.

The description of the polynomially solvable cases in the proofs of Bulatov and of Zhuk is based on the so-called algebraic approach and phrased using polymorphisms of $$\mathbb {H}$$, i.e., edge-preserving multivariate operations on the vertex set (‘higher-dimensional symmetries’) [12]. The algebraic condition for polynomial-time tractability in the proofs of Bulatov and of Zhuk has numerous equivalent characterizations, e.g. [6, 62, 68]. Siggers was the first to show the (at the time somewhat surprising) fact that the condition can be characterized by the existence of a single, 6-ary polymorphism satisfying certain identities [68] — which can readily be tested at least for very small digraphs. This was later improved by Kearnes, Marković, and McKenzie [55] to the existence of a single 4-ary operation, commonly referred to as a Siggers polymorphism, or a pair of 3-ary operations which we will call Kearnes-Marković-McKenzie polymorphisms (for the definition, see Section 6.1). The latter is computationally the most feasible (the search space is the smallest) and thus the most suitable for our purposes. The question whether a given finite digraph $$\mathbb {H}$$ satisfies any of the equivalent characterizations of the algebraic tractability condition is decidable, but NP-hard [25].

### 1.1 Computational complexity

Several other important conjectures about the computational complexity of the constraint satisfaction problem for a fixed finite structure $$\mathbb {H}$$ with finite relational signature remain open: most notably the question for which finite structures $$\mathbb {H}$$ the problem $$\text {CSP}(\mathbb {H})$$ is in the complexity class NL (non-deterministic logspace), and for which finite structures $$\mathbb {H}$$ it is in the complexity class L (deterministic logspace). As in the case of P versus NP-hard, it appears that these questions are closely linked to central dividing lines in universal algebra, as illustrated by the following conjectures.

### Conjecture 1 (Larose and Tesson [58])

If the polymorphisms of a finite structure $$\mathbb {H}$$ with finite relational signature contain a Kearnes-Kiss chain (defined in Section 6.7), then $$\text {CSP}(\mathbb {H})$$ is in NL.

It is known that if $$\mathbb {H}$$ does not satisfy the condition from Conjecture 1, then $$\mathbb {H}$$ is hard for complexity classes that are not believed to be in NL (more details can be found in Section 6.7). Conjecture 1 is wide open and we believe it to be one of the most difficult research problems in the theory of finite-domain constraint satisfaction that remains open.

### Conjecture 2 (Egri, Larose, and Tesson [32])

If the polymorphisms of a finite structure $$\mathbb {H}$$ with finite relational signature contain a Noname chain (defined in Section 6.9) then $$\text {CSP}(\mathbb {H})$$ is in L.

Also here it is known that if $$\mathbb {H}$$ does not satisfy the condition from Conjecture 2, then $$\mathbb {H}$$ is hard for complexity classes that are not believed to be in L (more details can be found in Section 6.9).

We mention that both conjectures can equivalently be phrased by the inability to primitively positively construct in $$\mathbb {H}$$ certain finite structures that are known to be L-hard, ModpL-hard, or NL-hard (see Section 6). Kazda proved a conditional result that states that resolving the first conjecture would also provide a solution to the second [52].

Again, these conjectures are already open if $$\mathbb {H}$$ is a finite digraph, or even if $$\mathbb {H}$$ is an orientation of a finite tree. It is also known that answering the question of containment in NL for finite digraphs would also answer the question for general finite structures [23]. For orientations of finite trees, however, the question might be easier to resolve. For brevity, an orientation of a finite tree is simply called a tree in this paper and we adopt the following terminology: a digraph $$\mathbb {H}$$ is NP-hard if $$\text {CSP}(\mathbb {H})$$ is NP-hard, and tractable if $$\text {CSP}(\mathbb {H})$$ is in P. Similarly, we say that $$\mathbb {H}$$ is P-hard, NL-hard, in NL, in L, NP-complete, NL-complete, etc. if $$\text {CSP}(\mathbb {H})$$ has that property.

Unfortunately, there is no graph theoretic characterization of which trees are NP-hard. The first NP-hard tree $$\mathbb {T}$$ was found by Gutjahr, Welzl, and Woeginger and had 287 vertices [39]. This was later improved by Gutjahr to a smaller NP-hard tree with 81 vertices [38], and then to an NP-hard tree with just 45 vertices by Hell, Nešetřil, and Zhu [40]. The tree $$\mathbb {T}$$ constructed there is even a triad, i.e., a tree with exactly one vertex of degree three and all other vertices of degree one or two. An NP-hard triad with 39 vertices was found by Barto, Kozik, Maróti, and Niven [8, 9] using an in-depth analysis of the polymorphisms of triads; they conjectured that their triad is the smallest NP-hard tree (assuming P≠NP). This approach lead to a study of certain classes of trees [4, 22]. Fischer [36] used a computer search and found an NP-hard tree with just 30 vertices (refuting the conjecture of Barto et al. mentioned above). Later, independently, Tatarko constructed a 26-vertex NP-hard triad, by manual analysis of polymorphisms. See Table 1.

### 1.2 Descriptive complexity

Besides the computational complexity of CSPs, the descriptive complexity of CSPs has been studied intensively, and leads to a fruitful interplay of finite model theory, graph theory, and universal algebra. Since the results obtained in this context are highly relevant for the open conjectures mentioned above, we provide a brief introduction to the most prominent concepts. A digraph $$\mathbb {H}$$ has tree duality if for all finite digraphs $$\mathbb {G}$$, if whenever all trees that map homomorphically to $$\mathbb {G}$$ also map to $$\mathbb {H}$$, then $$\mathbb {G}$$ maps to $$\mathbb {H}$$. It is well known that a finite digraph $$\mathbb {H}$$ has tree duality if and only if the so-called arc-consistency procedure solves $$\text {CSP}(\mathbb {H})$$ [35]. This procedure is of central importance to our work, for many independent reasons that we mention later, and will be introduced in detail in Section 2.1.

For every finite digraph $$\mathbb {H}$$, the arc-consistency procedure for $$\text {CSP}(\mathbb {H})$$ can be formulated as a Datalog program [35]; Datalog is the fragment of Prolog where function symbols are forbidden. Every Datalog program can be evaluated in polynomial time. Feder and Vardi proved that $$\text {CSP}(\mathbb {H})$$ can be solved by Datalog if and only if $$\mathbb {H}$$ has so-called bounded treewidth duality; the definition of this concept is similar to the concept of tree duality but we omit it since it is not needed in this article. Bounded treewidth duality can be strengthened to bounded pathwidth duality, which corresponds precisely to solvability by a natural fragment of Datalog, namely linear Datalog [27]. Linear Datalog programs can be evaluated in NL. An even more restricted fragment of Datalog is linear symmetric Datalog; such programs can be evaluated in L [32].

A structure $$\mathbb {H}$$ has the ability to count [59] if $$\text {CSP}(\mathbb {H})$$ can encode, in some natural sense (namely pp-constructibility [12, 13]), solving systems of linear equations over $$\mathbb Z_{p}$$ (for some prime p); thus making $$\text {CSP}(\mathbb {H})$$ ModpL-hard. The ability to count adds substantial complexity to the CSP. Structures that cannot count (i.e., that lack the ability to count) are all tractable and even in Datalog [5, 18] and this result, known as the bounded width theorem, was an important intermediate step towards the resolution of the Feder-Vardi CSP dichotomy conjecture. Based on this theorem, the lack of the ability to count has a number of equivalent characterizations: bounded width, bounded treewidth duality, definability in Datalog, solvability by Singleton Arc Consistency [56].

Several important classes of structures exhibit a dichotomy between NP-hardness and the lack of the ability to count (assuming P≠NP), which we will refer to as “easy structures cannot count”. Examples include undirected graphs [41], smooth digraphs (digraphs without sources and sinks) [10], conservative digraphs (digraphs expanded with all subsets of vertices as unary relations) [45], binary conservative structures (even 3-conservative) [53]. We note that this phenomenon also occurs for many large classes of infinite structures $$\mathbb {H}$$: for example for all first-order expansions of the basic relations of RCC5 [15]; see [16] for a survey on the question of which infinite-domain CSPs can be solved in Datalog. In this paper, however, we only consider finite structures. Additionally, for classes of finite structures, if the easy structures in the class cannot count, then the algebraic tractability condition for that class can be tested in polynomial time [25].

In [22] Bulín conjectured that ‘easy trees cannot count’ (i.e., only NP-hard trees possess the ability to count) and showed that this conjecture held for a large yet structurally limited subclass of trees.

### Conjecture 3

Let $$\mathbb {T}$$ be a tree. If $$\mathbb {T}$$ has the ability to count, then $$\mathbb {T}$$ is NP-hard.

This conjecture (which is a rephrasing of Conjecture 2 in [22]) would answer an open question posed by Hell, Nešetřil, and Zhu [44] (Open Problem 1 at the end of the article): they asked whether there exists a tractable tree which does not have bounded treewidth duality.

### 1.3 Contributions

In this article, we continue the research program of systematic, computer-based investigation and classification of the complexity of CSPs by encoding conditions ensuring tractability as constraint problems via the so-called indicator construction [48]. This program was initiated in [37]; our approach is more directly influenced by [25] but builds upon recent developments of the algebraic theory. We obtain the following results.

1. 1.

We find 36 NP-hard trees with 20 vertices; moreover, we prove that all smaller trees and all other trees with 20 vertices are tractable.

2. 2.

We find four NP-hard triads with 22 vertices, and prove that all smaller triads and all other triads with 22 vertices are tractable.

3. 3.

We show that all the trees with at most 20 vertices that are not NP-hard can be solved by Datalog, confirming Conjecture 3 for trees with at most 20 vertices.

4. 4.

We find a tree with 19 vertices that can not be solved by arc consistency, and prove that all smaller trees and all other trees with 19 vertices can be solved by arc consistency.

5. 5.

We find 8 NL-hard trees with 12 vertices; moreover, we prove that all smaller trees and all other trees with 12 vertices are in L.

Even though we draw from the results of the universal-algebraic approach to the CSP which led to the theorems of Bulatov and of Zhuk, and use state-of-the-art computers for our computations, these tasks remain challenging due to the huge number of trees: for example, even considered up to isomorphism, there are 139,354,922,608 trees with 20 vertices (see Table 3), which is prohibitive even if we could test the algebraic tractability condition within milliseconds. Several further contributions of this article are related to the way we managed to overcome these difficulties.

A well-known key simplification is to only consider trees that are cores; a digraph $$\mathbb {H}$$ is a core if every homomorphism from $$\mathbb {H}$$ to $$\mathbb {H}$$ is injective. Two graphs $$\mathbb {H}_{1}$$ and $$\mathbb {H}_{2}$$ are called homomorphically equivalent if there is a homomorphism from $$\mathbb {H}_{1}$$ to $$\mathbb {H}_{2}$$ and vice versa. Clearly, in that case $$\text {CSP}(\mathbb {H}_{1})=\text {CSP}(\mathbb {H}_{2})$$ and so $$\mathbb {H}_{1},\mathbb {H}_{2}$$ are either both tractable or both NP-hard. It is easy to see that every finite digraph $$\mathbb {H}$$ is homomorphically equivalent to a core digraph $$\mathbb {H}^{\prime }$$, which is unique up to isomorphism [42]. Moreover, if $$\mathbb {H}$$ is a tree, then $$\mathbb {H}^{\prime }$$ is a tree as well (and its size is at most the size of $$\mathbb {H}$$). Hence, it suffices to work with trees that are cores. Hell and Nešetřil proved that deciding whether a given digraph is a core is coNP-complete [42]. However, it follows from a result of Chen and Mengel [26] (Lemma 25) that for trees this problem can be decided in polynomial time. Our next result provides a more efficient algorithm for the same task and remarkably seems to be unnoticed in the literature.

1. 6.

A single execution of the arc consistency procedure can be used to decide whether a given tree is a core.

There are far too many trees with at most 20 vertices to run the core test on each of them. Our next contribution is a method to generate the core trees more directly, rather than generating all trees and then discarding the non-cores (the details can be found in Section 4). Applying our method we were able to construct all trees that are cores up to size 20, and all triads that are cores up to size 22, which was essential to achieve the results 1.-5. above.

1. 7.

We computed the number of trees that are cores for sizes up to 20 (see Table 3). In particular, there are 779268 core trees of size 20.

These are still too many to be tested for the algebraic tractability condition if this is implemented naively. We therefore use results from the universal algebraic approach to first run more efficient tests for certain sufficient conditions, such as the existence of a binary symmetric polymorphism, and only run the full test for Kearnes-Marković-McKenzie polymorphisms if the simpler conditions all fail; this will be explained in Section 6.

Finally, we identify trees that are important ‘test-cases’ for the open problems that have been mentioned earlier.

1. 8.

We computed the two smallest trees that are not known to be in NL; they have 16 vertices, and they are the smallest trees that do not have a majority polymorphism.

2. 9.

We computed 28 smallest trees that are candidates for failing the condition in Conjecture 1 and hence might be P-hard (and that are thus candidates for not being in NL, unless NL = P); they have 18 vertices.

### 1.4 Outline of the article

Basic notation and terminology about directed and undirected graphs and homomorphisms is introduced in Section 2. This section also presents a brief description of the arc-consistency procedure which plays an important role in several of our results. In Section 3 we explain how to use the arc-consistency procedure to efficiently test whether a given tree is a core. In Section 4 we present our method to generate all trees that are cores (directly, without having to discard too many non-cores in the process). We then use these trees to make extensive experiments about their computational and descriptive complexity. For this, we need to introduce important polymorphism conditions and related facts from universal algebra (Sections 5 and 6). Finally, the results of our experiments as announced in Section 1.3 can be found in Section 7.

## 2 Graphs, digraphs, homomorphisms

For the definition of relational structure we refer to any text-book in mathematical logic; note that we allow the signature of structures to be infinite (but the constraint satisfaction problem is only defined for relational structures with finite relational signature). Since we work most of the time with digraphs, we present the basic definitions only for digraphs; most of them generalize to relational structures in a straightforward way. We use standard terminology for graphs and undirected graphs as introduced e.g. in [31]. All graphs we consider are finite. A digraph is a pair $$\mathbb {H} = (H;E)$$ where H is a nonempty set and $$E=E(\mathbb {H}) \subseteq H^{2}$$ is a set of (directed) edges. A (simple, undirected) graph is a pair $$\mathbb {H} = (H;E)$$ where H is a nonempty set and $$E=E(\mathbb {H}) \subseteq {H \choose 2}$$ is a set of two-element subsets of H. An orientation of a graph $$\mathbb {G}$$ is a digraph $$\mathbb {O}$$ such that O = G, $$(x,y) \in E(\mathbb {O})$$ implies $$\{x,y\} \in E(\mathbb {G})$$, and for every $$\{x,y\} \in E(\mathbb {G})$$ either $$(x,y) \in E(\mathbb {O})$$ or $$(y,x) \in E(\mathbb {O})$$, but not both. If $$\mathbb {H}$$ is a digraph, then the reverse of $$\mathbb {H}$$ is the digraph $$\mathbb {H}^{R} = (H;E^{R})$$ where ER = {(y,x)∣(x,y) ∈ E}. The operation that obtains $$\mathbb {H}^{R}$$ from $$\mathbb {H}$$ is called edge reversal.

If $$\mathbb {G}$$ and $$\mathbb {H}$$ are digraphs, then a homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$ is a map h: GH such that for all $$(x,y) \in E(\mathbb {G})$$ we have $$(h(x),h(y)) \in E(\mathbb {H})$$. We write $$\text {CSP}(\mathbb {H})$$ (for constraint satisfaction problem) for the class of all finite digraphs $$\mathbb {G}$$ which admit a homomorphism to $$\mathbb {H}$$. A homomorphism from $$\mathbb {H}$$ to $$\mathbb {H}$$ is called an endomorphism of $$\mathbb {H}$$. A finite digraph $$\mathbb {H}$$ is called a core if all endomorphisms of $$\mathbb {H}$$ are injective. It is easy to see that an injective endomorphism of $$\mathbb {H}$$ must in fact be bijective and an automorphism, i.e., an isomorphism between $$\mathbb {H}$$ and $$\mathbb {H}$$. It is easy to see that every finite digraph $$\mathbb {G}$$ is homomorphically equivalent to a finite core digraph $$\mathbb {H}$$, and that this core digraph is unique up to isomorphism [43], hence $$\mathbb {H}$$ will be called the core of $$\mathbb {G}$$.

An undirected tree is a connected undirected graph without cycles. If u,vT and $$\mathbb {T}$$ is an undirected tree, then there exists a unique path $$\mathbb {P}$$ from u to v in $$\mathbb {T}$$; the number of edges of $$\mathbb {P}$$ is denoted by dist(u,v). A vertex vT is called a center of $$\mathbb {T}$$ if v lies in the middle of a longest path in $$\mathbb {T}$$. An edge $$e\in E(\mathbb {T})$$ is called a bicenter of $$\mathbb {T}$$ if e is the middle edge of a longest path in $$\mathbb {T}$$. We will use the following classical result.

### Theorem 1 (Jordan (1869))

An undirected tree $$\mathbb {T}$$ has exactly one center or one bicenter.

If $$\mathbb {O}$$ is an orientation of a tree and u,vO, then dist(u,v) (center of $$\mathbb {O}$$, bicenter $$\mathbb {O}$$) is meant with respect to the underlying undirected tree. As mentioned in the introduction in this article an orientation of a finite tree will simply be called a tree. A digraph $$\mathbb {H}$$ is balanced if its vertices can be organized into levels, that is, there exists a function $$\text {lvl} \colon H\to \mathbb N$$ such that lvl(v) = lvl(u) + 1 for all $$(u,v)\in E(\mathbb {H})$$ and the smallest level is 0. The height of $$\mathbb {H}$$ is the maximum level. Note that trees are balanced and observe that if $$\mathbb {G}$$ and $$\mathbb {H}$$ are balanced of the same height, and $$\mathbb {G}$$ is connected, then any homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$ must preserve levels, that is, lvl(v) = lvl(h(v)) for all vG. A rooted tree is a tuple $$(\mathbb {T},r)$$, where $$\mathbb {T}$$ is a tree and rT; r is then called the root of $$\mathbb {T}$$. A rooted tree $$(\mathbb {T},r)$$ is called a rooted core if every endomorphism of $$\mathbb {T}$$ that fixes r is injective. The depth of a rooted tree $$(\mathbb {T},r)$$ is $$\max \limits \{\text {dist}(r,v)\mid v \in T\}$$.

### 2.1 The arc-consistency procedure

One of the most efficient algorithms employed by constraint solvers to reduce the search space is the arc-consistency procedure. In the graph homomorphism literature, the algorithm is sometimes called the consistency check algorithm. The arc-consistency procedure is important for us for several reasons:

• It plays a crucial role for efficiently deciding whether a given tree is a core (Section 3).

• It is well suited for combination with exhaustive search to prune the search space, and this will be relevant in Section 5.

• It is an important fragment of Datalog of independent interest from the point of view of the CSP theory (see Section 6.5), and we will later perform experiments to compute the smallest tree that cannot be solved by arc consistency (Section 7.1.4).

We need to give a short description of the procedure.

Let $$\mathbb {G}$$ and $$\mathbb {H}$$ be finite digraphs. We would like to determine whether there exists a homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$. The idea of the arc-consistency procedure is to maintain for each xG a set $$L(x) \subseteq H$$. Informally, each element of L(x) represents a candidate for an image of x under a homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$. The algorithm initializes each list L(x) with H and successively removes vertices from these lists; it only removes a vertex uH from L(x) if there is no homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$ that maps x to u. To detect vertices x,u such that u can be removed from L(x), the algorithm uses two rules (in fact, one rule and a symmetric version of the same rule): if $$(x,y) \in E(\mathbb {G})$$, then

$$\begin{array}{@{}rcl@{}} \text{remove} \textit{u} \text{from} L(x) \text{if there is no} v \in L(y) \text{with} (u,v) \in E(\mathbb{H});\\ \text{remove} \textit{v} \text{from} L(y) \text{if there is no} u \in L(x) \text{with} (u,v) \in E(\mathbb{H}). \end{array}$$

If eventually we cannot remove any vertex from any list with these rules any more, the digraph $$\mathbb {G}$$ together with the lists for each vertex is called arc-consistent. Note that formally we may view L as a function L: G → 2H from the vertices of $$\mathbb {G}$$ to sets of vertices of $$\mathbb {H}$$.

Note that we may run the algorithm also on digraphs $$\mathbb {G}$$ where for some xG the list L(x) is already set to some subset of H. In this setting, the input consists of $$\mathbb {G}$$ and the given lists, and we are looking for a homomorphism h from $$\mathbb {G}$$ to $$\mathbb {H}$$ such that for every xG we have h(x) ∈ L(x). The pseudocode of the entire arc-consistency procedure is displayed in Algorithm 1. The standard arc-consistency procedure $$\text {AC}_{\mathbb {H}}(\mathbb {G})$$ is then obtained by calling $$\text {AC}_{\mathbb {H}}(\mathbb {G},L)$$ with L(x) := H for all xG.

Clearly, if the algorithm removes all vertices from one of the lists, then there is no homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$. It follows that if $$\text {AC}_{\mathbb {H}}$$ rejects $$\mathbb {G}$$, then there is no homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$. The converse implication does not hold in general. For instance, let $$\mathbb {H}$$ be the loopless digraph with two vertices and two edges, denoted $$\mathbb {K}_{2}$$, and let $$\mathbb {G}$$ be $$\mathbb {K}_{3} = (\{0,1,2\};\neq )$$. In this case, $$\text {AC}_{\mathbb {H}}$$ does not remove any vertex from any list, but obviously there is no homomorphism from $$\mathbb {K}_{3}$$ to $$\mathbb {K}_{2}$$.

The arc-consistency procedure can be implemented so that it runs in $$O(|E(\mathbb {G})| \cdot |H|^{3})$$, e.g. by Mackworth’s AC-3 algorithm [61].

## 3 Cores of trees

Recall that the problem of deciding whether a given digraph is a core is coNP-complete [42]. The following theorem implies that whether a given finite tree is a core can be tested in polynomial time.

### Theorem 2

Let $$\mathbb {T}$$ be a finite tree. Then the following are equivalent.

1. 1.

$$\mathbb {T}$$ is a core;

2. 2.

$$\text {End}(\mathbb {T}) = \{\text {id}_{T}\}$$;

3. 3.

$$\text {AC}_{\mathbb {T}}(\mathbb {T})$$ terminates such that the list for each vertex contains a single element.

### Corollary 3

There is a polynomial-time algorithm to decide whether a given finite tree is a core.

We first prove the following two useful lemmata.

### Lemma 4

Let $$\mathbb {T}$$ be a finite tree and let $$\mathbb {H}$$ be a finite digraph such that $$\text {AC}_{\mathbb {H}}(\mathbb {T})$$ does not reject. Let tT, and let aH be such that aL(t) after running $$\text {AC}_{\mathbb {H}}(\mathbb {T})$$. Then there is a homomorphism $$h\colon \mathbb {T}\to \mathbb {H}$$ such that h(t) = a.

### Proof

Let S be a maximal subtree of $$\mathbb {T}$$ such that tS and there exists a partial homomorphism $$h\colon S\to \mathbb {H}$$ with h(t) = a. If ST, then there exists xS and yTS such that either (x,y) or (y,x) is an edge in $$\mathbb {T}$$; without loss of generality assume that $$(x,y)\in E(\mathbb {T})$$. Because the value u = h(x) was not removed from L(x) when running $$\text {AC}_{\mathbb {H}}(\mathbb {T})$$, it follows that there exists vL(y) such that $$(u,v)\in E(\mathbb {H})$$. But then setting h(y) = v extends h to a partial homomorphism from S ∪{y} to $$\mathbb {H}$$ contradicting maximality of the subtree S. □

### Lemma 5

Let $$(\mathbb {T},r)$$ be a rooted tree with an automorphism that is not the identity. Then $$(\mathbb {T},r)$$ has a non-injective endomorphism.

### Proof

Let h be an automorphism of $$(\mathbb {T},r)$$ that is not the identity. We prove the statement by induction on the number of vertices of $$\mathbb {T}$$. Consider the components of the graph obtained from $$\mathbb {T}$$ by deleting r. If there is a component C such that h does not map C into itself, then the mapping which agrees with h on C and which fixes all other vertices of $$\mathbb {T}$$ is a non-injective endomorphism of $$(\mathbb {T},r)$$.

If each component C is mapped by h into itself, then each h|C is an automorphism of (C,rC), where rC is the unique neighbor of r that lies in C. Since h is not idT there must be some C such that h|C is not idC and by the induction hypothesis there exists a non-injective endomorphism $$h^{\prime }$$ of (C,rC). Since $$h^{\prime }(r_{C})=r_{C}$$ the mapping which extends $$h^{\prime }$$ to T by fixing all other vertices of $$\mathbb {T}$$ is a non-injective endomorphism of $$(\mathbb {T},r)$$. □

### Proof Proof of Theorem 2

We prove the equivalence of 1. and 2., and then the equivalence of 2. and 3.

Clearly, 2. implies 1. Conversely, suppose that $$\mathbb {T}$$ has an endomorphism h which is not the identity map. If h is not injective, then $$\mathbb {T}$$ is not a core and we are done. Hence, suppose that h is an automorphism. Note that by Theorem 1, if $$\mathbb {T}$$ has a center cT, then h(c) = c and if $$\mathbb {T}$$ has a bicenter $$(x,y) \in E(\mathbb {T})$$, then h({x,y}) = {x,y}. In the latter case, since $$(y,x)\notin E(\mathbb {T})$$, we must have h(x) = x and h(y) = y. In both cases h has a fixed point r and h is an automorphism of $$(\mathbb {T},r)$$. By Lemma 5, $$\mathbb {T}$$ has a non-injective endomorphism and is therefore not a core.

To prove that 2. implies 3., we prove the contrapositive. Suppose that $$\text {AC}_{\mathbb {T}}(\mathbb {T})$$ terminates with |L(x)| > 1 for some xT. Then there exists yL(x) with yx. Lemma 4 implies that there is an endomorphism h of $$\mathbb {T}$$ such that h(x) = y and thus h≠idT.

To see that 3. implies 2., note that L(x) = {x} since because of the identity endomorphism idT, x cannot be removed from L(x). Therefore, for any endomorphism $$h\colon \mathbb {T}\to \mathbb {T}$$ and any xT we must have h(x) ∈ L(x), and so h(x) = x and h = idT. □

## 4 Generating all core trees

In this section we present an algorithm to generate all core trees with n vertices up to isomorphism. To this end, we first present a known algorithm that generates all trees with n vertices up to isomorphism [70]. Later we explain how to modify this algorithm to directly generate core trees.

We also refer to the isomorphism classes of trees as unlabeled trees, as opposed to labeled trees, which are trees with vertex set $$\{1,\dots ,n\}$$ for some $$n \in {\mathbb {N}}$$. The difference between the enumeration of labelled and unlabeled trees is significant: while the number of labelled trees is Sloane’s integer sequence A097629, given by 2(2n)n− 2, the number of unlabeled trees is Sloane’s integer sequence A000238, which grows asymptotically as cdn/n5/2 where d ≈ 5.6465 and c ≈ 0.2257 are constants; the initial terms are shown in Table 3. However, these numbers are still too large to apply the core test to all the unlabeled trees separately. The number of unlabeled trees that are cores is again much smaller. We therefore present a modification of the generation algorithms that allows us to generate unlabeled trees that are cores directly without enumerating all unlabeled trees.

Let ≥ be some total order on all rooted trees that linearly extends the order by depth. The idea of the algorithm is to generate all unlabeled rooted trees with at most n − 1 vertices and then use Theorem 1.

It is easy to verify that Algorithm 3 produces all unlabeled rooted trees with n vertices and depth d. Analogously, Algorithm 2 generates all unlabeled trees with n vertices. Remarkably, there are no isomorphism checks necessary and Algorithm 2 runs in linear time in the number of unlabeled trees with n vertices plus the number of unlabeled rooted trees with at most n − 1 vertices.

Let us make some observations. Let $$(\mathbb {T}_{1},r_{1})\geq \dots \geq (\mathbb {T}_{m},r_{m})$$ be rooted trees, s ∈{0,1}m, $$T := \{r\}\uplus T_{1}\uplus \dots \uplus T_{m}$$, and $$E := \{(r_{i},r)\mid s_{i}=1\}\uplus \{(r,r_{i})\mid s_{i}=0\}\uplus E(\mathbb {T}_{1})\uplus \dots \uplus E(\mathbb {T}_{m})$$.

• A rooted tree $$(\mathbb {T},r)$$ is a rooted core if and only if $$\text {AC}_{\mathbb {T}}(\mathbb {T},L)$$, where L(r) = {r} and L(x) = T for xT ∖{r}, terminates such that the list for each vertex contains a single element.

• By Corollary 3, testing whether a (rooted) tree is a (rooted) core can be checked in polynomial time using the arc-consistency procedure.

• If $$(\mathbb {T},r)$$ is a rooted core, then $$(\mathbb {T}_{i},r_{i})$$ is a rooted core for every i.

• If $$\mathbb {T}$$ is a core and r is its center, then $$(\mathbb {T}_{i},r_{i})$$ is a rooted core for every i.

• If $$(T_{1}\uplus T_{2};\{(r_{1},r_{2})\}\uplus E(\mathbb {T}_{1})\uplus E(\mathbb {T}_{2}))$$ is a core and (r1,r2) is its bicenter, then $$(\mathbb {T}_{1},r_{1})$$ and $$(\mathbb {T}_{2},r_{2})$$ are rooted cores.

• If two trees that are cores are homomorphically equivalent, then they are isomorphic.

To generate all oriented trees that are cores we slightly modify both algorithms. In both functions we only add trees to the output if they are cores or rooted cores, respectively. By the above observations, these modified algorithms generate each tree with n vertices that is a core exactly once. We do not know whether our algorithm is a polynomial-delay generation procedure for unlabeled core trees. In practice, it is fast enough to generate all core trees with at most 20 vertices within reasonable time (see Section 7).

## 5 Polymorphism conditions

In this section we introduce basic facts from the universal-algebraic approach that are essential for obtaining our results. If $$\mathbb {H}$$ is a digraph and k ≥ 1 is an integer, then $$\mathbb {H}^{k}$$ denotes the k-th categorical power of $$\mathbb {H}$$, i.e., the digraph with vertex set Hk and edge set

$$\{((u_{1},\dots,u_{k}),(v_{1},\dots,v_{k})) \mid (u_{1},v_{1}),\dots,(u_{k},v_{k}) \in E(\mathbb{H}) \}.$$

A polymorphism of $$\mathbb {H}$$ is a homomorphism from $$\mathbb {H}^{k}$$ to $$\mathbb {H}$$, for some k ≥ 1. Clearly, every projection, i.e., every operation of the form $$(x_{1},\dots ,x_{k}) \mapsto x_{i}$$, for some fixed ik, is a polymorphism for every digraph $$\mathbb {H}$$. Of particular interest to us will be polymorphisms that satisfy certain sets of identities, introduced in Section 5.2. The connection between such identities and computational complexity is described in Section 5.1.

### 5.1 Primitive positive constructions

Primitive positive definitions are a natural type of gadget construction which can be used to obtain logspace reductions between CSPs (see, e.g., Lemma 1.2.6 in [14]). Central to the algebraic theory of the CSP is the fact that the possibility of such an encoding can be determined from the polymorphisms of the respective templates. Let $$\mathbb {A} = (A;R_{1},\dots ,R_{n})$$ be a relational structure. A relation $$S\subseteq A^{n}$$ is primitive positive (pp-) definable from $$\mathbb {A}$$ if it can be defined (without parameters) by a first order formula which only uses the predicate symbols $$R_{1},\dots ,R_{n}$$, the equality predicate, conjunction, and existential quantification.

Primitive positive constructions are a more powerful generalization of primitive positive definitions. A relational structure $$\mathbb {B}=(B;S_{1},\dots ,S_{m})$$ is pp-constructible from $$\mathbb {A}$$ if there exists k > 0 and a structure $$\mathbb {B}^{\prime }=(B^{\prime };S^{\prime }_{1},\dots ,S^{\prime }_{m})$$ which is homomorphically equivalent to $$\mathbb {B}$$ such that $$B^{\prime }=A^{k}$$ and for every $$i\in \{1,\dots ,m\}$$ the relation $$S_{i}\subseteq {B^{\prime }}^{r_{i}}$$, when considered as a kri-ary relation on A, is pp-definable from $$\mathbb {A}$$. In this case there is a logspace reduction from $$\text {CSP}(\mathbb {B})$$ to $$\text {CSP}(\mathbb {A})$$ (see, e.g., [13, 21]).

If $$\mathbb {A}$$ and $$\mathbb {B}$$ are finite structures, then $$\mathbb {B}$$ is pp-constructible from $$\mathbb {A}$$ if and only if $$\mathbb {B}$$ satisfies every height-one condition satisfied by $$\mathbb {A}$$; these concepts will be introduced in the next section. This algebraic characterization of pp-constructibility was shown in [13, Theorem 1.3, Corollary 4.7] (see also [12, Theorem 38, Corollary 20]).

### 5.2 Linear conditions and height-one conditions

Height-one conditions and linear conditions are particular types of strong Maltsev condition [54] that are essential for the algebraic approach to CSPs. If f is a function symbol of arity k and h is a function symbol of arity , and $$\sigma \colon \{1,\dots ,k\} \to \{1,\dots ,n\}$$ and $$\rho \colon \{1,\dots ,\ell \} \to \{1,\dots ,n\}$$ are functions, then an expression of the form

$$f(x_{\sigma(1)},\dots,x_{\sigma(k)}) \approx g(x_{\rho(1)},\dots,x_{\rho(\ell)})$$

is called a height-one identity. For the purposes of this paper, a finite set of height-one identities will be called a height-one condition. Height-one conditions are important because of the mentioned tight link with pp-constructibility (Section 5.1). More generally, an identity is linear if each side has one or zero occurrences of function symbols, i.e., it is either height-one, or of the form $$f(x_{\sigma (1)},\dots ,x_{\sigma (k)}) \approx x_{j}$$, $$x_{i}\approx g(x_{\rho (1)},\dots ,x_{\rho (\ell )})$$, or xixj. Then a linear condition is a finite set of linear identities.

A set of operations $$\mathcal F$$ on some domain D satisfies a linear condition Σ if we can interpret every function symbol appearing in Σ as an operation from $$\mathcal F$$ so that for every identity in Σ, the left-hand side of the identity and the right-hand side of the identity evaluate to the same element under all possible substitutions of variables by elements of D. We say that a structure $$\mathbb {A}$$ satisfies a linear condition if the set of all polymorphisms of $$\mathbb {A}$$ satisfies it.

An example of a height-one condition consisting of a single height-one identity involving a single binary function symbol f is

$$\{f(x_{1},x_{2}) \approx f(x_{2},x_{1}) \}$$

which is satisfied by $$\mathbb {A}$$ if and only if $$\mathbb {A}$$ has a binary symmetric polymorphism. Since $$x_{1},x_{2},x_{3},\dots$$ are just variable names we sometimes use x,y,z, etc. instead.

An operation f : DkD is called idempotent if it satisfies the identity $$f(x,\dots ,x) \approx x$$. Note that this identity is linear but not height-one.

### Remark 6

It is well known and easy to see that the polymorphisms of a finite core digraph satisfy a height-one condition if and only if its idempotent polymorphisms satisfy the condition: if f is a polymorphism of a core digraph $$\mathbb {H}$$, then $$f(x,\dots ,x)$$ must be an automorphism of $$\mathbb {H}$$; let i be its inverse. Then $$(x_{1},\dots ,x_{n}) \mapsto i(f(x_{1},\dots ,x_{n}))$$ is an idempotent polymorphism of $$\mathbb {H}$$ that satisfies the same height-one identities as f. The argument for conditions involving more than one height-one identity is analogous.

Linear conditions have been introduced and studied first, in particular motivated by the fact that idempotence of operations can only be expressed in linear conditions, but not in height one conditions, and that idempotence plays a central role in many classical areas of universal algebra. Also note that in the setting of finite-domain CSPs we may use the idempotence assumption for free because of Remark 6 and the fact that the core of a structure has an equivalent CSP (indeed, the set of YES instances is exactly the same) and satisfies the same height-one identities (which is not true for linear conditions in general).

### 5.3 The indicator construction

The question whether a given digraph $$\mathbb {H}$$ has polymorphisms that satisfy a given height-one or even linear condition can be tested algorithmically; this is well-known, see, e.g., [25]. To illustrate the idea, suppose that the given set consists of a single identity, namely f(x,y) ≈ f(y,x). We then compute $$\mathbb {H}^{2}$$ and identify every vertex of $$\mathbb {H}^{2}$$ of the form (x,y) with the vertex (y,x). The resulting digraph $${\mathbb {H}^{\text {Ind}}}$$ will be called the indicator digraph for the height-one condition. We finally search for a homomorphism from $$\mathbb {H}^{\text {Ind}}$$ to $$\mathbb {H}$$. Note that $$\mathbb {H}^{\text {Ind}}$$ may be viewed as an instance of $$\text {CSP}(\mathbb {H})$$, and that the homomorphisms from $$\mathbb {H}^{\text {Ind}}$$ to $$\mathbb {H}$$ are in 1-1 correspondence with the binary symmetric polymorphisms of $$\mathbb {H}$$ (see Definition 9).

Analogously we may proceed for any other height-one condition: to compute $$\mathbb {H}^{\text {Ind}}$$, we construct for each function symbol the categorical power of $$\mathbb {H}$$ of the corresponding arity, take their disjoint union, and then identify vertices as dictated by the identities. Clearly, the size of the indicator digraph grows exponentially with the arity of the function symbols in the condition and linearly with number of function symbols in the condition so we generally prefer conditions where the function symbols are of low arity even if the number of function symbols is large.

Linear conditions can be tested in the following way. Note that the left- and right-hand sides of identities can be switched, and that identities of the form xixj are only satisfied in one-element structures. Therefore, we may assume that every identity is either height-one or of the form $$f(x_{\sigma (1)},\dots ,x_{\sigma (k)})\approx x_{j}$$. First, construct the indicator digraph $$\mathbb {H}^{\text {Ind}}$$ using only the height-one identities when identifying vertices. Then, for every identity that is not height-one, find every vertex of $$\mathbb {H}^{\text {Ind}}$$ that comes from a tuple of vertices of $$\mathbb {H}$$ matching the left-hand side and set its value to the vertex of $$\mathbb {H}$$ given by the right-hand side. For example, if the identity is f(x,y,x) ≈ x, we require that (a,b,a) ∈ HInd must be mapped to a, for every a,bH. In this way, we obtain an instance of the $$\mathbb {H}$$-precoloring extension problem (see also the discussion in Section 8). It is well known that for cores, this problem is logspace-equivalent to $$\text {CSP}(\mathbb {H})$$ [13, 21]. Moreover, it is particularly easy to implement within the arc-consistency procedure, see the next section. For balanced digraphs, another important improvement—based on the decomposition into levels—that can be applied for many height-one conditions is described in Section 5.5 below.

### 5.4 Arc consistency with exhaustive search

To test for the existence of polymorphisms satisfying a given linear condition, we run the arc-consistency procedure for $$\mathbb {H}$$ on the indicator digraph $$\mathbb {H}^{\text {Ind}}$$ and then perform an exhaustive search. While this procedure is not (provably) in P, it is very efficient in practice.

We initialize the lists for vertices of $$\mathbb {H}^{\text {Ind}}$$ with preset values dictated by non-height-one identities, as explained above. Additionally, for every uH, we initialize the list for every vertex of $$\mathbb {H}^{\text {Ind}}$$ of the form $$(u,\dots ,u)$$ with {u} (since it suffices to look for idempotent polymorphisms as we have explained in Remark 6 and this reduces the search space). For the remaining vertices of $$\mathbb {H}^{\text {Ind}}$$, the lists are initialized to H.

If $$\text {AC}_{\mathbb {H}}$$ detects an inconsistency, we can be sure that no polymorphisms satisfying the linear condition exist. Otherwise, we select some vertex xHInd, and set L(x) to {u} for some uL(x). Then we proceed recursively with the resulting lists. If $$\text {AC}_{\mathbb {H}}$$ now detects an empty list, we backtrack, but remove u from L(x). Finally, if the algorithm does not detect an empty list at the first level of the recursion, we end up with singleton lists for each vertex xHInd, which defines a homomorphism from $$\mathbb {H}^{\text {Ind}}$$ to $$\mathbb {H}$$. The restriction of this homomorphism to the vertices of $$\mathbb {H}^{\text {Ind}}$$ for a specific function symbol can then be interpreted as (the function table of) a polymorphism of $$\mathbb {H}$$, and these polymorphisms satisfy the linear condition.

There are numerous heuristics that often help to speed up this backtracking procedure. One of the best known is called Maintaining Arc Consistency (MAC) [66]. This family of algorithms has the arc-consistency procedure at its core and takes advantage of the incremental design of the backtracking procedure by maintaining data structures which help to reduce the number of consistency checks. Another common way to speed up the search procedure is to choose the vertex $$x \in \mathbb {H}^{\text {Ind}}$$ that has a list of smallest size.

### 5.5 Level-wise satisfiability

If $$\mathbb {H}$$ is a balanced digraph (in particular, a tree), the test from the previous section can sometimes be significantly simplified. We say that a linear condition is level-wise satisfied if we can interpret the function symbols as polymorphisms of $$\mathbb {H}$$ in such a way that for every level in $$\mathbb {H}$$, the identities are satisfied under all evaluations of variables by vertices from that level.

When testing whether a linear condition is level-wise satisfied, we do not need to construct the full indicator digraph. Instead, for every function symbol (say of arity k) we construct only the subgraph of $$\mathbb {H}^{k}$$ consisting of all same-level k-tuples (i.e., tuples in which all vertices are from the same level). Note that, since $$\mathbb {H}$$ is balanced, this subgraph is a union of connected components of $$\mathbb {H}^{k}$$ and that polymorphisms can be defined to be the first projection on the remaining connected components of $$\mathbb {H}^{k}$$.

While we do not have a general construction, for many linear conditions relevant to the complexity of the CSP we can show that if a linear condition is level-wise satisfied in $$\mathbb {H}$$, then it is satisfied in $$\mathbb {H}$$. The idea is to start with polymorphisms satisfying the identities level-wise, and then redefine those polymorphisms for tuples of vertices that are not all on the same level, in such a way as to satisfy the identities. We will introduce several such concrete constructions in the next section. Similar constructions have appeared in [4, 8, 22, 23]. This optimization is particularly useful when testing the condition TS(n) for all n; see Section 7.1.4.

## 6 Specific polymorphism conditions

In this section we focus on certain concrete linear conditions that are relevant for studying the membership of CSPs in the most prominent complexity classes in the subsequent sections. An overview of the classes and the respective linear conditions is given in Fig. 1. Solid arrows indicate implications, dotted arrows indicate conjectures. Figure 2 shows the relationships between relevant linear polymorphism conditions that are defined throughout the section. The left side shows the general case of finite-domain structures with possibly infinite signatures and the right side shows the case for trees assuming Conjecture 3 (and P≠NP). The implications are either immediate or from the literature [46] (Chapter 9), [3, 11, 55].

### 6.1 Containment in P

As discussed above, the characterization of the algebraic condition for tractability which is the most suitable for testing with a computer consists of a pair of ternary operations [55].

### Definition 7

A pair of ternary operations p,q: D3D is called Kearnes-Marković-McKenzie if it satisfies the height-one condition

$$\begin{array}{@{}rcl@{}} p(x,y,y) &\approx q(y,x,x)\approx q(x,x,y)\\ p(x,y,x)&\approx q(x,y,x). \end{array}$$

The respective height one condition is abbreviated by KMM.

Using this characterization, the CSP dichotomy can be stated as follows.

### Theorem 8 (20, 55, 72)

A finite digraph $$\mathbb {H}$$ has Kearnes-Marković-McKenzie polymorphisms if and only if there is no pp-construction of $$\mathbb {K}_{3}$$ from $$\mathbb {H}$$. In this case, $$\text {CSP}(\mathbb {H})$$ is in P.

This characterization is optimal in the following sense: every height-one condition equivalent to Kearnes-Marković-McKenzie polymorphisms involves either an operation of arity at least 4 or at least two operations of arity 3 [55]. However, there are several height-one conditions that imply the existence of Kearnes-Marković-McKenzie polymorphisms and that are easier to test. In particular, we use the following.

### Definition 9

An operation f of arity k, for k ≥ 2, is called a k-ary weak near-unanimity operation (short, k-wnu) if it satisfies the following height-one condition

$$f(y,x,\dots,x) \approx f(x,y,x,\dots,x) \approx {\cdots} \approx f(x,\dots,x,y).$$

A binary operation f is called symmetric if it is a 2-wnu, i.e., if it satisfies f(x,y) ≈ f(y,x).

It is known that the existence of a k-wnu implies the existence of Kearnes-Marković-McKenzie polymorphisms [55, 68], and that the existence of Kearnes-Marković-McKenzie polymorphisms implies the existence of a k-wnu for some k ≥ 2 [62]. Hence, in particular, if a finite digraph $$\mathbb {H}$$ has a binary symmetric polymorphism then $$\text {CSP}(\mathbb {H})$$ can be solved in polynomial time. Our results will show that the converse is false even if $$\mathbb {H}$$ is a tree, see Section 7.1.4.

For both Kearnes-Marković-McKenzie and k-wnu, it is enough to test for level-wise satisfiability as discussed in Section 5.5. We prove the following more general claim.

### Lemma 10

Let Σ be a height-one condition in two variables such that both the variables appear on each side in every identity from Σ. Then a balanced digraph level-wise satisfies Σ if and only if it satisfies Σ.

### Proof

Fix some polymorphisms $$f,\dots$$ that level-wise satisfy Σ, and define polymorphisms $$f^{\prime },\dots$$ in the following way (say f is k-ary): If $$lvl(x_{1})=lvl(x_{2})=\dots =lvl(x_{k})$$, define $$f^{\prime }(x_{1},x_{2},\dots ,x_{k})=f(x_{1},x_{2},\dots ,x_{k})$$. Else, let $$\ell =\min \limits \{lvl(x_{i})\mid 1\leq i\leq k\}$$ and define $$f^{\prime }(x_{1},x_{2},\dots ,x_{k})=x_{j}$$ where $$j\in \{1,2,\dots ,k\}$$ is the smallest index such that lvl(xj) = . To verify that the $$f^{\prime }$$s are polymorphisms, note that if (xi,yi) is an edge for $$i\in \{1,2,\dots ,k\}$$, then $$f^{\prime }(x_{1},x_{2},\dots ,x_{k})$$ and $$f^{\prime }(y_{1},y_{2},\dots ,y_{k})$$ fall under the same case of the definition. If it is the second case, xj lies on the smallest level out of {lvl(xi)∣1 ≤ ik} if and only if yj lies on the smallest level out of {lvl(yi)∣1 ≤ ik}. Hence, the selected coordinate j is the same.

Now let x,y be the two variables appearing in Σ. To see that every identity from Σ is satisfied, note that the only interesting case is when lvl(x)≠lvl(y), and $$f^{\prime }$$ then chooses the variable on the lower level. The other implication is trivial. □

### 6.2 Containment in Datalog

We have already mentioned in the introduction that containment in Datalog has numerous equivalent characterizations. In this section, we formally state one of these characterizations in terms of pp-constructibility and one in terms of height-one conditions. The structure 3Linp has the domain $$D = \{0,\dots ,p-1\}$$ where p is some prime, the relation {(x,y,z)∣x + y + z ≡ 0 (mod p)}, and the relation {x} for every xD. It is well known that CSP(3Linp) is not in Datalog [35].

### Definition 11

A 3-4 weak near-unanimity pair (short, 3-4 WNU) is a pair of operations f,g such that f is a 3-wnu, g is a 4-wnu, and they additionally satisfy the identity

$$f(x,x,y) \approx g(x,x,x,y).$$

### Theorem 12 (7, 57, see [12, Theorem 47])

Let $$\mathbb {H}$$ be a finite digraph. Then the following are equivalent.

• $$\mathbb {H}$$ can be solved by Datalog,

• there is no pp-construction of 3Linp in $$\mathbb {H}$$, for any prime p (i.e., $$\mathbb {H}$$ lacks the ability to count),

• $$\mathbb {H}$$ has a 3-4 weak near-unanimity pair of polymorphisms.

Note that by the above theorem, if Conjecture 3 is true (and assuming P ≠ NP), then every tree with Kearnes-Marković-McKenzie polymorphisms has a 3-4WNU pair of polymorphisms. In particular, it implies that every tree with KMM polymorphisms has a 3-wnu polymorphism: a claim that is weaker but still open. Also note that by Lemma 10, it is enough to test for level-wise 3-4 WNU.

### 6.3 Containment in NL

In this section we present a strong sufficient condition for the containment of $$\mathbb {H}$$ in NL.

### Definition 13

For n ≥ 0, a Jónsson chain of length n over D is a sequence of ternary operations $$j_{1},j_{2},\dots ,j_{2n+1}$$ on D that satisfy

$$\begin{array}{@{}rcl@{}} x &\approx& j_{1}(x,x,y) \\ j_{2i-1}(x,y,y) &\approx& j_{2i}(x,y,y) \qquad\qquad \text{ for all } i \in \{1,\dots,n\} \\ j_{i}(x,y,x) &\approx& x \qquad\qquad\qquad\qquad \text{ for all } i \in \{1,\dots,2n+1\} \\ j_{2i}(x,x,y) &\approx& j_{2i+1}(x,x,y) \qquad\quad \text{ for all } i \in \{1,\dots,n\} \\ j_{2n+1}(x,y,y) &\approx& y. \end{array}$$

The respective linear condition is abbreviated by J(n).

Note that J(n) implies J(n + 1) for every n ≥ 0. Also note that for n = 0 the operation j1 must be a so-called majority operation, which is the ternary case of a near-unanimity (NU) operation, that is, an operation satisfying the identities

$$x\approx f(y,x,\dots,x) \approx f(x,y,x,\dots,x) \approx {\cdots} \approx f(x,\dots,x,y).$$

The existence of a near-unanimity polymorphism characterizes bounded strict width [35]. More importantly for us, a near-unanimity polymorphism is sufficient to put $$\mathbb {H}$$ in NL, using the following two results. Barto, Kozik, and Willard proved that finite structures with finite relational signature and a near-unanimity polymorphism have bounded pathwidth duality [11]. Dalmau proved that bounded pathwidth duality implies containment in NL [28].

Barto [3] moreover proved that if a finite structure with a finite relational signature has polymorphisms that form a Jónsson chain, then it also has a near-unanimity polymorphism (albeit its arity in the proof is doubly exponential in the size of the domain). In the other direction, it is well known that NU(n) implies J(n − 2), syntactically. Therefore, we do not test for near-unanimities of arities higher than 3; it is more efficient to test for a Jónsson chain.

### Theorem 14 (3, 11, 28)

If a finite digraph $$\mathbb {H}$$ satisfies J(n) for some n ≥ 1, then $$\text {CSP}(\mathbb {H})$$ is in linear Datalog, and hence in NL.

Note that the existence of polymorphisms of $$\mathbb {H}$$ that form a Jónsson chain is only a sufficient condition for the containment of $$\text {CSP}(\mathbb {H})$$ in NL. An incomparable sufficient condition for the containment of $$\text {CSP}(\mathbb {H})$$ in NL was identified in [24]. The condition presented there also has a characterization via height-one identities, but the arities of the operations are prohibitively large so that we did not implement this test for trees.

The conjectured characterization of containment in NL, the Kearnes-Kiss chain from Conjecture 1, is defined in Section 6.7 (Definition 21).

### 6.4 Containment in L

One of the strongest known sufficient conditions for containment in L is a conditional result of Kazda, which involves the following linear condition.

### Definition 15

For n ≥ 1, a Hagemann-Mitschke chain of length n over D is a sequence of ternary operations $$p_{1},\dots ,p_{n}$$ on D that satisfy

$$\begin{array}{@{}rcl@{}} x & \approx& p_{1}(x,y,y) \\ p_{i}(x,x,y) & \approx& p_{i+1}(x,y,y) \qquad\qquad\qquad\text{ for all } i \in \{1,\dots,n-1\} \\ p_{n}(x,x,y) & \approx& y. \end{array}$$

The respective linear condition is abbreviated by HaMi(n).

Note that HaMi(n) implies HaMi(n + 1) for every n ≥ 1. For n = 1 the operation p1 is known as a Maltsev operation. Kazda [52] proved the following conditional result.

### Theorem 16 (52)

If a finite digraph $$\mathbb {H}$$ can be solved by linear Datalog, and $$\mathbb {H}$$ satisfies HaMi(n) for some n ≥ 1, then $$\mathbb {H}$$ can also be solved by linear symmetric Datalog (and hence is in L).

The conjectured characterization of containment in L, the Noname chain from Conjecture 2, is defined in Section 6.9 (Definition 24).

### 6.5 Solvability by Arc Consistency

Solvability by Arc-Consistency (and tree duality) can be characterized in terms of height one conditions as well.

### Definition 17

An operation sn: DnD is called totally symmetric if for all variables $$x_{1},\dots ,x_{n}$$ and $$y_{1},\dots ,y_{n}$$ such that $$\{x_{1},\dots ,x_{n}\} = \{y_{1},\dots ,y_{n}\}$$ the operation sn satisfies

$$s_{n}(x_{1},\dots,x_{n}) \approx s_{n}(y_{1},\dots,y_{n}).$$

The respective height one condition is abbreviated by TS(n).

The digraph $$\mathbb {H}$$ can be solved by arc consistency if and only if $$\mathbb {H}$$ has totally symmetric polymorphisms of all arities [30, 35]. Note that TS(4) implies 3-4 WNU. Also note that a finite digraph $$\mathbb {H}$$ satisfies TS(n) for all n > 0 if and only if it satisfies $$\text {TS}(2 |E(\mathbb {H})|)$$ (see the proof given in [30]). The arity $$2 |E(\mathbb {H})|$$ is still fairly large; therefore it is particularly useful that the level-wise test is sufficient.

### Lemma 18 (see [8, proof of Lemma 4.1])

For any balanced digraph $$\mathbb {H}$$ and n > 0, $$\mathbb {H}$$ level-wise satisfies TS(n) if and only if $$\mathbb {H}$$ satisfies TS(n).

### Proof

Let sn be an n-ary polymorphism of $$\mathbb {H}$$ that level-wise satisfies the condition TS(n). We can construct an n-ary totally symmetric polymorphism $$s^{\prime }_{n}$$ of $$\mathbb {H}$$ by applying sn to the set of vertices on the smallest level. That is, for an input tuple $$(x_{1},\dots ,x_{n})$$ let $$\ell =\min \limits \{\text {lvl}(x_{i})\mid 1\leq i\leq n\}$$, $$\{x_{i}\mid \text {lvl}(x_{i})=\ell \}=\{x_{i_{1}},\dots ,x_{i_{k}}\}$$, and set

$$s^{\prime}_{n}(x_{1},\dots,x_{n})=s_{n}(x_{i_{1}},\dots,x_{i_{k}},\underbrace{x_{i_{k}},\dots,x_{i_{k}}}_{(n-k)\text{ times}}).$$

Clearly, the definition of $$s^{\prime }_{n}(x_{1},\dots ,x_{n})$$ depends only on the set $$\{x_{1},\dots ,x_{n}\}$$. To see that $$s^{\prime }_{n}$$ is a polymorphism, note that similarly as in Lemma 10 if (xi,yi) is an edge for $$i\in \{1,2,\dots ,n\}$$, then $$x_{i_{j}}$$ lies on the smallest level among the levels of the arguments if and only if $$y_{i_{j}}$$ does. The rest follows from the fact that sn is totally symmetric on each level. The other implication is again trivial. □

### 6.6 P-hardness

The structure Horn-3SAT has the domain {0,1} and a ternary relation {0,1}3 ∖{(1,1,0)}, and the two unary relations {0} and {1}). It is well known that CSP(Horn-3SAT) is P-complete, i.e., complete for the complexity class P under deterministic logspace reductions.

### Definition 19

Let D be a set. A Hobby-McKenzie chain of length n over D is a sequence of ternary operations $$d_{0},\dots ,d_{n},p,e_{0},\dots ,e_{n}$$ such that

$$\begin{array}{@{}rcl@{}} d_{0}(x,y,z) & \approx& x \\ d_{i}(x,y,y) & \approx& d_{i+1}(x,y,y) \qquad\qquad\qquad\qquad\qquad \text{for even } i < n \\ d_{i}(x,x,y) & \approx& d_{i+1}(x,x,y) \qquad\qquad\qquad\qquad\qquad \text{for odd } i < n \\ d_{i}(x,y,x) & \approx& d_{i+1}(x,y,x) \qquad\qquad\qquad\qquad\qquad \text{for odd } i < n \\ d_{n}(x,y,y) & \approx& p(x,y,y) \\ p(x,x,y) & \approx& e_{0}(x,x,y) \\ e_{i}(x,y,y) & \approx& e_{i+1}(x,y,y) \qquad\qquad\qquad\qquad\qquad \text{for even } i < n \\ e_{i}(x,x,y) & \approx& e_{i+1}(x,x,y) \qquad\qquad\qquad\qquad\qquad \text{for odd } i < n \\ e_{i}(x,y,x) & \approx& e_{i+1}(x,y,x) \qquad\qquad\qquad\qquad\qquad \text{for even } i < n \\ e_{n}(x,y,z) &\approx& z. \end{array}$$

The respective linear condition is abbreviated by HoMcK(n).

### Theorem 20 (consequence of Theorem 9.8 in 46)

A finite structure does not satisfy HoMcK(n) for any n ≥ 1 if and only if it can pp-construct Horn-3SAT.

The theorem implies that if a finite digraph $$\mathbb {H}$$ does not satisfy HoMcK(n) for any n ≥ 1, then $$\mathbb {H}$$ is P-hard (see Section 5.1).

### 6.7 P-hardness or ModpL-hardness

It is widely believed that NL is a proper subclass of P. Another complexity class which is believed to be a proper subclass of P is the class ModpL, for some prime p: this is defined to be the class of problems such that there exists a non-deterministic logspace machine M such that an instance is in the class if and only if the number of accepting paths of M on the instance is divisible by p; see [58]. It is well known that CSP(3Linp) is ModpL-complete (see the discussion in Section 1.3 of [58]). If NL would contain ModpL then this would be a considerable breakthrough in complexity theory.

### Definition 21 (from Theorem 9.11 in 46)

Let D be a set. A Kearnes-Kiss chain of length n ≥ 2 over D is a sequence of ternary operations $$d_{0},d_{1},\dots ,d_{n}$$ on D such that

$$\begin{array}{@{}rcl@{}} d_{0}(x,y,z) & \approx& x \\ d_{i}(x,y,y) & \approx& d_{i+1}(x,y,y) \qquad\qquad\qquad \text{ for even } i \in \{0,1,\dots,n-1\} \\ d_{i}(x,y,x) & \approx& d_{i+1}(x,y,x) \qquad\qquad\qquad \text{ for even } i \in \{0,1,\dots,n-1\} \\ d_{i}(x,x,y) & \approx& d_{i+1}(x,x,y) \qquad\qquad\qquad \text{ for odd } i \in \{1,\dots,n-1\} \\ d_{n}(x,y,z) & \approx& z . \end{array}$$

The respective linear condition is abbreviated by KK(n).

Note that KK(n) implies KK(n + 1) for every n ≥ 0. Also note that the existence of a Jónsson chain implies the existence of a Kearnes-Kiss chain [46]; namely J(n) trivially implies KK(2n + 4).

### Theorem 22 (see 12 and [46])

A finite structure does not satisfy KK(n) for any n ≥ 2 if and only if it can pp-construct Horn-3SAT or 3Linp for some prime p.

We have already mentioned that if a finite digraph $$\mathbb {H}$$ pp-constructs Horn-3SAT then it is P-hard, and hence $$\text {CSP}(\mathbb {H})$$ is not in NL unless NL = P. Similarly, if $$\mathbb {H}$$ pp-constructs 3LinP then it is ModpL-hard, and in this case it is not in NL unless NL contains ModpL. If the conjecture that ‘easy trees cannot count’ (Conjecture 3) is true, then the existence of a Kearnes-Kiss chain is equivalent to the existence of a Hobby-McKenzie chain for trees (assuming P ≠ NP).

### 6.8 NL-hardness

The structure st-Con has the domain {0,1}, the binary relation {(0,0),(0,1),(1,1)} and the unary relations t = {0} and s = {1}. Note that an instance of the CSP of st-Con is unsatisfiable if and only if there exists a directed path from s to t in the digraph defined by the binary relation. It is well known that CSP(st-Con) is complete for the complexity class NL (see, e.g., [47]).

### Theorem 23 (46, 58)

If a finite digraph $$\mathbb {H}$$ does not satisfy HaMi(n) for any n ≥ 1, then it can pp-construct the structure st-Con, and $$\mathbb {H}$$ is NL-hard.

### 6.9 NL-hardness or ModpL-hardness

We now present a polymorphism condition that characterizes the finite structures that can pp-construct st-Con or3LinP for some prime p.

### Definition 24 (46, Theorem 9.15)

For n ≥ 0, a Noname chain of length n over D is a sequence of operations $$f_{0},f_{1},\dots ,f_{n}$$ of arity four on D such that

$$\begin{array}{@{}rcl@{}} f_{0}(x,y,y,z) & \approx& x \\ f_{i}(x,x,y,x) & \approx& f_{i+1}(x,y,y,x) \qquad\qquad\qquad \text{for all } i \in \{0,\dots,n-1\} \\ f_{i}(x,x,y,y) & \approx& f_{i+1}(x,y,y,y) \qquad\qquad\qquad \text{for all } i \in \{0,\dots,n-1\} \\ f_{n}(x,x,y,z) & \approx& z. \end{array}$$

The respective linear condition is abbreviated by NN(n).

Note that NN(n) implies NN(n + 1) for every n ≥ 0.

### Theorem 25 (12, 46)

A finite structure does not satisfy NN(n) for any n ≥ 1 if and only if it can pp-construct the structure st-Con or the structure 3LinP for some prime p.

It follows that if a finite digraph $$\mathbb {H}$$ does not satisfy NN(n) for any n ≥ 1, then $$\text {CSP}(\mathbb {H})$$ is NL-hard or ModpL-hard. Hence, $$\mathbb {H}$$ is in this case not in L, unless L = NL or L = ModpL. Note that Conjecture 3 together with Conjecture 2 implies that NN(n) for some n and HaMi(n) for some n are equivalent for trees (assuming L≠NL).

## 7 Experimental results

We implemented the AC-3 algorithm for establishing arc-consistency and used its adaptation, known as the MAC-3 algorithm, for maintaining arc-consistency during the backtracking procedure described in Section 5.3. The lists and related operations were implemented by doubly-linked lists. The code is written in Rust and the experiments were run on a Intel(R) Xeon(R) CPU E5-2680 v3 (12 cores) @ 2.50GHz with Linux. We also used another implementation written in Python. All tests for chains of polymorphisms and for totally symmetric polymorphisms were performed using this implementation on a AMD Ryzen 5 4500U (with 8 cores) @ 2.38 GHz with Windows. Some results were verified with both implementations, see Table 2. An efficient implementation was essential to obtain our results. Footnote 1 Both implementations and all trees presented in the figures in this section can be found at https://github.com/WhatDothLife/TheSmallestHardTrees.

Table 3 shows the number of unlabeled trees with n vertices and the number of those that are cores. The table suggests that the fraction of trees that are cores quickly goes to 0. The next columns contain the number of unlabeled rooted cores with n vertices, the number of AC calls, and the mean cpu time per AC call on a tree with n vertices. The final column in the table shows the computation time needed to generate all the unlabeled core trees with n vertices with Algorithm 2.

In this section we present the results of testing the discussed linear conditions on these trees to classify them with respect to their computational complexity. In some cases we manage to compute all the minimal trees in the respective complexity class; the corresponding results are presented in Section 7.1. In Section 7.2 we present trees whose precise complexity status is open. While the numbers of trees given in the text are up to isomorphism, the corresponding figures make a further restriction based on the following fact.

### Remark 26

An operation is a polymorphism of $$\mathbb {H}$$ if and only if it is a polymorphism of $$\mathbb {H}^{R}$$.

The remark justifies that our figures contain exactly one of the trees $$\mathbb {T}$$, $$\mathbb {T}^{R}$$. It turns out that the trees in our figures that do not satisfy a certain height-one condition have a unique minimal subtree which has no idempotent polymorphisms satisfying the respective condition (see Remark 6). The vertices and edges drawn in gray do not belong to this minimal subgraph of $$\mathbb {T}$$.

### 7.1 The smallest hard trees

In this section we present the smallest trees that are NP-hard and that are NL-hard, under standard assumptions from complexity theory. We also compute the smallest tree that cannot be solved by arc consistency, the smallest trees that cannot be solved by Datalog, and the smallest trees that cannot be solved by linear symmetric Datalog; these results hold without any assumptions from complexity theory.

#### 7.1.1 The smallest NP-hard trees

Our algorithm found that all trees with at most 19 vertices have Kearnes-Marković-McKenzie polymorphisms and hence are tractable. It also found that there exist exactly 36 trees with 20 vertices that have no Kearnes-Marković-McKenzie polymorphisms and hence are NP-hard. For such an NP-hard tree $$\mathbb {T}$$ with 20 vertices it takes our algorithm about 0.07 seconds to construct the indicator digraph $$\mathbb {T}^{\text {Ind}}$$ for the Kearnes-Marković-McKenzie polymorphisms and about 0.03 seconds to verify that $$\mathbb {T}^{\text {Ind}}$$ does not have a homomorphism to $$\mathbb {T}$$. When applying the level trick, it takes about 0.01 seconds to construct the indicator digraph and 0.03 seconds to verify that $$\mathbb {T}^{\text {Ind}}$$ does not have a homomorphism to $$\mathbb {T}$$.

The trees with 20 vertices that have no Kearnes-Marković-McKenzie polymorphisms are displayed in Fig. 3. Each of these trees has a unique smallest subtree without idempotent Kearnes-Marković-McKenzie polymorphisms. These subtrees are clearly not cores and have Kearnes-Marković-McKenzie polymorphisms. Note that these subtrees are the same for the trees A1–A8 and for A10–A18.

Moreover, there are 4 smallest triads with 22 vertices that have no Kearnes-Marković-McKenzie polymorphisms; these are shown in Fig. 4. All smaller triads have a binary symmetric polymorphism.

#### 7.1.2 The smallest NL-hard trees

There are 8 trees with 12 vertices that are NL-hard. Two of them are isomorphic to their reverse, so we only display 5 trees in Fig. 5, called B1, B2, B3, B4, and B5. The proof that they are NL-hard can be found below. All other trees with at most 12 vertices satisfy HaMi(8).

Since the trees B1-B5 have a majority polymorphism they are in NL. To prove that B1-B5 are NL-hard, we show that they can pp-construct st-Con. Hence we need to construct the three relations {0},{1}, and {(0,0),(0,1),(1,1)}. First note that in a core tree $$\mathbb {T}$$ any singleton set is pp-definable from $$\mathbb {T}$$, since $$\text {End}(\mathbb {T})=\{\text {id}_{T}\}$$ by Theorem 2. The following two graphs represent two pp-formulas ϕ1(x,y) and ϕ2(x,y). The filled vertices stand for existentially quantified variables.

The trees B1, B2, B3 can pp-define a structure that is homomorphically equivalent to st-Con using ϕ1(x,y) for E(st-Con). The trees B4 and B5 can do the same using ϕ2(x,y) for E(st-Con). Since st-Con is NL-hard, B1-B5 are NL-hard as well.

So for 12 vertices, 8 out of 226 trees are NL-hard (assuming L ≠ NL). In Fig. 6 we present how this distribution in core trees changes with increasing number of vertices. Every tree with at most 20 vertices falls into one of two cases:

• it satisfies HaMi(16) and has a majority polymorphism, hence it is in L, or

• it has no HaMi(30).

We strongly suspect that in the latter case the trees have no HaMi(n) for any n, can pp-construct st-Con, and are NL-hard.

#### 7.1.3 The smallest tree not solved by Datalog

It turns out that every tree with at most 20 vertices which is not NP-hard can be solved by Datalog, thus confirming Conjecture 3. In fact, up to 20 vertices all trees that have Kearnes-Marković-McKenzie polymorphisms either have a majority polymorphism or totally symmetric polymorphisms of all arities. The picture is however more complex for larger trees: there exists a tree which can be solved by Datalog but does not have a near-unanimity polymorphism (of any arity) and does not have totally symmetric polymorphisms of all arities, see [4, Proposition 5.5] for an example and [22] for its solvability in Datalog.

#### 7.1.4 The smallest tree not solved by arc consistency

The smallest tree $$\mathbb {T}$$ that has no binary symmetric polymorphism has 19 vertices and is displayed in Fig. 7. It has a 3-wnu polymorphism, and even a majority polymorphism which satisfies f(x,x,y) = f(x,y,x) = f(y,x,x) = x for all x,yT. Note that $$\text {CSP}(\mathbb {T})$$ cannot be solved by the arc-consistency procedure since in this case $$\mathbb {T}$$ must have a binary symmetric polymorphism [30, 35]. All other trees with at most 19 vertices satisfy TS(n) for all n. For a tree $$\mathbb {T}$$ the vertices of the indicator digraph for $$\text {TS}(2 |E(\mathbb {T})|)$$ correspond to the nonempty subsets of T. Hence the indicator structure of a tree $$\mathbb {T}$$ with 19 vertices has 219 − 1 = 524287 vertices. Using level-wise satisfiability (see Section 6.5) the number of vertices of the indicator structure is reduced to something between 19 and 513, depending on the number of vertices on each level.

### 7.2 Open trees

In this section we present trees that are interesting test cases, in particular regarding the conjectured classification of digraphs in NL (Conjecture 1).

#### 7.2.1 A tree not known to be in NL

We found a tree with polymorphisms that form a Kearnes-Kiss chain of length five and a Hobby-McKenzie chain of length 2, but has no majority polymorphism, and no (level-wise) Jónsson chain of length 1000 (see Fig. 8). This tree is neither known to be P-hard or ModpL-hard, nor is it known to be in NL. It is the smallest tree without a majority polymorphism. Note that the existence of a Jónsson chain of some length is decidable because for a given digraph there are only finitely many operations of arity three. Moreover, by the discussion from Section 5.5 we know that we may narrow down the set of operations that have to be considered; the resulting number of operations is 1236. Even if we could show that the tree has no Jónsson chain we would not know that the tree is not in NL. We believe that the tree is in NL, but new ideas are needed to prove that (e.g., ideas to prove Conjecture 1). We mention that it can pp-construct st-Con, so it is NL-hard.

#### 7.2.2 Trees that might be P-hard

There are 28 trees with 18 vertices that satisfy neither HoMcK(1000) nor KK(1000), not even level-wise (see Fig. 9). They satisfy TS(n) for all n, so they are in P and cannot pp-construct 3Linp for every p. Hence, this is in accordance with Conjecture 3. All other trees with up to 18 vertices satisfy KK(5) and are in NL assuming Conjecture 1. Hence, if this conjecture is true, and if NL≠P, and if indeed these 28 trees do not have HoMcK(n) for any n, then they are the smallest trees that are P-hard.

### 7.3 Majority polymorphisms

Majority polymorphisms play a central role in the early theory of the constraint satisfaction problem [34, 35, 49], in graph theory [45, 51], and in the algebraic theory of CSPs [19, 20]. Dalmau and Krokhin [29] proved that structures with a majority polymorphism are in NL already before the mentioned result of Barto, Kozik, and Willard for near-unanimity polymorphisms [11]. We have therefore also computed a smallest tree without a majority polymorphism (see Fig. 8). Interestingly, when solving the indicator problem for the existence of a majority polymorphism of $$\mathbb {H}$$ for graphs with at most 15 vertices (which all have a majority polymorphism), no backtracking was needed: pruning with the arc-consistency procedure sufficed to avoid all dead-ends in the search. Theoretical results only guarantee this behavior for establishing (2,3)-consistency (since $$\mathbb {H}$$ has a majority polymorphism). So one might ask: can every tree with a majority polymorphism be solved by arc consistency? This is not the case; see Lemmata 4.1 and 4.2 in [8]. In our experiments we found the smallest such tree: Fig. 7 shows a tree with a majority polymorphism which does not even have a binary symmetric polymorphism, and hence in particular cannot be solved by arc consistency.

### 7.4 Code availability and reproducibility

All of the code we used can be found at https://github.com/WhatDothLife/TheSmallestHardTrees. There you also find a list with all core trees with at most 20 vertices and a list with all trees occurring in figures in this section. The trees are represented as lists of edges.

If you implement your own algorithm to generate core trees you can compare the numbers with Table 3 (comparing the actual trees in the lists will not work as there are too many). If you want to verify the satisfiability of various polymorphism conditions independently of our implementation, we recommmend the software package PCSP Tools by Opršal [65].

## 8 Open problems and future work

The following conjecture is implied by Conjecture 3, but might be easier to answer.

### Conjecture 4

A tree has Kearnes-Marković-McKenzie polymorphisms if and only if it has a 3-wnu polymorphism.

### Question 1

Is it true that the probability that a tree drawn uniformly at random from the set of all trees with vertex set $$\{1,\dots ,n\}$$ is NP-hard tends to 1 as n tends to infinity? The answer is yes if we ask the question for random labelled digraphs instead of random labelled trees [60].

Figure 6 suggests that the following conjecture is true.

### Conjecture 5

The fraction of core trees with n vertices that are NL-hard goes to 1 as n goes to infinity.

### Question 2

Determine the smallest trees that are P-hard (assuming that NL≠P). We know from Section 7.3 that they must have at least 16 vertices, since all smaller trees have a majority polymorphism and thus are in NL.

### Question 3

Is our algorithm from Section 4 to generate unlabeled core trees a polynomial-delay enumeration algorithm (in the sense of [50])?

### Question 4

Characterize linear conditions that can be tested level-wise (in the sense of Section 5.5) for balanced digraphs, and more specifically, for trees.

It would be interesting to perform experiments similar to the experiments presented here for trees that are equipped with a singleton unary relation {a} for each vertex a of the tree; in this case, if $$\mathbb {T}_{c}$$ is the resulting expanded tree structure, $$\text {CSP}(\mathbb {T}_{c})$$ models the so-called $$\mathbb {T}$$-precoloring extension problem. This setting is particularly nice from the algebraic perspective because then all the polymorphisms of $$\mathbb {T}_{c}$$ are idempotent. Note, however, that all these structure $$\mathbb {T}_{c}$$ are cores, so there are far more structures to consider, and hardness will dominate more rapidly.

Taking this one step further, it would also be interesting to study the so-called list homomorphism problem for trees $$\mathbb {T}$$ from an experimental perspective. Here, the input contains, besides the graph $$\mathbb {G}$$, a set (also commonly referred to as a list) of vertices from $$\mathbb {H}$$ for every vertex of $$\mathbb {G}$$. And we are looking for a homomorphism from $$\mathbb {G}$$ to $$\mathbb {H}$$ that maps each vertex to an element from its set. This can be seen as a special case of a CSP for a relational structure, which contains besides the edge relation also a unary relation for each subset of the vertices of $$\mathbb {H}$$. On the algebraic side, we are therefore interested in polymorphisms that preserve all subsets of $$\mathbb {H}$$; such polymorphisms (and consequently the respective CSPs) are also called conservative. The algorithms and complexities for conservative CSPs are better understood than the general case [2, 17, 19, 53], which will help to determine the complexity of the list homomorphism for trees. On the other hand, as in the case of the precoloring extension problem we have much larger numbers of trees to consider since all the structures that we study are already cores.