The smallest hard trees

We find an orientation of a tree with 20 vertices such that the corresponding fixed-template constraint satisfaction problem (CSP) is NP-complete, and prove that for every orientation of a tree with fewer vertices the corresponding CSP can be solved in polynomial time. We also compute the smallest tree that is NL-hard (assuming L≠NL), the smallest tree that cannot be solved by arc consistency, and the smallest tree that cannot be solved by Datalog. Our experimental results also support a conjecture of Bulín concerning a question of Hell, Nešetřil and Zhu, namely that ‘easy trees lack the ability to count’. Most proofs are computer-based and make use of the most recent universal-algebraic theory about the complexity of finite-domain CSPs. However, further ideas are required because of the huge number of orientations of trees. In particular, we use the well-known fact that it suffices to study orientations of trees that are cores and show how to efficiently decide whether a given orientation of a tree is a core using the arc-consistency procedure. Moreover, we present a method to generate orientations of trees that are cores that works well in practice. In this way we found interesting examples for the open research problem to classify finite-domain CSPs in NL.


Introduction
For a fixed directed graph (short: digraph) H, the constraint satisfaction problem for H, denoted by CSP(H), is the computational problem of deciding whether a given finite digraph G admits a homomorphism to H.This problem is also known as the H-coloring problem.If H is finite and symmetric, then CSP(H) can be solved in polynomial time if H is bipartite or contains a loop, and is NP-complete otherwise [37].The situation if H is a finite but not necessarily symmetric digraph is much more complicated.The Feder-Vardi dichotomy conjecture states that CSP(H) is in P or NP-complete [32].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 [32,22].The Feder-Vardi conjecture was proved in 2017 independently by Bulatov [19] and by Zhuk [64,63].Prior to their break-through result, the conjecture was open even if 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 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.[60,56,6].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, 6ary polymorphism satisfying certain identities [60] -which can readily be tested at least for very small digraphs.This was later improved by Kearnes,Marković,and McKenzie [49] 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 H satisfies any of the equivalent characterizations of the algebraic tractability condition is decidable, but NP-hard [24].

Computational Complexity
Several other important conjectures about the computational complexity of the constraint satisfaction problem for a fixed finite structure H with finite relational signature remain open: most notably the question for which finite structures H the problem CSP(H) is in the complexity class NL (non-deterministic logspace), and for which finite structures 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 [52]).If the polymorphisms of a finite structure H with finite relational signature contain a Kearnes-Kiss chain (defined in Section 6.7), then CSP(H) is in NL.
It is known that if H does not satisfy the condition from Conjecture 1, then 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 [29]).If the polymorphisms of a finite structure H with finite relational signature contain a Noname chain (defined in Section 6.9) then CSP(H) is in L. Also here it is known that if H does not satisfy the condition from Conjecture 2, then 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 H certain finite structures that are known to be L-hard, Mod p L-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 [46].
Again, these conjectures are already open if H is a finite digraph, or even if 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 [22].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 H is NP-hard if CSP(H) is NP-hard, and tractable if CSP(H) is in P. Similarly, we say that H is P-hard, NL-hard, in NL, in L, NP-complete, NL-complete, etc. if CSP(H) has that property.
Unfortunately, there is no graph theoretic characterization of which trees are NP-hard.The first NP-hard tree T was found by Gutjahr, Welzl, and Woeginger and had 287 vertices [35].This was later improved by Gutjahr to a smaller NP-hard tree with 81 vertices [34], and then to an NP-hard tree with just 45 vertices by Hell, Nešetřil, and Zhu [36].The tree 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,21].Fischer [33] used a computer search and found an NP-hard tree with just 30 author year size comment Gutjahr, Welzl, and Woeginger [35] 1992 287 First published Gutjahr [34] 1991 81 PhD thesis Hell, Nešetřil, and Zhu [36] 1996 45 Triad Barto, Kozik, Maróti, and Niven [8] 2009 39 Triad Fischer [33] 2015 30 Master thesis Tatarko [61] 2019 26

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 H has tree duality if for all finite digraphs G, if whenever all trees that map homomorphically to G also map to H, then G maps to H.It is well-known that a finite digraph H has tree duality if and only if the so-called arc-consistency procedure solves CSP(H) [32].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 H, the arc-consistency procedure for CSP(H) can be formulated as a Datalog program [32]; 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 CSP(H) can be solved by Datalog if and only if 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 [25].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 [29].
A structure H has the ability to count [53] if CSP(H) can encode, in some natural sense (namely pp-constructibility [13,12]), solving systems of linear equations over Z p (for some prime p); thus making CSP(H) Mod p L-hard.The ability to count adds substantial complexity to the CSP.Structures that cannot count are all tractable and even in Datalog [17,5] 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 [50].
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 [37], smooth digraphs (digraphs without sources and sinks) [10], conservative digraphs (digraphs expanded with all subsets of vertices as unary relations) [41], binary conservative structures (even 3-conservative) [47].We note that this phenomenon also occurs for many large classes of infinite structures H: for example for all first-order expansions of the basic relations of RCC5 [14]; see [15] 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 [24].
In [21] Bulín conjectured that easy trees cannot count, establishing this fact for a large yet structurally limited subclass of trees.Conjecture 3. Let T be a tree.If T has the ability to count, then T is NP-hard.
This conjecture (which is rephrasing Conjecture 2 in [21]) would answer an open question posed by Hell, Nešetřil, and Zhu [40] (Open Problem 1 at the end of the article): they asked whether there exists a tractable tree which does not have bounded treewidth duality.

Contributions
In this article, we obtain the following results.
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. 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. 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. 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. 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 2), 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 H is a core if every homomorphism from H to H is injective.Two graphs H 1 and H 2 are called homomorphically equivalent if there is a homomorphism from H 1 to H 2 and vice versa.Clearly, in that case CSP(H 1 ) = CSP(H 2 ) and so H 1 , H 2 are either both tractable or both NP-hard.It is easy to see that every finite digraph H is homomorphically equivalent to a core digraph H ′ , which is unique up to isomorphism.Moreover, if H is a tree, then H ′ is a tree as well (and its size is smaller or equal to the size of H).Hence, it suffices to work with trees that are cores.However, Hell and Nešetřil proved that deciding whether a given digraph is a core is coNP-complete [38].Remarkably, the following fact seems to be unnoticed in the literature.
6.There is a polynomial-time algorithm for deciding whether a 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.7. We computed the number of trees that are cores for sizes up to 20 (see Table 2).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.
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.
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.

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.

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 [28].All graphs we consider are finite.A digraph is a pair H = (H; E) where H is a nonempty set and E = E(H) ⊆ H 2 is a set of (directed) edges.A (simple, undirected) graph is a pair H = (H; E) where H is a nonempty set and If G and H are digraphs, then a homomorphism from G to H is a map h : G → H such that for all (x, y) ∈ E(G) we have (h(x), h(y)) ∈ E(H).We write CSP(H) (for constraint satisfaction problem) for the class of all finite digraphs G which admit a homomorphism to H. A homomorphism from H to H is called an endomorphism of H.A finite digraph H is called a core if all endomorphisms of H are injective.It is easy to see that an injective endomorphism of H must in fact be bijective and an automorphism, i.e., an isomorphism between H and H.It is easy to see that every finite digraph G is homomorphically equivalent to a finite core digraph H, and that this core digraph is unique up to isomorphism [39], hence H will be called the core of G.
An undirected tree is a connected undirected graph without cycles.If u, v ∈ T and T is an undirected tree, then there exists a unique path P from u to v in T; the number of edges of P is denoted by dist(u, v).A vertex v ∈ T is called a center of T if v lies in the middle of a longest path in T.An edge e ∈ E(T) is called a bicenter of T if e is the middle edge of a longest path in T. We will use the following classical result.
If O is an orientation of a tree and u, v ∈ O, then dist(u, v) (center of O, bicenter 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 H is balanced if its vertices can be organized into levels, that is, there exists a function lvl : H → N such that lvl(v) = lvl(u) + 1 for all (u, v) ∈ E(H) and the smallest level is 0. The height of H is the maximum level.Note that trees are balanced and observe that if G and H are balanced of the same height, and G is connected, then any homomorphism from G to H must preserve levels, that is, lvl(v) = lvl(h(v)) for all v ∈ G.A rooted tree is a tuple (T, r), where T is a tree and r ∈ T ; r is then called the root of T. A rooted tree (T, r) is called a rooted core if every endomorphism of T that fixes r is injective.The depth of a rooted tree (T, r)

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 G and H be finite digraphs.We would like to determine whether there exists a homomorphism from G to H.The idea of the arc-consistency procedure is to maintain for each x ∈ G a set L(x) ⊆ H. Informally, each element of L(x) represents a candidate for an image of x under a homomorphism from G to H.The algorithm initializes each list L(x) with H and successively removes vertices from these lists; it only removes a vertex u ∈ H from L(x) if there is no homomorphism from G to 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 eventually we cannot remove any vertex from any list with these rules any more, the digraph G together with the lists for each vertex is called arc-consistent.Note that formally we may view L as a function L : G → 2 H from the vertices of G to sets of vertices of H. Note that we may run the algorithm also on digraphs G where for some x ∈ G the list L(x) is already set to some subset of H.In this setting, the input consists of G and the given lists, and we are looking for a homomorphism h from G to H such that for every x ∈ G we have h(x) ∈ L(x).The pseudocode of the entire arc-consistency procedure is displayed in Algorithm 1.The standard arc-consistency procedure AC H (G) is then obtained by calling AC H (G, L) with L(x) := H for all x ∈ G.
Clearly, if the algorithm removes all vertices from one of the lists, then there is no homomorphism from G to H.It follows that if AC H rejects G, then there is no homomorphism from G to H.The converse implication does not hold in general.For instance, let H be the loopless digraph with two vertices and two edges, denoted K 2 , and let G be does not remove any vertex from any list, but obviously there is no homomorphism from The arc-consistency procedure can be implemented so that it runs in O(|E(G)| • |H| 3 ), e.g. by Mackworth's AC-3 algorithm [55].

Cores of Trees
Recall that the problem of deciding whether a given digraph is a core is coNP-complete [38].The following theorem implies that whether a given finite tree is a core can be tested in polynomial time.
Theorem 2. Let T be a finite tree.Then the following are equivalent.

AC T (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 T be a finite tree and let H be a finite digraph such that AC H (T) does not reject.Let t ∈ T , and let a ∈ H be such that a ∈ L(t) after running AC H (T). Then there is a homomorphism Proof.Let S be a maximal subtree of T such that t ∈ S and there exists a partial homomorphism h : S → H with h(t) = a.If S = T , then there exists x ∈ S and y ∈ T \ S such that either (x, y) or (y, x) is an edge in T; without loss of generality assume that (x, y) ∈ E(T).Because the value u = h(x) was not removed from L(x) when running AC H (T), it follows that there exists v ∈ L(y) such that (u, v) ∈ E(H).But then setting h(y) = v extends h to a partial homomorphism from S ∪ {y} to H contradicting maximality of the subtree S.
Lemma 5. Let (T, r) be a rooted tree with an automorphism that is not the identity.Then (T, r) has a non-injective endomorphism.
Proof.We prove the statement by induction on the number of vertices of T. Consider the components of the graph obtained from 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 T is a non-injective endomorphism of (T, r).
If each component C is mapped by h into itself, then each h| C is an automorphism of (C, r C ), where r C is the unique neighbor of r that lies in C. Since h is not id T there must be some C such that h| C is not id C and by induction hypothesis there exists a non-injective endomorphism h ′ of (C, r C ).Since h ′ (r C ) = r C the mapping which extends h ′ to T by fixing all other vertices of T is a non-injective endomorphism of (T, r).
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 T has an endomorphism h which is not the identity map.If h is not injective, then T is not a core and we are done.Hence, suppose that h is an automorphism.Note that by Theorem 1, if T has a center, then h(c) = c and if T has a bicenter (x, y) ∈ E(T), then h({x, y}) = {x, y}.In the latter case, since (y, x) / ∈ E(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 (T, r).By Lemma 5, T has a non-injective endomorphism and is therefore not a core.
To prove that 2. implies 3., we prove the contrapositive.Suppose that AC T (T) terminates with |L(x)| > 1 for some x ∈ T .Then there exists y ∈ L(x), y = x.Lemma 4 implies that there is an endomorphism h of T such that h(x) = y and thus h = id T .
To see that 3. implies 2., note that L(x) = {x} since because of the identity endomorphism id T , x cannot be removed from L(x).Therefore, for any endomorphism h : T → T and any x ∈ T we must have h(x) ∈ L(x), and so h(x) = x and h = id T .

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 [62].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, . . ., n} for some n ∈ 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 cd n /n 5/2 where d ≈ 5.6465 and c ≈ 0.2257 are constants; the initial terms are shown in Table 2.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 (T 1 , r 1 ) • A rooted tree (T, r) is a rooted core if and only if AC T (T, L), where L(r) = {r} and L(x) = T for x ∈ T \ {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 (T, r) is a rooted core, then (T i , r i ) is a rooted core for every i.
• If T is a core and r is its center, then (T i , r i ) is a rooted core for every i.
• 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 now 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).

Polymorphism Conditions
In this section we introduce basic facts from the universal-algebraic approach that are essential for obtaining our results.If H is a digraph and k ≥ 1 is an integer, then H k denotes the k-th categorical power of H, i.e., the digraph with vertex set H k and edge set A polymorphism of H is a homomorphism from H k to H, for some k ≥ 1.Clearly, every projection, i.e., every operation of the form (x 1 , . . ., x k ) → x i , for some fixed i ≤ k, is a polymorphism for every digraph 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.

Primitive Positive Constructions
Primitive positive definitions are a natural type of gadget construction which can be used to obtain logspace reductions between CSPs.Central to the algebraic theory of the CSP is the return RootedTrees fact that the possibility of such an encoding can be determined from the polymorphisms of the respective templates.Let A = (A; R 1 , . . ., R n ) be a relational structure.A relation S ⊆ A n is primitive positive (pp-) definable from A if it can be defined (without parameters) by a first order formula which only uses the predicate symbols R 1 , . . ., R n , the equality predicate, conjunction, and existential quantification.
Primitive positive constructions are a more powerful generalization of primitive positive definitions.A relational structure B = (B; S 1 , . . ., S m ) is pp-constructible from A if there exists k > 0 and a structure B ′ = (B ′ ; S ′ 1 , . . ., S ′ m ) which is homomorphically equivalent to B such that B ′ = A k and for every i ∈ {1, . . ., m} the relation S i ⊆ B ′ ri , when considered as a kr i -ary relation on A, is pp-definable from A. In this case there is a logspace reduction from CSP(B) to CSP(A).
If A and B are finite structures, then B is pp-constructible from A if and only if B satisfies every height-one condition satisfied by 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]).

Linear Conditions and Height-one Conditions
Height-one conditions and linear conditions are particular types of strong Maltsev condition [48] 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 σ : {1, . . ., k} → {1, . . ., n} and ρ : {1, . . ., ℓ} → {1, . . ., n} are functions, then an expression of the form 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 σ(1) , . . ., x σ(k) ) ≈ x j , x i ≈ g(x ρ(1) , . . ., x ρ(ℓ) ), or x i ≈ x j .Then a linear condition is a finite set of linear identities.
A set of operations F on some domain D satisfies a linear condition Σ if we can interpret every function symbol appearing in Σ as an operation from 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 A satisfies a linear condition if the set of all polymorphisms of 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 which is satisfied by A if and only if A has a binary symmetric polymorphism.Since x 1 , x 2 , x 3 , . . .are just variable names we sometimes use x, y, z, etc. instead.
An operation f : D k → D is called idempotent if it satisfies the identity f (x, . . ., x) ≈ 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.
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 the same CSP and satisfies the same height-one identities (which is not true for linear conditions in general).

The Indicator Construction
The question whether a given digraph H has polymorphisms that satisfy a given height-one or even linear condition can be tested algorithmically as follows.To illustrate the well-known idea, suppose that the given set consists of a single identity, namely f (x, y) ≈ f (y, x).We then compute H 2 and contract every vertex of H 2 of the form (x, y) with the vertex (y, x).The resulting digraph H Ind will be called the indicator digraph for the height-one condition.We finally search for a homomorphism from H Ind to H. Note that H Ind may be viewed as an instance of CSP(H), and that the homomorphisms from H Ind to H are in 1-1 correspondence with the binary symmetric polymorphisms of H (see Definition 9).
Analogously we may proceed for any other height-one condition: to compute H Ind , we construct for each function symbol the categorical power of 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 x i ≈ x j are only satisfied in oneelement structures.Therefore, we may assume that every identity is either height-one or of the form f (x σ(1) , . . ., x σ(k) ) ≈ x j .First, construct the indicator digraph H Ind using only the heightone identities when identifying vertices.Then, for every identity that is not height-one, find every vertex of H Ind that comes from a tuple of vertices of H matching the left-hand side and set its value to the vertex of H given by the right-hand side.For example, if the identity is f (x, y, x) ≈ x, we require that (a, b, a) ∈ H Ind must be mapped to a, for every a, b ∈ H.In this way, we obtain an instance of the H-precoloring extension problem (see also the discussion in Section 8).It is well known that for cores, this problem is logspace-equivalent to CSP(H) [20,13].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.

Arc Consistency with Exhaustive Search
Chen and Larose [24] give a polynomial-time procedure to test for the existence of polymorphisms satisfying a given linear condition, providing that the linear condition implies the algebraic tractability condition.Their procedure uses the algorithm of Zhuk which is known to be uniform in the sense that it runs in polynomial time even if we assume that also the template H is part of the input to the algorithm for CSP(H) [64].
However, in our approach we avoid implementing and running the algorithm of Zhuk (which is complex and whose running time is a polynomial of a yet unknown degree).Instead, we run the arc-consistency procedure for H on the indicator digraph H 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 H Ind with preset values dictated by non-height-one identities, as explained above.Additionally, for every u ∈ H, we initialize the list for every vertex of H Ind of the form (u, . . ., 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 H Ind , the lists are initialized to H.
If AC H detects an inconsistency, we can be sure that no polymorphisms satisfying the linear condition exist.Otherwise, we select some vertex x ∈ H Ind , and set L(x) to u for some u ∈ L(x).Then we proceed recursively with the resulting lists.If AC 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 x ∈ H Ind , which defines a homomorphism from H Ind to H.This homomorphism can then be interpreted as polymorphisms satisfying the linear condition.
There are numerous methods to speed up this backtracking procedure.One of the best known is called Maintaining Arc Consistency (MAC) [58].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 ∈ H Ind that has a list of smallest size.

Level-wise satisfiability
If 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 H in such a way that for every level in 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 H k consisting of k-tuples of same-level vertices.Note that this is a union of connected components of H k and that polymorphisms can be defined the first projection on the remaining connected components of 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 H, then it is satisfied in 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 [8,4,21,22].This optimization is particularly useful when testing the condition TS(n) for all n; see Section 7.1.4.

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 Figure 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 and the right side shows the case for trees assuming Conjecture 3 (and P = NP).The implications are either immediate or from the literature [42] (Chapter 9), [11,49,3].Figure 1: An overview of (computational and descriptive) complexity classes that are relevant for finite-domain CSPs, of important pp-constructions, and of the respective polymorphism conditions.LT stands for Larose and Tesson [52], E stands for Egri [30], HMcK stands for Hobby-McKenzie [42] (Chapter 9), D stands for Dalmau [26], AC stands for Afrati and Cosmadakis [1], BZ stands for Bulatov [19] and Zhuk [64], and KMM stands for Kearnes, Marković, and McKenzie [49].

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 [49].Definition 7. A pair of ternary operations p, q : D 3 → D is called Kearnes-Marković-McKenzie if it satisfies the height-one condition p(x, y, y) ≈ q(y, x, x) ≈ q(x, x, y) p(x, y, x) ≈ q(x, y, x).
Using this characterization, the CSP dichotomy can be stated as follows.

Theorem 8 ([64, 19, 49]). A finite digraph H has Kearnes-Marković-McKenzie polymorphisms if and only if there is no pp-construction of K 3 from H. In this case, CSP(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 [49].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 It is known that the existence of a k-wnu implies the existence of Kearnes-Marković-McKenzie polymorphisms [60,49], and that the existence of Kearnes-Marković-McKenzie polymorphisms implies the existence of a k-wnu for some k ≥ 2 [56].Hence, in particular, if a finite digraph H has a binary symmetric polymorphism then CSP(H) can be solved in polynomial time.Our results will show that the converse is false even if 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, . . .that level-wise satisfy Σ, and define polymorphisms f ′ , . . . in the following way (say f is k-ary): where j ∈ {1, 2, . . ., k} is the smallest index such that lvl(x j ) = ℓ.To verify that the f ′ s are polymorphisms, note that if (x i , y i ) is an edge for i ∈ {1, 2, . . ., k}, then f ′ (x 1 , x 2 , . . ., x k ) and f ′ (y 1 , y 2 , . . ., y k ) fall under the same case of the definition.If it is the second case, x j lies on the smallest level out of {lvl(x i ) | 1 ≤ i ≤ k} if and only if y j lies on the smallest level out of {lvl(y i ) | 1 ≤ i ≤ k}.Hence, the selected coordinate j is the same.To see that every identity is satisfied, note that the only interesting case is when lvl(x) = lvl(y), and f ′ then chooses the variable on the lower level.The other implication is trivial.

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 3Lin p has the domain D = {0, . . ., p − 1} where p is some prime, the relation {(x, y, z) | x + y + z ≡ 0 (mod p)}, and the relation {x} for every x ∈ D. It is well-known that CSP(3Lin p ) is not in Datalog [32].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) ≈ g(x, x, x, y).
• H can be solved by Datalog.
• there is no pp-construction of 3Lin p in H, for any prime p.
• H has a 3-4 weak near-unanimity pair of polymorphisms.Note that this shows that Conjecture 3 implies (assuming P = NP) that every tree with Kearnes-Marković-McKenzie polymorphisms has a 3-4WNU pair of polymorphisms and in particular, that it has a 3-wnu polymorphism, which is open as well.Also note that by Lemma 10, it is enough to test for level-wise 3-4 WNU.

Containment in NL
In this section we present a strong sufficient condition for the containment of H in NL.

The respective height one 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 j 1 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 The existence of a near-unanimity polymorphism characterizes bounded strict width [32].More importantly for us, a near-unanimity polymorphism is sufficient to put 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 [26].
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.
Note that the existence of polymorphisms of H that form a Jónsson chain is only a sufficient condition for the containment of CSP(H) in NL.An incomparable sufficient condition for the containment of CSP(H) in NL was identified in [23].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).

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 , . . ., p n on D that satisfy x ≈ p 1 (x, y, y) for all i ∈ {1, . . ., n − 1} p n (x, x, y) ≈ y.

The respective height one condition is abbreviated by HM(n).
Note that HM(n) implies HM(n + 1) for every n ≥ 1.For n = 1 the operation p 1 is known as a Maltsev operation.Kazda [46] proved the following conditional result.
Theorem 16 ([46]).If a finite digraph H can be solved by linear Datalog, and H satisfies HM(n) for some n ≥ 1, then 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).

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 s n : D n → D is called totally symmetric if for all variables x 1 , . . ., x n and y 1 , . . ., y n such that {x 1 , . . ., x n } = {y 1 , . . ., y n } the operation s n satisfies s n (x 1 , . . ., x n ) ≈ s n (y 1 , . . ., y n ).

The respective height one condition is abbreviated by TS(n).
The digraph H can be solved by arc consistency if and only if H has totally symmetric polymorphisms of all arities [32,27].Note that TS(4) implies 3-4 WNU.Also note that a finite digraph H satisfies TS(n) for all n > 0 if and only if it satisfies TS(2|E(H)|) (see the proof given in [27]).The arity 2|E(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 H and n > 0, H level-wise satisfies TS(n) if and only if H satisfies TS(n).
Proof.Let s n be an n-ary polymorphism of H that level-wise satisfies the condition TS(n).We can construct an n-ary totally symmetric polymorphism s ′ n of H by applying s n to the set of vertices on the smallest level.That is, for an input tuple (x 1 , . . ., Clearly, the definition of s ′ n (x 1 , . . ., x n ) depends only on the set {x 1 , . . ., x n }.To see that s ′ n is a polymorphism, note that similarly as in Lemma 10 if (x i , y i ) is an edge for i ∈ {1, 2, . . ., n}, then x ij lies on the smallest level if and only if y ij does.The rest follows from the fact that s n is totally symmetric on each level.The other implication is again trivial.
for odd i < n d n (x, y, y) ≈ p(x, y, y) p(x, x, y) ≈ e 0 (x, x, y) e i (x, y, y) ≈ e i+1 (x, y, y) for even i < n e i (x, x, y) ≈ e i+1 (x, x, y) for odd i < n e i (x, y, x) ≈ e i+1 (x, y, x) for even i < n e n (x, y, z) ≈ z.

The respective height one condition is abbreviated by HMcK(n).
Theorem 20 (consequence of Theorem 9.8 in [42]).A finite structure does not satisfy HMcK(n) for some n ≥ 1 if and only if it can pp-construct Horn-3SAT.
The theorem implies that if a finite digraph H does not satisfy HMcK(n) for some n ≥ 1, then H is P-hard (see Section 5.1).

P-hardness or Mod p L-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 Mod p L, 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 [52].It is well known that CSP(3Lin p ) is Mod p L-complete.If NL would contain Mod p L then this would be a considerable breakthrough in complexity theory.

The respective height one 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 [42]; namely J(n) trivially implies KK(2n + 4).
Theorem 22 (see [12] and [42]).A finite structure does not satisfy KK(n) for some n ≥ 2 if and only if it can pp-construct Horn-3SAT or 3Lin p for some prime p.
We have already mentioned that if a finite digraph H pp-constructs Horn-3SAT then it is Phard, and hence CSP(H) is not in NL unless NL = P. Similarly, if H pp-constructs 3Lin p then it is Mod p L-hard, and in this case it is not in NL unless NL contains Mod p L. If the conjecture that 'easy trees cannot count' (Conjecture 3) is true, then the existence a Kearnes-Kiss chain is equivalent to the existence of a Hobby-McKenzie chain for trees (assuming P = NP).

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.
Theorem 23 ([52, 42]).If a finite digraph H does not satisfy HM(n) for some n ≥ 1, then it can pp-construct the structure st-Con, and H is NL-hard.

NL-hardness or Mod p L-hardness
We now present a polymorphism condition that characterizes the finite structures that can ppconstruct st-Con or 3Lin p for some prime p.

The respective height one condition is abbreviated by NN(n).
Note that NN(n) implies NN(n + 1) for every n ≥ 0.
Theorem 25 ([42, 12]).A finite structure does not satisfy NN(n) for some n ≥ 1 if and only if it can pp-construct the structure st-Con or the structure 3Lin p for some prime p.
It follows that if a finite digraph H does not satisfy NN(n) for any n ≥ 1, then CSP(H) is NL-hard or Mod p L-hard.Hence, H is in this case not in L, unless L = NL or L = Mod p L. Note that Conjecture 3 together with Conjecture 2 implies that NN(n) for some n and HM(n) for some n are equivalent for trees (assuming L = NL).

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 Rust1 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 where done using this implementation on a AMD Ryzen 5 4500U (with 8 cores) @ 2.38 GHz with Windows.An efficient implementation was essential to obtain our results.Table 2 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 core checks, and the mean cpu time per core check 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 H if and only if it is a polymorphism of H R .
The remark justifies that our figures contain exactly one of the trees T, 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 T.

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.

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 Figure 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 HM (8).
Since the trees B1-B5 have a majority 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 T any singleton set is pp-definable from T, since End(T) = {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.

x y x y
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 Table 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 HM (16) and has a majority polymorphism, hence it is in L, or • it has no HM (30).
We strongly suspect that in the latter case the trees have no HM(n) for any n, can pp-construct st-Con, and are NL-hard.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 [21] for its solvability in Datalog.

The Smallest Tree not Solved by Arc Consistency
The smallest tree T that has no binary symmetric polymorphism has 19 vertices and is displayed in Figure 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, y ∈ T .Note that CSP(T) cannot be solved by the arc-consistency procedure since in this case T must have a binary symmetric polymorphism [32,27].All other trees with at most 19 vertices satisfy TS(n) for all n.For a tree T the vertices of the indicator digraph for TS(2|E(T)|) correspond to the nonempty subsets of T .Hence the indicator structure of a tree T with 19 vertices has 2 19 − 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.
Tree C Figure 7: The smallest tree that cannot be solved by Arc Consistency (it has 19 vertices and a majority, but no binary symmetric polymorphism).
Tree D Figure 8: The smallest tree without a majority polymorphism (unique up to edge reversal; it has 16 vertices).It satisfies KK(5) but does not satisfy Jónsson(1000).Therefore, Conjecture 1 puts it in NL but we cannot prove this fact; it is an interesting open case.

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).

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, and no (level-wise) Jónsson chain of length 1000 (see Figure 8).This tree is neither known to be P-hard or Mod p L-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 12 36 .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.

Trees that might be P-hard
There are 28 trees with 18 vertices that satisfy neither HMcK(1000) nor KK(1000), not even level-wise (see Figure 9).They satisfy TS(n) for all n, so they are in P and cannot pp-construct 3Lin p 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 HMcK(n) for any n, then they are the smallest trees that are P-hard.

Majority Polymorphisms
Majority polymorphisms play a central role in the early theory of the constraint satisfaction problem [32,31,43], in graph theory [45,41], and in the algebraic theory of CSPs [18,19].We have therefore also computed a smallest tree without a majority polymorphism (see Figure 8).Interestingly, when solving the indicator problem for the existence of a majority polymorphism of H for graphs with at most 15 vertices (which all have a majority polymorphism), no backtracking was needed: pruning with the arc-consistency procedure did suffice to avoid all dead-ends in the search.Theoretical results only guarantee this behavior for establishing (2, 3)-consistency (since 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: Figure 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.

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, . . ., 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 [54].
The table in 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 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 [44])?
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 T c is the resulting expanded tree structure, CSP(T c ) models the so-called T-precoloring extension problem.This setting is particularly nice from the algebraic perspective because then all the polymorphisms of T c are idempotent.Note, however, that all these structure 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 T from an experimental perspective.Here, the input contains besides the graph G a list of vertices from H and we are looking for a homomorphism from G to H that maps each vertex to an element from its list.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 H. On the algebraic side, we are therefore interested in polymorphisms that preserve all subsets of 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 [16,2,18,47], 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.

Algorithm 3 :
GenerateRootedTrees input : two positive integers n, d output: a list of rooted trees with n vertices and depth d begin if n = 0 then return

Figure 2 :
Figure 2: Taxonomy of polymorphism conditions of structures with a finite domain that are relevant for the computational complexity of CSPs, ordered by strength; the arrows point from stronger conditions to weaker ones.The right picture shows the situation for trees assuming Conjecture 3 (and P = NP).

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 T with 20 vertices it takes our algorithm about 0.07 seconds to construct the indicator digraph T Ind for the Kearnes-Marković-McKenzie polymorphisms and about 0.03 seconds to verify that T Ind does not have a homomorphism to T. When applying the level trick, it takes about 0.01 seconds to construct the indicator digraph and 0.03 seconds to verify that T Ind does not have a homomorphism to T. The trees with 20 vertices that have no Kearnes-Marković-McKenzie polymorphisms are displayed in Figure 3.Note that the smallest subtree without idempotent Kearnes-Marković-McKenzie polymorphism is the same for the trees A2-A4, A5-A12, and A13-A18.Moreover, there are 4 smallest triads with 22 vertices that have no Kearnes-Marković-McKenzie polymorphisms; these are shown in Figure 4.All smaller triads have a binary symmetric polymorphism.

Table 1 :
A time-line of the history of the smallest known NP-hard orientation of a tree.
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 Table1.

Table 2 :
The number of unlabeled trees with n vertices together with results of Algorithm 2.