DOCSLIB.ORG

Modular Tree Transducers

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Modular Tree Transducers 267 Fundamental Study Modular tree transducers Joost Engelfriet Departmenf of Conrpurer Science, Leidm Uniuersics, Niels Bohreg 1, NL-2300 RA Leiden, Nerherlonds Heiko Vogler Lehrsruhl fTir In,formarik II, R WTH Aachen, Ahornrrr. 55, D-5100 Aacben, FRG Communicated by M. Nivat Received May 198s Revised January 1589 Absrracr Engelfrict, J. and H. Vogler, Modular tree transducers, Theoretical Computer Science 7S (1991) 267-303. A new tree transducer, called a modular tree transducer, is introduced. This device specifies operations on trees and ca be considered as a formalization of the concept of nesred simultaneous primitive recursion on trees. Roughly speaking, a modular tree transducer is a specie.1 left-linear and non-overlapping term rewriting system of which the set of ruies is partitioned into modules, es;h module being equipped with a non-negative integer: the xmber of the module. Then, a module with number i may cell modules with numbers oat !ess than i. Three properties are proved: (I) modular tree transducers compote exactly the (inductiv-ely defined) class of primitive recursive functions on trees; (2) the number of moduies in modular tree transducers induces a strict hierarchy on the class of all modular tree transductions, and (3) by appropriate!g res:tictinr the c4iing s~~‘ure between modules, modular tree transducers characterize the compositions of macro tree transducers where the number of modules and the number of compositions coinade. Content5 1. introduction........................._._...._...________...._,_._..___._._.___.... 2. Preliminaries...............__..____.__...._.____..._.._....,..___.____.____._._._. 2.1. General nations . _ . _ . _ . 2.2. Ranked alphabets. trees. trz-‘ f~?tccti-_r.s. aigebras __.~.__.._.~._.._._.._~__..__.... 2.3. Primitive recar;i,xe functions over iU. _ . _ . 2.4. L~pprograms......................._..._~.._.__.__._.._.___.___~_..___.____. 3. Basic definmons and examples _.. _. __._ .___ __ _._. _.. __. 4. Primititre recuxive tree functions . “. .~. ___ __. _. _I _ ._. _._. ._. 5. Cfiaractenzatton of PRec by modular tree transducers . _._. __ _ _._. _ __. __ I __. 5.1. Modular tree transductions are primitive recursiw iree functions _”_. __ _ _ _ _. 5.2. Primitire recursive tree functions are in ModT, _ . _ . __ _ . _. __ . .I _ _. 6. Hierarchy of modular tree transductions _ _ . _ . _. _ _ _ __ _. __. _, 7.Callingrestrictedmhdutartree~nducers .___.__ I . .._________I ______ ~..,_._ __~.~_..,, 8. Conclusions . _ . _ _ __ ___. ______._...._...___.___.___............ References _ . __~~~~~~“~___.~~“._____~~~__~~__~~_.~~~.....~...... 0304-3975/91/SO3.50 Q 199:--Elsevim Science Publishers B.V. (North-Holland; In computer science one is often faced wirh the task of defining a function on tree-structured objects, e.g., as a part of a search algorithm [23], as semantic function in denotational semantics [35. 161 (cf. e.g., 1223 for a functional compiler description in a denotationa! way), oras operation in an abstract data type [24]. If such functions arise from practical problems in a natural way, then frequently it is possible to specify thetn by primitive recursion, i.e., recursion on the structure of the tree- structured object, Thus, every such function .I‘ has a distinguished argument, called the “recursion argument”, which keeps the tree-structured object; we will call the other arg!tments “(context) parameters”. In a fictive metalanguage, the definition off’ may have the form of a case analysis on the structure of the actual value of the recursion argument. Thus, if f has arity r+ 1 and the first argument off is its recursion argument, the definition off looks like .f(x,Y ,,..., y,)=casexof . e, 1.. , Q): expr, ; (*) . end witete x is the recursion argument, +rC9. , yr are the context parameters, and 6(x,, . , xk) describes the structure of a tree in which S is the symbol (with rank k 3 0) labelling the root, and the variables xi,. , x, represent the subtrees. In general, the expression expr, is built up from recursive calls off; calls of functions that are simultaneons!y defined with A calls of previously defined functions, calls of basic functions, the snbtree variables x,, . , xbr and the parameters y,, . , y,. haoreover, since the recursion is primitive, the recursion argument of every recursive call off and every ca!l of a simultaneously defined function is one of the subtree variables. (For previousiy defined functions there is no such restriction.) Note that calls of functions may occur nested in parameters of functions. The dots i~piescnt combinations y(x,, . , x,): expr, for structures different from 8(x,, . _,xL). Intuitively, the expression expr, specifies the value off( 1, a,, . , a,) for every tuple n, , . , n, of values with appropriate type whenever the actual value t of the recursion argument has the structure 6(x,, . , xkf, i.e., the form 6(s,, _ . _, sk) for some trees S,,*..,S& Since we are only interested in devices that formalize operations on trees, also context parameters are of type tree (thus, a,, . , a, are trees). Moreover, we do not specify a particular semantic dostain in which the basic functions are interpreted. Rather we represent every k-ary basic function by a symbol with rank k This amounts to the assumption that the results of our functions are also of type tree. The informal function description (*j follows the concept of nested simultaneous primitive recursion on trees. Ry means of examples we wiil now illustrate the features involved in this concept. Example. We consider the rnnked alphabet V = {o”‘, CT”“}where the superscripts indicate the ranks of the symbols, and we work with binary trees over 2. Figure 1 shows an example of such a tree; the dotted line indicates the so-called “left spine of the tree” and the dashed lines enclose the so-called “l-subtrees”; in a similar way we can identify the “right spine of the tree” and the “r-subtrees”. Fig. 1. Binary tree over (r and a wi:h left spin? and I-sobtrees. (1) We define the unary operation mirror by using the basic concept of prhiriae recursioon (without nested calls or simultaneous definitions of functions). Mirror takes binary trees over P as arguments and transforms the left spine into a right spine without changing the I-subtrees; e.g., if t,, f,, and r3 are binary trees; then mirror(o(cr(o(q t,), t2), ti)) = o(r,, u(tz. o(t,, a))). Mirror can be specified by the fo!lowing case analysis: mirror(x) =ease X Of u(x,, x2): 0(x,, mirror!x,)); a: a end Here, expi,, = 17(.6, mirior(x,)) and expr, = o. Note that the recursion argument of the recursive call of mirror in expr,_ is the subtree variable X, . Note also that the symbofs D and CYare used both as part of tree structures and as basic function symbols. Er’o auxiliary functions are involved In expr, and expr,. iS) We describe the unary operations ane and zero by means of simuiraneous primih’ce recursion. Both operations take binaty trees as arguments, attach inZ?rma- tion above every symbol (namely, the unaty symbols 1 and 0. respestiveefy). and afterwards call the other operation. The operaiion one attaches a 1 to every symbol ?Hl J, En#rgnrr. jf, 1’bgkr thar is at an even disttince from the root. om( x) = case x of a(x,, x2): l(o(zero(x,), zero(xz))); 01: l(n) eml zero(x) = case x of a(x,, x2): O(o(one(x,),one(xz))): a: O(a) end (3) We program the binary operation shovel by using nested primitive recursion. Shovel takes binary trees s, and s> (over Z) as recursion argument and parameter, respectively, and it shovds the I-subtrees of s, on top of s-.; e.g., if s, = u(o(o(o, rr), r2), r,), then shovehs,, s2)= cr(l,, ff(fz, o(t,, s,))) (cf. Fig. 2). Thus, for a tree s, a call shovel(s, CY)transforms the left spine of s into a right spine and reverses the order of the I-subtrees. shovehx, y) = case x of G-(X,, xzj: shovel(x,, a(xz, y)); cx:y end This demonstrates a very simple form of nesting: the basic function o is called in the parameter of the call of shovel. A more complicated form of nested recursion is obtained by taking expr, equal to shovehx,, o(shovel&, w)? y)). In this case, the call shovei(s, o) transforms :he left spire of s into a right spine, reverses the order of the I-subtrees, and recursively applies this same operation to the I-subtrees. shovei / \ / “\A s2 /“Y, = /“\ t2 /o\ t2 t/o\ ,=\ s2 cx t1 Fig. 2. Application of shovel to 5: =u(o(u(e, r,), I?), i,) and s2 with the result rr(t,, u(I*, o(t3, So))). Quite a number of different models have been studied to form..lize such primitive recursion based descriptions of operations on trees. In its simplest form, the descrip- tion method has been formalized by generalized syntax-directed translation schemes [l, 23, top-down tree transducers [36,34], and attribute grammars with synthesized attributes only [26]. Operations like mirror, one, and zero can be specified . >ec:1 of the four mentioned formalisms. In fact, these formal models are equivalem ,.r..ir respect to their transformational power [29, 5, 371. However, for the description of an operation like shovel, more subtle devices are needed: they should be able to handle context information.
Load more

Recommended publications
  • Tree Automata Techniques and Applications
    Tree Automata Techniques and Applications Hubert Comon Max Dauchet Remi´ Gilleron Florent Jacquemard Denis Lugiez Sophie Tison Marc Tommasi Contents Introduction 7 Preliminaries 11 1 Recognizable Tree Languages and Finite Tree Automata 13 1.1 Finite Tree Automata . 14 1.2 The pumping Lemma for Recognizable Tree Languages . 22 1.3 Closure Properties of Recognizable Tree Languages . 23 1.4 Tree homomorphisms . 24 1.5 Minimizing Tree Automata . 29 1.6 Top Down Tree Automata . 31 1.7 Decision problems and their complexity . 32 1.8 Exercises . 35 1.9 Bibliographic Notes . 38 2 Regular grammars and regular expressions 41 2.1 Tree Grammar . 41 2.1.1 Definitions . 41 2.1.2 Regular tree grammar and recognizable tree languages . 44 2.2 Regular expressions. Kleene’s theorem for tree languages. 44 2.2.1 Substitution and iteration . 45 2.2.2 Regular expressions and regular tree languages. 48 2.3 Regular equations. 51 2.4 Context-free word languages and regular tree languages . 53 2.5 Beyond regular tree languages: context-free tree languages . 56 2.5.1 Context-free tree languages . 56 2.5.2 IO and OI tree grammars . 57 2.6 Exercises . 58 2.7 Bibliographic notes . 61 3 Automata and n-ary relations 63 3.1 Introduction . 63 3.2 Automata on tuples of finite trees . 65 3.2.1 Three notions of recognizability . 65 3.2.2 Examples of the three notions of recognizability . 67 3.2.3 Comparisons between the three classes . 69 3.2.4 Closure properties for Rec£ and Rec; cylindrification and projection .
    [Show full text]
  • Equivalence of Deterministic Top-Down Tree-To-String Transducers (Ydt Trans- Ducers)
    Equivalence of Deterministic Top-Down Tree-to-String Transducers is Decidable Helmut Seidl Sebastian Maneth Gregor Kemper Fakultat¨ fur¨ Informatik School of Informatics Fakultat¨ fur¨ Mathematik TU Munchen¨ University of Edinburgh TU Munchen¨ Garching, Germany Edinburgh, UK Garching, Germany Email: [email protected] Email: [email protected] Email: [email protected] Abstract We show that equivalence of deterministic top-down tree-to-string transducers is decidable, thus solving a long standing open problem in formal language theory. We also present efficient algorithms for subclasses: polynomial time for total transducers with unary output alphabet (over a given top-down regular domain language), and co- randomized polynomial time for linear transducers; these results are obtained using techniques from multi-linear algebra. For our main result, we prove that equivalence can be certified by means of inductive invariants using polynomial ideals. This allows us to construct two semi-algorithms, one searching for a proof of equivalence, one for a witness of non-equivalence. Furthermore, we extend our result to deterministic top-down tree-to-string transducers which produce output not in a free monoid but in a free group. I. INTRODUCTION Transformations of structured data are at the heart of functional programming [1], [2], [3], [4], [5] and also application areas such as compiling [6], document processing [7], [8], [9], [10], [11], [12], [13], automatic translation of natural languages [14], [15], [16], [17] or even cryptographic protocols [18]. The most fundamental model of such transformations is given by (finite-state tree) transducers [19], [6]. Transducers traverse the input by means of finitely many mutually recursive functions — corresponding to finitely many states.
    [Show full text]
  • Programming Using Automata and Transducers
    University of Pennsylvania ScholarlyCommons Publicly Accessible Penn Dissertations 2015 Programming Using Automata and Transducers Loris D'antoni University of Pennsylvania, [email protected] Follow this and additional works at: https://repository.upenn.edu/edissertations Part of the Computer Sciences Commons Recommended Citation D'antoni, Loris, "Programming Using Automata and Transducers" (2015). Publicly Accessible Penn Dissertations. 1677. https://repository.upenn.edu/edissertations/1677 This paper is posted at ScholarlyCommons. https://repository.upenn.edu/edissertations/1677 For more information, please contact [email protected]. Programming Using Automata and Transducers Abstract Automata, the simplest model of computation, have proven to be an effective tool in reasoning about programs that operate over strings. Transducers augment automata to produce outputs and have been used to model string and tree transformations such as natural language translations. The success of these models is primarily due to their closure properties and decidable procedures, but good properties come at the price of limited expressiveness. Concretely, most models only support finite alphabets and can only represent small classes of languages and transformations. We focus on addressing these limitations and bridge the gap between the theory of automata and transducers and complex real-world applications: Can we extend automata and transducer models to operate over structured and infinite alphabets? Can we design languages that hide the complexity of these formalisms? Can we define executable models that can process the input efficiently? First, we introduce succinct models of transducers that can operate over large alphabets and design BEX, a language for analysing string coders. We use BEX to prove the correctness of UTF and BASE64 encoders and decoders.
    [Show full text]
  • Categorical Semantics and Composition of Tree Transducers
    Categorical semantics and composition of tree transducers Dissertation zur Erlangung des akademischen Grades Doktor rerum naturalium (Dr. rer. nat.) vorgelegt an der Technischen Universit¨at Dresden Fakult¨at Informatik eingereicht von Diplom-Mathematiker Claus Jurgensen¨ geboren am 05. Mai 1966 in Kappeln an der Schlei Gutachter: Prof. Dr.-Ing. habil. Heiko Vogler, Technische Universit¨at Dresden Prof. Dr. rer. nat. habil. Horst Reichel, Technische Universit¨at Dresden Prof. Dr. Zolt´an Ful¨¨ op, Universit¨at Szeged, Ungarn Tag der Verteidigung: 30.01.2004 Dresden im Oktober 2003 ii Acknowledgments This dissertation would not have been written without the support from many people. I am grateful to Heiko Vogler for accepting the supervision of this thesis and for providing ideal conditions for doing research. I am obliged to Zolt´an Ful¨¨ op and Horst Reichel for accepting to be referees. Life in Dresden would not be fun without a number of people. My office- mates Lutz Straßburger, Bj¨orn Borchardt and Igor Tarasyuk somehow put up with me for some years. I am particularly thankful to Janis Voigtl¨ander, the most critical reader of my papers: His discerning remarks have always been very helpful to me. I have also been fortunate to share Dresden with Armin Kuhnemann,¨ Enrico Bormann, Alexandre Scalzitti, Andreas Maletti, and Kai Brunnler.¨ This thesis would not exist without the support of Gwendoline Blandin. During all the time she has been a continuous source of love and inspiration. This PhD thesis has been written with the financial support of the post- graduate program Specification of discrete processes and systems of processes by operational models and logics (GRK 334) of the German Research Com- munity (DFG).
    [Show full text]
  • Theory and Applications of Tree Languages
    Contributions to the Theory and Applications of Tree Languages Johanna H¨ogberg Ph.D. Thesis, May 2007 Department of Computing Science Ume˚a University Department of Computing Science Ume˚aUniversity SE-901 87 Ume˚a,Sweden Copyright c J. H¨ogberg, 2007 Except Paper I, c Springer-Verlag, 2003 Paper II, c Elsevier, 2007 Paper III, c F. Drewes, J. H¨ogberg, 2007 Paper IV, c World Scientific, 2007 Paper V, c Springer-Verlag, 2007 Paper VI, c Springer-Verlag, 2007 Paper VII, c Springer-Verlag, 2005 Paper VIII, c Springer-Verlag, 2007 ISBN 978-91-7264-336-9 ISSN 0348-0542 UMINF 07.07 Printed by Solfj¨adernOffset, Ume˚a,2007 Preface The study of tree languages was initiated in the late s and was originally motivated by various problems in computational linguistics. It is presently a well-developed branch of formal language theory and has found many uses, including natural language processing, compiler theory, model checking, and tree-based generation. This thesis is, as its name suggests, concerned with theoretical as well as practical aspects of tree languages. It consists of an opening introduction, written to provide motivation and basic concepts and terminology, and eight papers, organised into three parts. The first part treats algorithmic learning of regular tree languages, the second part is concerned with bisimulation minimisation of nondeterministic tree automata, and the third part is devoted to tree-based generation of music. We now summarise the contributions made in each part, and list the papers included therein. More detailed summaries of the individual papers are given in Chapter 3.
    [Show full text]
  • Three Hierarchies of Transducers
    Math. SystemsTheory 15, 95-125 (1982) Mathematical Systems Theory Three Hierarchies of Transducers Joost Engelfriet Twente Universityof Technology,Enschede, The Netherlands Abstract. Composition of top-down tree transducers yields a proper hierarchy of transductions and of output languages. The same is true for ETOL systems (viewed as transducers) and for two-way generalized sequential machines. 1. Introduction Soon after the introduction of the top-down tree transducer [35, 40], as a model of syntax-directed translation [4], one of the main problems turned out to concern their composition. In fact, the class of top-down tree transductions is not closed under composition [35, 40] unless certain restrictions or extensions are added to the main model. Thus the class of deterministic top-down tree transducers becomes closed under composition when the transducers are restricted to be total [35] or extended to have regular look-ahead [17]. A similar statement holds for linear (noncopying) top-down tree transducers. These phenomena are mainly due to the fact that a top-down tree transducer cannot handle nondeterminism followed by copying, cf. [16, 9]. Given the nonclosure of the class of tree transducers under composition, one may ask whether composition of tree transducers gives rise to a proper hierarchy. In other words the natural question arises whether n+ 1 transducers are more powerful than n, or whether perhaps there exists a constant N such that any sequence of tree transducers can be simulated by a sequence of at most N tree transducers. In this paper we prove that n + 1 tree transducers are more powerful than n (as conjectured in [32, 9, 33]).
    [Show full text]
  • Decision Problems of Tree Transducers with Origin Emmanuel Filiot, Sebastian Maneth, Pierre-Alain Reynier, Jean-Marc Talbot
    Decision problems of tree transducers with origin Emmanuel Filiot, Sebastian Maneth, Pierre-Alain Reynier, Jean-Marc Talbot To cite this version: Emmanuel Filiot, Sebastian Maneth, Pierre-Alain Reynier, Jean-Marc Talbot. Decision problems of tree transducers with origin. Information and Computation, Elsevier, 2018, 261, pp.311-335. 10.1016/j.ic.2018.02.011. hal-02093317 HAL Id: hal-02093317 https://hal.archives-ouvertes.fr/hal-02093317 Submitted on 8 Apr 2019 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Decision Problems of Tree Transducers with Origin Emmanuel Filiota, Sebastian Manethb, Pierre-Alain Reynier1, Jean-Marc Talbot1 aUniversit´eLibre de Bruxelles & FNRS bUniversity of Edinburgh cAix-Marseille University & CNRS Abstract A tree transducer with origin translates an input tree into a pair of output tree and origin information. The origin information maps each node in the output tree to the unique node in the input tree that created it. In this way, the implementation of the transducer becomes part of its semantics. We show that the landscape of decidable properties changes drastically when origin information is added. For instance, equivalence of nondeterministic top- down and MSO transducers with origin becomes decidable.
    [Show full text]
  • Underspecified Computation of Normal Forms
    International Conference on Rewriting Techniques and Applications 2010 (Edinburgh), pp. 177-192 http://rewriting.loria.fr/rta/ COMPUTING RELATIVE NORMAL FORMS IN REGULAR TREE LANGUAGES ALEXANDER KOLLER 1 AND STEFAN THATER 1 1 Saarland University Saarbrücken, Germany E-mail address: [email protected] E-mail address: [email protected] ABSTRACT.We solve the problem of computing, out of a regular language L of trees and a rewriting system R, a regular tree automaton describing the set L′ ⊆ L of trees which cannot be R-rewritten into a tree in L. We call the elements of L′ the relative normal forms of L. We apply our algorithm to the problem of computing weakest readings of sentences in computational linguistics, by approximating logical entailment with a rewriting system, and give the first efficient and practically useful algorithm for this problem. This problem has been open for 25 years in computational linguistics. 1. Introduction One key task in computational linguistics is to represent the meaning of a natural language sentence using some formal representation (reading), and to model inference on the level of natural language [1] as inference on the corresponding meaning representations. The classical approach [2] uses logical languages, such as first or higher order predicate logic, to represent sentence meanings. But when the sentence is ambiguous, it is often infeasible to explicitly enumerate all the different readings: The number of readings is worst-case exponential in the length of the sentence, and it is not uncommon for a sentence to have millions of readings if they contain a number of ambiguous constituents.
    [Show full text]
  • Foundations of Finite Symbolic Tree Transducers
    The Logic in Computer Science Column by Yuri Gurevich Microsoft Research One Microsoft Way, Redmond WA 98052, USA [email protected] Foundations of Finite Symbolic Tree Transducers Margus Veanes Nikolaj Bjørner∗ Abstract Finite transducers on trees are fundamental to computer science. They form the basis of many applications that manipulate strings and trees. The conventional representation of finite transducers assume a finite set of states and a finite alphabet. Classical algorithms and representations make essen- tial use of both of these assumptions. In many cases, the complexity of the algorithms is computed based on the number of states and alphabet size. But how important are these assumptions really for the main operations and de- cision problems? We have recently pursued applications of finite transducers in the context of web security as a foundation for sanitization of potentially malicious data. For these applications we have found that lifting the finite alphabet restriction to be useful to enable efficient symbolic analysis and we have developed symbolic counter-parts of the main classical operations on finite automata. We here define Symbolic Tree Transducers as a gener- alization of Regular Transducers as finite state input-output tree automata with logical constraints over a background theory. The background theory ∗Microsoft Research, Redmond, WA, USA {margus,nbjorner}@microsoft.com is a parameter of the formalization. We examine key closure properties of Symbolic Tree Transducers and we develop a composition algorithm and an equivalence decision procedure for single-valued transducers. 1 Introduction State machines are fundamental to computer science. General computations are captured by Abstract State Machines [20].
    [Show full text]
  • Equivalence Problems for Tree Transducers: a Brief Survey
    Equivalence Problems for Tree Transducers: A Brief Survey Sebastian Maneth School of Informatics University of Edinburgh [email protected] The decidability of equivalence for three important classes of tree transducers is discussed. Each class can be obtained as a natural restriction of deterministic macro tree transducers (MTTs): (1) no context parameters, i.e., top-down tree transducers, (2) linear size increase, i.e., MSO definable tree transducers, and (3) monadic input and output ranked alphabets. For the full class of MTTs, decid- ability of equivalence remains a long-standing open problem. 1 Introduction The macro tree transducer (MTT) was invented independently by Engelfriet [20, 29] and Courcelle [13, 14] (see also [37]). As a model of syntax-directed translations, MTTs generalize the attribute grammars of Knuth [46]. Note that one (annoying) issue of attribute grammars is that they can be circular; MTTs always terminate. Macro tree transducers are a combination of context-free tree grammars, invented by Rounds [57] and also known as “macro tree grammars” [34], and the top-down tree transducer of Rounds and Thatcher [58, 67]: the derivation of the grammar is (top-down) controlled by a given input tree. In terms of a top-down transducer, the combination is obtained by allowing nesting of state calls in the rules (similar to the nesting of nonterminals in the productions of context-free tree grammars). Top- down tree transducers generalize to trees the finite state (string) transducers (also known as “generalized sequential machines”, or GSMs, see [38, 8]). In terms of formal languages, compositions of MTTs give rise to a large hierarchy of string languages containing, e.g., the IO and OI hierarchies (at level one they include the indexed languages of Aho [1]), see [22].
    [Show full text]
  • Pushdown Machines for the Macro Tree Transducer
    Theoretical Computer Science 42 (1986) 251-368 251 North-Holland PUSHDOWN MACHINES FOR THE MACRO TREE TRANSDUCER Joost ENGELFRIET* and Heiko VOGLER** Department of Computer Sciences, Twente University of Technology, 7500 AE Enschede, The Netherlands Communicated by M. Nivat Received February 1985 Abstract. The macro tree transducer can be considered as a system of recursive function procedures with parameters, where the recursion is on a tree (e.g., the syntax tree of a program). We investigate characterizations of the class of tree (tree-to-string) translations which is induced by macro tree transducers (macro tree-to-string transducers, respectively). For this purpose we define several pushdown machines of which the control is recursive without parameters, or even iterative, and which work on a generalized pushdown as storage. Because of the relevance for semantics of programming languages, we stress (besides the nondeterministic case) the study of machines for the total deterministic macro tree(-to-string) transducer, which translates every input tree into exactly one output tree (string, respectively). Finally, we characterize the n-fold composition of total deterministic macro tree transducers by recursive pushdown machines with an iterated pushdown as storage, which is a pushdown of pushdowns of.. of pushdowns. Contents 1. Introduction ...................................................................... 252 2. Preliminaries ...................................................................... 259 2.1. Generalnotation.. ...........................................................
    [Show full text]
  • Macro Tree Transducers
    JOURNAL OF COMPUTER AND SYSTEM SCIENCES 31, 71-146 (1985) Macro Tree Transducers JOOST ENGELPRIET* AND HEIKO VOGLER*' Twente University of Technology, Department of Computer Science, P.O. Box 217, 7500 A.5 Enschede, The Netherlands Received October 29, 1982; accepted April 23, 1985 Macro tree transducers are a combination of top-down tree transducers and macro gram- mars. They serve as a model for syntax-directed semantics in which context information can be handled. In this paper the formal model of macro tree transducers is studied by investigating typical automata theoretical topics like composition, decomposition, domains, and ranges of the induced translation classes. The extension with regular look-ahead is con- sidered. 0 1985 Academic Press, Inc. 1. INTRODUCTION Macro tree transducers were introduced in [15, S] combining the features of topdown tree transducers [34, 36, 12,4] and macro grammars [23,20]. In fact, macro tree transducers are the generalization of topdown tree-to-string trans- ducers to trees according to the generalization method described in [13, 9, 15-j. Conceptually, they serve as a model for syntax-directed translations in which con- text information can be handled. Hence, it is reasonable to consider macro tree transducers as a formalization of certain aspects of denotational semantics and attribute grammars. From the program schematic point of view macro tree trans- ducers are systems of recursive procedures with parameters: the first (“syntactic”) parameter is of type T, (i.e., tree over alphabet C), representing a derivation of an underlying context-free grammar, and all other (“context”) parameters are of type T,, representing elements of a semantic domain.
    [Show full text]