Regular tree grammar

In theoretical computer science and formal language theory, a regular tree grammar (RTG) is a formal grammar that describes a set of directed trees, or terms. A regular word grammar can be seen as a special kind of regular tree grammar, describing a set of single-path trees.

Definition

A regular tree grammar G is defined by the tuple

G = (N, Σ, Z, P),

where

• N is a set of nonterminals,
• Σ is a ranked alphabet (i.e., an alphabet whose symbols have an associated arity) disjoint from N,
• Z is the starting nonterminal, with Z ∈ N, and
• P is a set of productions of the form A → t, with A ∈ N, and t ∈ T_Σ(N), where T_Σ(N) is the associated term algebra, i.e. the set of all trees composed from symbols in Σ ∪ N according to their arities, where nonterminals are considered nullary.

Derivation of trees

The grammar G implicitly defines a set of trees: any tree that can be derived from Z using the rule set P is said to be described by G. This set of trees is known as the language of G. More formally, the relation ⇒_G on the set T_Σ(N) is defined as follows:

A tree t₁∈ T_Σ(N) can be derived in a single step into a tree t₂ ∈ T_Σ(N) (in short: t₁ ⇒_G t₂), if there is a context S and a production (A→t) ∈ P such that:

• t₁ = S[A], and
• t₂ = S[t].

Here, a context means a tree with exactly one hole in it; if S is such a context, S[t] denotes the result of filling the tree t into the hole of S.

The tree language generated by G is the language L(G) = { t ∈ T_Σ | Z ⇒_G* t }.

Here, T_Σ denotes the set of all trees composed from symbols of Σ, while ⇒_G* denotes successive applications of ⇒_G.

A language generated by some regular tree grammar is called a regular tree language.

Examples

File:Example derivation tree of a term from a regular tree grammar svg.svg

Example derivation tree from G₁ in linear (upper left table) and graphical (main picture) notation

Let G₁ = (N₁,Σ₁,Z₁,P₁), where

• N₁ = {Bool, BList } is our set of nonterminals,
• Σ₁ = { true, false, nil, cons(.,.) } is our ranked alphabet, arities indicated by dummy arguments (i.e. the symbol cons has arity 2),
• Z₁ = BList is our starting nonterminal, and
• the set P₁ consists of the following productions:
  • Bool → false
  • Bool → true
  • BList → nil
  • BList → cons(Bool,BList)

An example derivation from the grammar G₁ is

BList ⇒ cons(Bool,BList) ⇒ cons(false,cons(Bool,BList)) ⇒ cons(false,cons(true,nil)).

The image shows the corresponding derivation tree; it is a tree of trees (main picture), whereas a derivation tree in word grammars is a tree of strings (upper left table).

The tree language generated by G₁ is the set of all finite lists of boolean values, that is, L(G₁) happens to equal T_Σ1. The grammar G₁ corresponds to the algebraic data type declarations (in the Standard ML programming language):

  datatype Bool
    = false
    | true
  datatype BList
    = nil
    | cons of Bool * BList

Every member of L(G₁) corresponds to a Standard-ML value of type BList.

For another example, let G₂ = (N₁,Σ₁,BList1,P₁ ∪ P₂), using the nonterminal set and the alphabet from above, but extending the production set by P₂, consisting of the following productions:

• BList1 → cons(true,BList)
• BList1 → cons(false,BList1)

The language L(G₂) is the set of all finite lists of boolean values that contain true at least once. The set L(G₂) has no datatype counterpart in Standard ML, nor in any other functional language. It is a proper subset of L(G₁). The above example term happens to be in L(G₂), too, as the following derivation shows:

BList1 ⇒ cons(false,BList1) ⇒ cons(false,cons(true,BList)) ⇒ cons(false,cons(true,nil)).

Language properties

If L₁, L₂ both are regular tree languages, then the tree sets L₁ ∩ L₂, L₁ ∪ L₂, and L₁ \ L₂ are also regular tree languages, and it is decidable whether L₁ ⊆ L₂, and whether L₁ = L₂.

Alternative characterizations and relation to other formal languages

Rajeev Alur and Parthasarathy Madhusudan related a subclass of regular binary tree languages to nested words and visibly pushdown languages.

The regular tree languages are also the languages recognized by bottom-up tree automata and nondeterministic top-down tree automata.

Regular tree grammars are a generalization of regular word grammars.

Applications

Applications of regular tree grammars include:

• Instruction selection in compiler code generation
• A decision procedure for the first-order logic theory of formulas over equality (=) and set membership (∈) as the only predicates
• Solving constraints about mathematical sets
• The set of all truths expressible in first-order logic about a finite algebra (which is always a regular tree language)

See also

• Set constraint – a generalization of regular tree grammars
• Tree-adjoining grammar

Further reading

• Regular tree grammars were already described in 1968 by:
• A book devoted to tree grammars is:
• Algorithms on regular tree grammars are discussed from an efficiency-oriented view in:
• Given a mapping from trees to weights, Donald Knuth's generalization of Dijkstra's shortest-path algorithm can be applied to a regular tree grammar to compute for each nonterminal the minimum weight of a derivable tree. Based on this information, it is straightforward to enumerate its language in increasing weight order. In particular, any nonterminal with infinite minimum weight produces the empty language. See:
• Regular tree automata have been generalized to admit equality tests between sibling nodes in trees. See:
• Allowing equality tests between deeper nodes leads to undecidability. See: