Regular tree grammar

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In theoretical computer science and formal language theory, a regular tree grammar (RTG)[1] 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[edit]

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 ZN, and
  • P is a set of productions of the form At, with AN, and tTΣ(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[edit]

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 t1TΣ(N) can be derived in a single step into a tree t2TΣ(N) (in short: t1G t2), if there is a context S and a production (At) ∈ P such that:

  • t1 = S[A], and
  • t2 = 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) = { tTΣ | ZG* 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[edit]

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

Let G1 = (N11,Z1,P1), where

  • N1 = {Bool, BList } is our set of nonterminals,
  • Σ1 = { true, false, nil, cons(.,.) } is our ranked alphabet, arities indicated by dummy arguments (i.e. the symbol cons has arity 2),
  • Z1 = BList is our starting nonterminal, and
  • the set P1 consists of the following productions:
    • Boolfalse
    • Booltrue
    • BListnil
    • BListcons(Bool,BList)

An example derivation from the grammar G1 is

BListcons(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 G1 is the set of all finite lists of boolean values, that is, L(G1) happens to equal TΣ1. The grammar G1 corresponds to the algebraic data type declarations

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

in the Standard ML programming language: every member of L(G1) corresponds to a Standard-ML value of type BList.

For another example, let G2 = (N11,BList1,P1P2), using the nonterminal set and the alphabet from above, but extending the production set by P2, consisting of the following productions:

  • BList1cons(true,BList)
  • BList1cons(false,BList1)

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

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

Language properties[edit]

If L1, L2 both are regular tree languages, then the tree sets L1L2, L1L2, and L1 \ L2 are also regular tree languages, and it is decidable whether L1L2, and whether L1 = L2.

Alternative characterizations and relation to other formal languages[edit]

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

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

Regular tree grammars are a generalization of regular word grammars.

See also[edit]

  • Set constraint — a generalization of regular tree grammars
  • Tree-adjoining grammar
  • A book devoted to tree grammars: Nivat, Maurice; Podelski, Andreas (1992). Tree Automata and Languages. Studies in Computer Science and Artificial Intelligence 10. North-Holland. 
  • Regular tree grammars were already described in 1968 by:
    • Brainerd, W.S. (1968). "The Minimalization of Tree Automata". Information and Control 13: 484–491. doi:10.1016/s0019-9958(68)90917-0. 
    • Thatcher, J.W.; Wright, J.B. (1968). "Generalized Finite Automata Theory with an Application to a Decision Problem of Second-Order Logic". Mathematical Systems Theory 2 (1). 
  • Applications of regular tree grammars include:
    • Instruction selection in compiler code generation:Emmelmann, Helmut (1991). "Code Selection by Regularly Controlled Term Rewriting". Code Generation - Concepts, Tools, Techniques. Workshops in Computing. Springer. pp. 3–29. 
    • A decision procedure for the first-order logic theory of formulas over equality (=) and set membership (∈) as the only predicates: Comon, Hubert (1990). "Equational Formulas in Order-Sorted Algebras". Proc. ICALP. 
    • Solving constraints about mathematical sets: Gilleron, R.; Tison, S.; Tommasi, M. (1993). "Solving Systems of Set Constraints using Tree Automata". 10th Annual Symposium on Theoretical Aspects of Computer Science. LNCS 665. Springer. pp. 505–514. 
    • The set of all truths expressible in first-order logic about a finite algebra is always a regular tree language: Burghardt, Jochen (2002). "Axiomatization of Finite Algebras". Advances in Artificial Intelligence. LNAI 2479. Springer. pp. 222–234. ISBN 3-540-44185-9. 
  • Algorithms on regular tree grammars are discussed from an efficiency-oriented view in: Aiken, A.; Murphy, B. (1991). "Implementing Regular Tree Expressions". ACM Conference on Functional Programming Languages and Computer Architecture. pp. 427–447. 
  • Given a mapping from trees to weights, 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: Knuth, D.E. (1977). "A Generalization of Dijkstra's Algorithm". Information Processing Letters 6 (1): 1–5. doi:10.1016/0020-0190(77)90002-3. . 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.
  • Regular tree automata have been generalized to admit equality tests between sibling nodes in trees: Bogaert, B.; Tison, Sophie (1992). "Equality and Disequality Constraints on Direct Subterms in Tree Automata". Proc. 9th STACS. LNCS 577. Springer. pp. 161–172. 
  • Allowing equality tests between deeper nodes leads to undecidibility: Tommasi, M. (1991), Automates d'Arbres avec Tests d'Égalités entre Cousins Germains, LIFL-IT 

References[edit]

  1. ^ Regular tree grammars as a formalism for scope underspecification. CiteSeerX: 10.1.1.164.5484. 
  2. ^ Alur, R.; Madhusudan, P. (2004). "Visibly pushdown languages". Proceedings of the thirty-sixth annual ACM symposium on Theory of computing - STOC '04. pp. 202–211. doi:10.1145/1007352.1007390. ISBN 1581138520.  edit Sect.4, Theorem 5,
  3. ^ Alur, R.; Madhusudan, P. (2009). "Adding nesting structure to words". Journal of the ACM 56 (3): 1–43. doi:10.1145/1516512.1516518.  edit Sect.7
  4. ^ Comon et al, Tree Automata Techniques and Applications, 1997

External links[edit]