{'fraction_non_alphanumeric': 0.06133799459717146, 'fraction_numerical': 0.007415647015202077, 'mean_word_length': 3.7894469812278033, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 6, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 25, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
On Tree Substitution Grammars

Tree substitution grammars are formal models that are used extensively in natural language processing. It is demonstrated that their expressive power is located strictly between the local tree grammars and the regular tree grammars. A decision procedure for the problem of determining whether a tree substitution grammar generates a local tree language is provided. Unfortunately, the class of tree substitution languages is neither closed under union, nor intersection, nor complements. Indeed unions of tree substitution languages even generate an infinite hierarchy. However, all finite and all co-finite tree languages are tree substitution languages.


Introduction
Trees are a fundamental data structure in computer science and are used in many application areas like natural language processing [12], database theory [1], and compiler construction [17]. All the mentioned applications as well as others [6,7] require effective representations of sets of trees, also called tree languages. These requirements triggered detailed investigations of various classes of tree languages since the 1960s and by now there exists an abundance of models [5].
The most robust of those classes of tree languages are the regular tree languages [6,7], which are generated by finite-state tree automata, which are a natural extension of the finite-state string automata that generate the regular string languages [18]. Most standard problems are decidable for the regular tree languages and they generally enjoy the same nice algorithmic properties as the regular string languages. The main feature of those automata are their finitely many states, which enable most of the positive properties. However, these states are not exhibited directly in the trees generated. In application areas like natural language processing, in which representations of tree languages have to be inferred from finite sets of trees, practitioners often resorted to simpler models, in which the representation can more readily be induced from the sample.
Tree substitution grammars were originally introduced as a special case of tree-adjoining grammars [9,11], in which no adjunction is allowed. This restriction proved useful in the lexicalization of context-free grammars [10]. However, tree substitution grammar soon became popular in the parsing community [15] under the approach called data-oriented parsing [3] and were the formal model of many state-of-the-art parsers [16]. Similarly, synchronous tree substitution grammars, which are the same as the syntax-directed translation schemes of [2], are used in many statistical machine translation models [4,8,13,14]. Despite the multitude of applications, a fundamental study of their expressive power is missing. Rather they are attributed properties like "extended domain of locality", which provides some intuition, but has no formal definition.
A tree substitution grammar G is essentially a finite set F of tree fragments together with a set R of permissible root labels. Those tree fragments can be arbitrarily tall or large, which distinguishes tree substitution grammars from local tree grammars [6,7]. In addition, the fragments can contain leaves that are labeled by internal symbols. Leaves with such labels are called open and can be expanded further by fragments of F that have the same symbol as root label. Indeed G generates trees from a permissible root label of R by successively expanding open leaves with fragments of F until no open leaves remain. The set of all trees derivable in this manner is called the tree language generated by G. The tree languages that can be generated by some tree substitution grammar are called the tree substitution languages.
In this contribution we start a fundamental study of the expressive power of tree substitution grammars. We show that tree substitution grammars are strictly more expressive than local tree grammars [6,7], but strictly less expressive than finite-state tree automata (see Corollary 10). This, in particular, yields that most standard decision problems are also decidable for tree substitution languages because they are regular. In addition, it is decidable to determine whether a given tree substitution language is local (see Theorem 8). The decidability status of the related question whether a given regular tree language is a tree substitution language remains open. It is interesting to note that all finite and co-finite tree languages are tree substitution languages (see Theorem 6), which makes them much more useful for the approximation of finite samples of trees than the local tree languages, which do not contain all finite tree languages.
We also investigate the closure properties of the tree substitution languages. Unfortunately, they are neither closed under union (see Theorem 9), nor under intersection (see Theorem 13), nor under complement (see Theorem 14). In fact, unions of tree substitution languages even form a strict hierarchy (see Theorem 11), so unions of k tree substitution languages are strictly less expressive than unions of k + 1 tree substitution languages. A similar hierarchy is significantly more difficult to prove for intersections and remains an open problem because intersections break the "extended domain of locality" (as shown in the proof of Theorem 13) and can manage a non-explicit information transport over unbounded distances in the trees. Indeed the trivial union construction, which just takes the union of the fragments of the individual tree substitution grammars G 1 , . . . , G n , does yield a tree substitution grammar G that can generate each tree that can be generated by some G i . However, G might overgeneralize in the sense that it may also generate trees that cannot be generated by any G 1 , . . . , G n . This property is utilized in grammar induction to generalize beyond the seen data. Overall, the expressive power of tree substitution grammars is interesting and offers new challenging problems because they are used extensively in real-world applications despite their brittle expressive power. It is exactly this absence of good closure properties, which requires separate arguments for each individual problem and thus makes several problems challenging as outlined in the open problems section.

Preliminaries
We denote the set of nonnegative integers (including 0) by N. For every k ∈ N, we use the subset [k] = {i ∈ N | 1 ≤ i ≤ k}. An alphabet A is simply a finite set and A * = k∈N A k is the set of all finite words over A, where A k = A × · · · × A containing k factors A and A 0 = {ε}, of which ε is called the empty word. The length |w| of a word w = a 1 · · · a k ∈ A * with a 1 , . . . , a k ∈ A is |w| = k; i.e. the number of symbols making up w. Given words v, w ∈ A * , their concatenation is written v.w or simply vw. We write v w provided that there exists u ∈ A * such that vu = w. The relation is actually a partial order, called the prefix order.
Let S be a set and R ⊆ S × S be a relation. The identity on S is the rela- A ranked alphabet (Σ, rk) is a pair consisting of an alphabet Σ and a mapping rk : Σ → N that assigns a rank to each symbol of Σ. We usually denote a ranked alphabet (Σ, rk) by just Σ alone when the ranks are clear. We also write σ (k) to indicate that rk(σ) = k. Moreover, for every k ∈ N, we let Σ k = {σ ∈ Σ | rk(σ) = k}. Given a ranked alphabet Σ and a set Z, the set T Σ (Z) of Σ" trees indexed by Z is the smallest set T such that Z ⊆ T and σ(t 1 , . . . , t k ) ∈ T for every k ∈ N, σ ∈ Σ k , and t 1 , . . . , t k ∈ T . We abbreviate T Σ (∅) simply to T Σ , and any subset L ⊆ T Σ is called tree language. It is co-finite if T Σ \ L is finite.
Next, we recall some common notions and notations for trees. In the following, let t ∈ T Σ (Z) be a tree for a ranked alphabet Σ and a set Z. The set pos(t) of positions of t is inductively defined by pos(z) = {ε} for all z ∈ Z, and pos(σ(t 1 , . . . , t k )) = {ε}∪{i.p | i ∈ [k], p ∈ pos(t i )} for every k ∈ N, σ ∈ Σ k , and t 1 , . . . , t k ∈ T Σ (Z). The height of t is defined by ht(t) = max p∈pos(t) |p|, and the size of t is defined by |t| = |pos(t)|. A leaf is a position p ∈ pos(t) such that p.1 / ∈ pos(t). We denote the subset of leaves of pos(t) by leaf(t). Given a position p ∈ pos(t), the label t(p) of t at p and the subtree t| p of t at p are defined by z(ε) = z| ε = z for all z ∈ Z, and We reserve the use of the special symbol .
is a context, if there exists exactly one p ∈ pos(t) with t(p) = ; i.e., there is exactly one occurrence of in t. The set of all such contexts is denoted by C Σ (Z). Given a context c ∈ C Σ (Z) and a tree t containing the context c a total of k times.
Finally, let us recall regular tree grammars (RTGs) [6,7]. An RTG is a tuple G = (Q, Σ, Q 0 , P ), where Q is a finite set of states such that Q ∩ Σ = ∅, Σ is a ranked alphabet of input symbols, Q 0 ⊆ Q is a set of initial states, and P ⊆ Q × T Σ (Q) is a finite set of productions. We also write productions (q, t) as The class of regular tree languages is denoted by RTL. We note that RTL coincides with the class of tree languages generated by tree automata [6,7].

Tree Substitution Grammars
Let us start with the formal definition of tree substitution grammars (TSGs) taken essentially from the natural language processing community [10,11]. TSGs have been applied to various tasks including parsing [16] and machine translation [19]. Consequently, the definitions of TSGs vary, but our definition captures the essence of the notion, while still being convenient to work with.
Next we present the derivation semantics for a TSG G = (Σ, R, F ). Essentially we start the derivation process with a tree consisting solely of a root label of R and then iteratively replace a leaf by a fragment of F with the same root label. This process can be repeated until no replacements are possible anymore. If the such obtained tree t contains only leaves that are labeled by nullary symbols, then t is part of the tree language generated by G. (2) , γ (1) , α (0) } and consider the TSG G = (Σ, {σ}, F ) with the fragments displayed in Fig. 3. The derivation presented in Fig. 3 illustrates that a derived tree can contain several leaves that still need to be independently replaced. More precisely, both occurrences of γ in the tree σ(γ, γ) are independently replaced in the displayed derivation. Example 5. Consider the TSG G from Example 2. A few derivation steps are displayed in Fig. 2. Let c α = δ(α, δ(α, )) and c β = δ(β, δ(β, )). Overall, this TSG generates the tree language Two TSGs G and G are equivalent if L(G) = L(G ). A tree language L is a tree substitution language if there exists a TSG G such that L = L(G), and it is local [6,7] if there exists a local tree grammar G such that L = L(G). The classes of all tree substitution languages and all local tree languages are denoted by TSL and LTL, respectively.

Expressive Power
In this section, we investigate the expressive power of tree substitution grammars and start with some simple tree languages that are contained in TSL. To this end, let FIN and co-FIN be the classes of all finite and all co-finite tree languages, respectively.

Theorem 6. FIN ∪ co-FIN ⊆ TSL.
Proof. Every finite tree language L ⊆ T Σ is trivially a tree substitution language via the TSG (Σ, R, Now, let L ⊆ T Σ be a co-finite tree language and T Σ \ L = {t 1 , . . . , t k } be the finitely many trees outside L. Moreover, let n > max i∈ [k] ht(t i ) be larger than the height of the tallest tree from {t 1 , . . . , t k }. We construct the TSG (Σ, R, F ) with Clearly, F is finite. Now we prove L(G) = L. For L(G) ⊆ L it is sufficient to show that t i / ∈ L(G) for every i ∈ [k]. Obviously, the fragments of F are either in L or have height at least n, which proves L(G) ⊆ L. We prove the converse L ⊆ L(G) by contradiction, so suppose that there exists t ∈ L with t / ∈ L(G). Then there also exists a smallest t ∈ L with t / ∈ L(G). Since all trees t ∈ L with ht(t ) ≤ 2n can be generated directly using a single fragment from F , we must have ht(t ) > 2n. Let P = {p ∈ pos(t ) | |p| ≤ n, ∃p ∈ pos(t ): p p , |p | > 2n} be the short positions that are prefixes to long positions, and let C = max P be the maximal (with respect to ) elements of P . We construct the unique tree f ∈ T Σ (Σ) with positions pos(f ) = {p ∈ pos(t ) | |p| ≤ 2n} \ {p ∈ pos(t ) | ∃c ∈ C : c ≺ p} and labels f (p) = t (p) for all p ∈ pos(f ). In other words, we obtain f by cutting all paths in t that have length more than 2n at length n. Obviously, f ∈ F . In addition, we observe that ht(t | p ) > n for all p ∈ C. For every p ∈ C, we thus obtain t | p ∈ L and t | p ∈ L(G) since |t | p | < |t | and t is the smallest counterexample. However, this yields that t (ε) ⇒ G f as well as f (p) ⇒ * G t | p for all p ∈ C. Altogether t (ε) ⇒ * G t , which proves that t ∈ L(G) contradicting the assumption.
Next we relate the class of tree substitution languages to the well-known classes of local and regular tree languages, respectively. Unsurprisingly, they are situated strictly between them, but the second strictness will be established later (see Corollary 10).

Theorem 7. LTL TSL ⊆ RTL.
Proof. The first inclusion holds by definition. For the latter, let G = (Σ, R, F ) be a TSG and S / ∈ Σ a new symbol. We construct an RTG G = (Σ ∪ {S}, Σ, S, P ) such that L(G ) = L(G). To this end, we use copies Σ = {σ | σ ∈ Σ} of the input symbols of Σ as states. The productions are given by P = P S ∪ P with for every σ ∈ Σ and rel(σ(t 1 , . . . , t k )) = σ(rel(t 1 ), . . . , rel(t k )) for all k ∈ N \ {0}, σ ∈ Σ k , and t 1 , . . . , t k ∈ T Σ (Σ). Clearly any derivation ξ 0 ⇒ G ξ 1 ⇒ G · · · ⇒ G ξ n of G yields a corresponding derivation rel(ξ 0 ) ⇒ G rel(ξ 1 ) ⇒ G · · · ⇒ G rel(ξ n ) of G . Together with rel(t) = t for all t ∈ T Σ and the new initial states, we obtain L(G) ⊆ L(G ). The converse is proved similarly. The first inclusion is strict because FIN ⊆ TSL by Theorem 6, but it is wellknown [6,7] that FIN ⊆ LTL. The inclusion TSL ⊆ RTL immediately yields that most interesting problems are decidable for tree substitution languages. For example, the emptiness, finiteness, inclusion, and equivalence problems are all decidable because they are decidable for regular tree languages [6,7]. We proceed with a subclass definability problem: Is it decidable whether an effectively presented tree substitution language is local? Whenever we speak about an effectively presented tree substitution language L, we assume that we are actually given a tree substitution grammar G such that Clearly, for every TSG we can construct an equivalent reduced TSG. Proof. Let G = (Σ, R, F ) be a reduced tree substitution grammar such that L(G) = L. We construct the local tree grammar G = (Σ, R, F ) with Obviously, L = L(G) ⊆ L(G ) and all fragments of F are essential for this property. Consequently, L is local if and only if L(G ) ⊆ L. Since both L(G ) and L are regular by Theorem 7 and inclusion is decidable for regular tree languages [6,7], we obtain the desired statement.

Closure Properties
In this section, we investigate the closure properties of the class of tree substitution languages. More specifically, we investigate the Boolean operations and the hierarchy for union. Unfortunately, the results are all negative, but they and, in particular, their proofs shed additional light on the expressive power of tree substitution languages. Let us start with union.

Corollary 10. LTL TSL RTL.
We demonstrated that the union of two tree substitution languages need not be a tree substitution language. Next, we ask ourselves whether additional unions increase the expressive power even further. For every k ∈ N let ∪ k -TSL = {L 1 ∪ · · · ∪ L k | L 1 , . . . , L k ∈ TSL} be the class of those tree languages that can be presented as unions of k tree substitution languages. Since ∅ ∈ TSL (see Theorem 6), we obtain ∪ 0 -TSL = ∅, ∪ 1 -TSL = TSL, and ∪ k -TSL ⊆ ∪ k+1 -TSL for every k ∈ N. Next, we show that the mentioned inclusion is actually strict, so that we obtain an infinite hierarchy.
Proof. The statement is clear for k = 0, so let k ≥ 1. Consider the ranked alphabet Σ = {σ (2) , δ (2) , α (0) } and the TSG G i = (Σ, {σ}, F i ) for every i ∈  Obviously, L = L(G 1 ) ∪ · · · ∪ L(G k+1 ) ∈ ∪ k+1 -TSL and those individual tree languages are infinite and pairwise disjoint. For the sake of a contradiction, assume that L ∈ ∪ k -TSL; i. e. there exist L 1 , . . . , L k ∈ TSL such that L = L 1 ∪ · · · ∪ L k . The pigeonhole principle establishes that there exist i ∈ [k] and m, n ∈ [k+1] with m = n such that L m ∩L i and L n ∩L i are infinite. Let G = (Σ, R, F ) be a TSG such that Let us move on to intersection. Unfortunately, TSL is not closed under intersection, but intersections of TSL become quite powerful. In particular, they allow information to be transported over unbounded distances, which can be observed from the proof.
Note how the intersection achieves a global synchronization in the proof of Theorem 13. This power makes the investigation of the intersection hierarchy difficult. We leave the strictness of the intersection hierarchy as an open problem and conclude by considering the complement.  The generated tree language is illustrated in Fig. 8. Now suppose that its complement L = T Σ (Σ) \ L(G) is a tree substitution language; i.e., L ∈ T SL. Hence there exists a TSG G = (Σ, R, F ) such that L = L(G ). Let n ∈ N be such that n > max f ∈F ht(f ). Since t = γ(A n (β)) ∈ L (see Fig. 8) there must exist a derivation γ ⇒ * G t and γ ∈ R. Since ht(t) > n at least two derivation steps are required, so γ ⇒ G γ(A k ) ⇒ + G t for some 0 ≤ k < n, which yields the subderivation A ⇒ + G A n−k (β). Similarly, we consider the tree t = γ(B(A n (α))) ∈ L (see Fig. 8), for which the derivation γ ⇒ + G γ(B(A )) ⇒ + G t for some 0 ≤ < n and the subderivation A ⇒ + G A n− (α) must exist. However, exchanging the subderivations yields the derivation

Open Problems
We showed that it is decidable whether a given tree substitution language is local. It remains open if we can also decide whether a given regular tree language is a tree substitution language. Progress on this problem will probably provide additional fine-grained insight into the expressive power of tree substitution grammars in comparison to the regular tree grammars. Another open problem concerns the intersection hierarchy. We showed that unions of tree substitution languages can progressively express more and more tree languages. A similar hierarchy also exists for intersections of tree substitution languages and we showed that the intersection of two tree substitution languages is not necessarily a tree substitution languages. However, it remains open whether there is an infinite intersection hierarchy or whether it collapses at some level.