<?xml version="1.0" standalone="yes"?>
<Paper uid="E06-1048">
  <Title>Unifying Synchronous Tree-Adjoining Grammars and Tree Transducers via Bimorphisms</Title>
  <Section position="4" start_page="377" end_page="379" type="metho">
    <SectionTitle>
2 Tree-Adjoining Grammars
</SectionTitle>
    <Paragraph position="0"> Tree adjoining grammar (TAG) is a tree grammar formalism distinguished by its use of a tree adjunction operation. Traditional presentations of TAG, which we will assume familiarity with, take the symbols in elementary and derived trees to be unranked; nodes labeled with a given non-terminal symbol may have differing numbers of children. (Joshi and Schabes (1997) present a good overview.) For example, foot nodes of auxiliary trees and substitution nodes have no children, whereas the similarly labeled root nodes must have at least one. Similarly, two nodes with the same label but differing numbers of children may match for the purpose of allowing an adjunction (as the root nodes of a1 and b1 in Figure 1). In order to integrate TAG with tree transducers, however, we move to a ranked alphabet, which presents some problems and opportunities.</Paragraph>
    <Paragraph position="1"> (In some ways, the ranked alphabet definition of TAGs is slightly more elegant than the traditional one.) Although the bulk of the later discussion integrating TAGs and transducers assumes (without loss of expressivity (Joshi and Schabes, 1997, fn. 6)) a limited form of TAG that includes adjunction but not substitution, we define the more complete form here.</Paragraph>
    <Paragraph position="2"> We will thus take the nodes of TAG trees to be labeled with symbols from a ranked alphabet F; a given symbol then has a fixed arity and a fixed</Paragraph>
    <Paragraph position="4"> number of children. However, in order to maintain information about which symbols may match for the purpose of adjunction and substitution, we take the elements of F to be explicitly formed as pairs of an unranked label e and an arity n. (For notational consistency, we will use e for unranked and f for ranked symbols.) We will notate these elements, abusing notation, as e(n), and make use of a function |* |to unrank symbols in F, so that |e(n) |= e.</Paragraph>
    <Paragraph position="5"> Tohandlefootnodes, foreachnon-nullarysymbol e(i) [?] F([?]1), we will associate a new nullary symbol e[?], which one can take to be the pair of e and [?]; the set of such symbols will be notated F[?]. Similarly, for substitution nodes,F |will be the set of nullary symbols e |for all e(i) [?] F([?]1). These additional symbols, since they are nullary, will necessarily appear only at the frontier of trees. Finally, to allow null adjoining constraints, for each f [?]F(i), we introduce a symbol f/0 also of arity i, and take F/0 to be the set of all such symbols. We will extend the function|*|to provide the unranked symbol associated with these symbols as well, so</Paragraph>
    <Paragraph position="7"> A TAG is then a quadruple &lt;F,S,I,A&gt; , where F isarankedalphabet; S[?]Fisadistinguishedinitial symbol; I isthesetofinitialtrees, afinitesubsetof T(F[?]F/0 [?]F|); and A is the set of auxiliary trees, afinitesubsetofT(F[?]F/0[?]F|[?]F[?]). Anauxiliary tree b whose root is labeled f must have exactly onenodelabeledwith|f|[?] [?]F[?] andnoothernodes labeled inF[?]; this node is its foot node, its address notated foot(b). In Figure 1, a1 and a2 are initial trees; b1 and b2 are auxiliary trees.</Paragraph>
    <Paragraph position="8"> In order to allow reference to a particular tree in the set P, we associate with each tree in P a unique index, conventionally notated with a subscripted a or b for initial and auxiliary trees respectively.</Paragraph>
    <Paragraph position="9"> This further allows us to have multiple instances of a tree in I or A, distinguished by their index.</Paragraph>
    <Paragraph position="10"> (We will abuse notation by using the index and the tree that it names interchangably.) The trees are combined by two operations, substitution and adjunction. Under substitution, a</Paragraph>
    <Paragraph position="12"> language {wcw  |w [?] {a,b}[?]}.</Paragraph>
    <Paragraph position="13"> node labeled e |(at address p) in a tree a can be replaced by an initial tree aprime with the corresponding label f at the root when |f |= e. The resulting tree, the substitution of aprime at p in a, is a[p mapsto- aprime]. Under adjunction, an internal node of a at p labeled f [?] F is split apart, replaced by an auxiliary tree b rooted in fprime when |f |= |fprime|. The resulting tree, the adjunction of b at p in a, is a[p mapsto- b[foot(b) mapsto- a/p]]. This definition (by requiring f to be in F, not F[?] or F|) maintains the standard convention, without loss of expressivity, that adjunction is disallowed at foot nodes and substitution nodes.</Paragraph>
    <Paragraph position="14"> The TAG in Figure 1 generates a tree set whose yield is the non-context-free copy language {wcw  |w [?] {a,b}[?]}. The arities of the nodes are suppressed, as they are clear from context.</Paragraph>
    <Paragraph position="15"> A derivation tree D records the operations over the elementary trees used to derive a given derived tree. Each node in the derivation tree specifies an elementary tree a, the node's child subtrees Di recordingthederivationsfortreesthatareadjoined or substituted into that tree. A method is required to record at which node in a the tree specified by child subtree Di operates. For trees recording derivations in context-free grammars, there are exactly as many substitution operations as nonterminals on the right-hand side of the rule used. Thus, child order in the derivation tree can be used to recordtheidentityofthesubstitutionnode. Butfor TAG trees, operations occur throughout the tree, and some, namely adjunctions, can be optional, so a simple convention using child order is not possible. Traditionally, the branches in the derivation treehavebeennotatedwiththeaddressofthenode in the parent tree at which the child node operates. Figure 4 presents a derivation tree (a) using this notation, along with the corresponding derived tree (b) for the string abcab.</Paragraph>
    <Paragraph position="16"> For simplicity below, we use a stripped down TAG formalism, one that loses no expressivity in weak generative capacity but is easier for analysis purposes.</Paragraph>
    <Paragraph position="17"> First, we make all adjunction obligatory, in the  to show the permutation of operable nodes.</Paragraph>
    <Paragraph position="18"> sense that if a node in a tree allows adjunction, an adjunction must occur there. To get the effect of optional adjunction, for instance at a node labeled B, we add a vestigial tree of a single node eB =B[?], which has no adjunction sites and does not itself modify any tree that it adjoins into. It thus founds the recursive structure of derivations.</Paragraph>
    <Paragraph position="19"> Second, now that it is determinate whether an operation must occur at a node, the number of children of a node in a derivation tree is determined by the elementary tree at that node; it is just the number of adjunction or substitution nodes in the tree, the OPERABLE NODES. All that is left to determine is the mapping between child order in the derivation tree and node in the elementary tree labeling the parent, that is, a permutation pi on the operable nodes (or equivalently, their addresses), so that the i-th child of a node labeled a in a derivation tree is taken to specify the tree that operates at the node pii in a. This permutation can be thought of as specified as part of the elementary tree itself. For example, the tree in Figure 3, whichrequiresoperationsatthenodesataddresses e, 12, and 2, may be associated with the permutation &lt;12,2,e&gt; . This permutation can be marked on the tree itself with numeric diacritics i, as shown in the figure.</Paragraph>
    <Paragraph position="20"> Finally, as mentioned before, we eliminate substitution (Joshi and Schabes, 1997, fn. 6). With these changes, the sample TAG grammar and derivation tree of Figures 1 and 4(a) might be expressed with the core TAG grammar and derivation tree of Figures 2 and 4(c).</Paragraph>
  </Section>
  <Section position="5" start_page="379" end_page="380" type="metho">
    <SectionTitle>
3 Tree Transducers, Homomorphisms,
</SectionTitle>
    <Paragraph position="0"/>
    <Section position="1" start_page="379" end_page="380" type="sub_section">
      <SectionTitle>
and Automata
3.1 Tree Transducers
</SectionTitle>
      <Paragraph position="0"> Informally, a TREE TRANSDUCER is a function from T(F) to T(G) defined such that the symbol at the root ofthe input tree and a current state determines an output context in which the recursive images of the subtrees are placed. Formally, we can define a transducer as a kind of functional program, that is, a set of equations characterized by the following grammar for equations Eqn. (The set of states is conventionally notated Q, with members notated q. One of the states is distinguished as the INITIAL STATE of the transducer.)1</Paragraph>
      <Paragraph position="2"> Intuitively speaking, the expressions in R(n) are right-hand-side terms using variables limited to the first n.</Paragraph>
      <Paragraph position="3"> For example, the grammar allows definition of</Paragraph>
      <Paragraph position="5"> This transducer allows for the following derivation: null</Paragraph>
      <Paragraph position="7"> The relation defined by a tree transducer with initial state q is {&lt;t,u&gt;  |q(t) = u}. By virtue of nondeterminism in the equations, multiple equations for a given state q and symbol f, tree transducers define true relations rather than merely functions.</Paragraph>
      <Paragraph position="8"> TREE HOMOMORPHISMS are a subtype of tree transducers, those with only a single state, hence essentially stateless. Other subtypes of tree transducers can be defined by restricting the trees t  transducer in terms of a set of states, an input and output ranked alphabet, and an initial state, in addition to the set of transitions, that is, defining equations. We will leave off these details, in the expectation that the sets of states and symbols can be inferred from the equations, and the initial state determined under a convention that it is the state defined in the textually first equation.</Paragraph>
      <Paragraph position="9"> Note also that we avail ourselves of consistent renaming of the variables x1, x2, and so forth, where convenient for readability.</Paragraph>
      <Paragraph position="10">  that form the right-hand sides of equations, the elements of R(n) used. A transducer is LINEAR if all such t are linear; is COMPLETE if t contains every variable in Xn; is e-FREE if t negationslash[?]Xn; is</Paragraph>
      <Paragraph position="12"> Another subcase is TREE AUTOMATA, tree transducers that compute a partial identity function; these are delabeling tree transducers that preserve the label and the order of arguments. Because they compute only the identity function, tree automata are of interest for their domains, not the mappings they compute. Their domains define tree languages, in particular, the so-called REGU-</Paragraph>
    </Section>
  </Section>
  <Section position="6" start_page="380" end_page="380" type="metho">
    <SectionTitle>
LAR TREE LANGUAGES.
</SectionTitle>
    <Paragraph position="0"/>
    <Section position="1" start_page="380" end_page="380" type="sub_section">
      <SectionTitle>
3.2 The Bimorphism Characterization of
Tree Transducers
</SectionTitle>
      <Paragraph position="0"> Tree transducers can be characterized directly in terms of equations defining a simple kind of functionalprogram, asabove. Thereisanelegantalternative characterization of tree transducers in terms of a constellation of elements of the various sub-types of transducers -- homomorphisms and automata -- we have introduced, called a bimorphism. null A bimorphism is a triple &lt;L,hi,ho&gt; , consisting of a regular tree language L (or, equivalently, a tree automaton) and two tree homomorphisms hi and ho. The tree relation defined by a bimorphism is the set of tree pairs that are generable from elements of the tree language by the homomorphisms, that is, L(&lt;L,hi,ho&gt; ) = {&lt;hi(t),ho(t)&gt; |t [?] L} .</Paragraph>
      <Paragraph position="1"> We can limit attention to bimorphisms in which the input or output homomorphisms are restricted to a certain type, linear (L), complete (C), epsilon-free (F), symbol-to-symbol (S), delabeling (D), or unrestricted (M). We will write B(I,O) where I and O characterize a subclass of homomorphisms for the set of bimorphisms for which the input homomorphism is in the subclass indicated by I and the output homomorphism is in the subclass indicated by O. Thus, B(D,M) is the set of bimorphisms for which the input homomorphism is a delabeling but the output homomorphism can be arbitrary.</Paragraph>
      <Paragraph position="2"> The tree relations definable by tree transducers turn out to be exactly this class B(D,M) (Comon et al., 1997). The bimorphism notion thus allows us to characterize the tree transductions purely in terms of tree automata and tree homomorphisms.</Paragraph>
      <Paragraph position="3"> We have shown (Shieber, 2004) that the tree relations defined by synchronous tree-substitution grammars were exactly the relations B(LC,LC).</Paragraph>
      <Paragraph position="4"> Intuitively speaking, the tree language in such a bimorphism represents the set of derivation trees for the synchronous grammar, and each homomorphism represents the relation between the derivation tree and the derived tree for one of the projected tree-substitution grammars. The homomorphismsarelinearandcompletebecausethetreere- null lation between a tree-substitution grammar derivation tree and its associated derived tree is exactly a linear complete tree homomorphism. To characterize the tree relations defined by a synchronous tree-adjoining grammar, it similary suffices to find a simple homomorphism-like characterization of the tree relation between TAG derivation trees and derived trees. In Section 5 below, we show that linear complete embedded tree homomorphisms, which we introduce next, serve this purpose.</Paragraph>
    </Section>
  </Section>
  <Section position="7" start_page="380" end_page="383" type="metho">
    <SectionTitle>
4 Embedded Tree Transducers
</SectionTitle>
    <Paragraph position="0"> Embedded tree transducers are a generalization of tree transducers in which states are allowed to take a single additional argument in a restricted manner. They correspond to a restrictive subcase of macro tree transducers with one recursion variable. We use the term &amp;quot;embedded tree transducer&amp;quot; rather than the more cumbersome &amp;quot;monadic macro tree transducer&amp;quot; for brevity and by analogy with embedded pushdown automata (Schabes and Vijay-Shanker, 1990), another automata-theoretic characterization of the tree-adjoining languages.</Paragraph>
    <Paragraph position="1"> Wemodifythegrammaroftransducerequations to add an extra argument to each occurrence of a state q. To highlight the special nature of the extra argument, it is written in angle brackets before the input tree argument. We uniformly use the otherwise unused variable x0 for this argument in the left-hand side, and add x0 as a possible right-hand side itself. Finally, right-hand-side occurrences of states may be passed an arbitrary further right-hand-side tree in this argument.</Paragraph>
    <Paragraph position="3"> Embedded transducers are strictly more expressive than traditional transducers, because the extra argument allows unbounded communication between positions unboundedly distant in depth in the output tree. For example, a simple embedded transducer can compute the reversal of a string, e.g., 1(2(2(nil))) reverses to 2(2(1(nil))). (This is not computable by a traditional tree transducer.) It is given by the following equations:</Paragraph>
    <Paragraph position="5"> This is, of course, just the normal accumulating reverse functional program, expressed as an embedded transducer. The additional power of embedded transducers is, we will show in this section, exactly what is needed to characterize the additional power that TAGs represent over CFGs in describing tree languages. In particular, we show that the relation between a TAG derivation tree and derived tree is characterized by a deterministic linear complete embedded tree transducer (DLCETT). null The relation between tree-adjoining languages and embedded tree transducers may be implicit in a series of previous results in the formal-language theory literature.3 For instance, Fujiyoshi and Kasai (2000) show that linear, complete monadic context-free tree grammars generate exactly the tree-adjoining languages via a normal form for spine grammars. Separately, the relation between context-free tree grammars and macro tree transducers has been described, where the relationship between the monadic variants of each is implicit. Thus, taken together, an equivalence between the tree-adjoining languages and the image languages of monadic macro tree transducers might be pieced together. In the present work, we define the relation between tree-adjoining languages and linear complete monadic tree transducers directly, simply, and transparently, by giving explicit constructions in both directions, carefully handling the distinction between the unranked trees of tree-adjoining grammars and the ranked trees of macro tree transducers and other important issues of detail in the constructions.</Paragraph>
    <Paragraph position="6"> Theproofrequiresreductionsinbothdirections.</Paragraph>
    <Paragraph position="7"> First, we show that for any TAG we can construct a DLCETT that specifies the tree relation between the derivation trees for the TAG and the derived 3We are indebted to Uwe M&amp;quot;onnich for this observation. trees. Then, we show that for any DLCETT we can construct a TAG such that the tree relation between the derivation trees and derived trees is related through a simple homomorphism to the DLCETT tree relation.</Paragraph>
    <Section position="1" start_page="381" end_page="382" type="sub_section">
      <SectionTitle>
4.1 From TAG to Transducer
</SectionTitle>
      <Paragraph position="0"> Given an elementary tree a with the label A at its root, let the sequence pi = &lt;pi1,...,pin&gt; be a permutation on the nodes in a at which adjunction occurs. (We use this ordering by means of the diacritic representation below.) Then, if a is an auxiliary tree, construct the equation</Paragraph>
      <Paragraph position="2"> (2) Note that the equations are linear and complete, because each variable xi is generated once as the tree a is traversed, namely at position pii in the traversal (marked with i), and the variable x0 is generated at the foot node only. Thus, the generated embedded tree transducer is linear and complete. Because only one equation is generated per tree, the transducer is trivially deterministic.</Paragraph>
      <Paragraph position="3"> By way of example, we consider the core TAG grammar given by the following trees:</Paragraph>
      <Paragraph position="5"> as they are not really components of the tree being traversed, but merely reflexes of an extrinsic ordering. But their use is benign. The same transformation can be defined, a bit more cumbersomely, keeping the permutation pi separate, by tracking the permutation and the current address p in a revised transformation floorleft*floorrightpi,p defined as follows:</Paragraph>
      <Paragraph position="7"> We then use floorleftafloorrightpi,e for the transformation of the tree a.</Paragraph>
      <Paragraph position="8">  ple grammars: (a) derivation tree for the grammar of Figure 1; (b) corresponding derived tree; (c) corresponding derivation tree for the core TAG version of the grammar in Figure 2.</Paragraph>
      <Paragraph position="9"> Starting with the auxiliary tree bA = A/0(1 B(a), 2 C(3 D(A[?]))), the adjunction sites, corresponding to the nodes labeled B, C, and D at addresses 1, 2, and 21, have been arbitrarily given a preorder permutation. We therefore construct the equation as follows:</Paragraph>
      <Paragraph position="11"> Similar derivations for the remaining trees yield the (deterministic linear complete) embedded tree transducer defined by the following set of equations: null</Paragraph>
      <Paragraph position="13"> We can use this transducer to compute the derived tree for the derivation tree a(bA(bB(eB),eC,eD)).</Paragraph>
      <Paragraph position="15"> As a final step, useful later for the bimorphism characterization of synchronous TAG, it is  straightforwardtoshowthatthetransducersoconstructed is the composition of a regular tree language and a linear complete embedded tree homomorphism. null</Paragraph>
    </Section>
    <Section position="2" start_page="382" end_page="383" type="sub_section">
      <SectionTitle>
4.2 From Transducer to TAG
</SectionTitle>
      <Paragraph position="0"> Givenalinearcompleteembeddedtreetransducer, we construct a corresponding TAG as follows: For each rule of the form</Paragraph>
      <Paragraph position="2"> we build a tree named &lt;qi, f,t&gt; . Where this tree appears is determined solely by the state qi, so we take the root node of the tree to be the state.</Paragraph>
      <Paragraph position="3"> Any foot node in the tree will also need to be marked with the same label, so we pass this information down as the tree is built inductively. The tree is therefore of the form qi/0(ceilinglefttceilingrighti) where the right-hand-side transformation ceilingleft*ceilingrighti constructs the remainder of the tree by the inductive walk of t, with the subscript noting that the root is labeled qi.</Paragraph>
      <Paragraph position="5"> Note that at x0, a foot node is generated of the proper label. (Because the equation is linear, only one foot node is generated, and it is labeled appropriately by construction.) Where recursive processing of the input tree occurs (qj&lt;t&gt; (xl)), we generate a tree that admits adjunctions at qj. The role of the diacritic k is merely to specify the permutationofoperablenodesforinterpretingderiva- null tion trees; it says that the k-th child in a derivation tree rooted in the current elementary tree is taken to specify adjunctions at this node.</Paragraph>
      <Paragraph position="6"> The trees generated by this TAG are intended to correspond to the outputs of the corresponding tree transducer. Because of the more severe constraints on TAG, in particular that all combinatorial limitations on putting subtrees together must be manifest in the labels in the trees themselves, the outputs actually contain more structure than the corresponding transducer output. In particular, the state-labeled nodes are merely for bookkeeping. A homomorphism removing these nodes gives the desired transducer output. Most importantly, then, the weak generative capacity of TAGs and LCETTs are identical.</Paragraph>
      <Paragraph position="7">  Some examples may clarify the construction.</Paragraph>
      <Paragraph position="8"> Recall the reversal embedded transducer in (1) above. The construction above generates a TAG containing the following trees. We have given themindicativenamesratherthanthecumbersome ones of the form &lt;qi, f,t&gt; .</Paragraph>
      <Paragraph position="10"> It is simple to verify that the derivation tree a(b1(b2(b2(bnil)))) derives the tree r(rprime6(2(rprime(2(rprime(1(rprime(nil)))))))) Simple homomorphisms that extract the input function symbols on the input and drop the book-keeping states on the output reduce these trees to 1(2(2(nil))) and 2(2(1(nil))) respectively, just as for the corresponding tree transducer.</Paragraph>
    </Section>
  </Section>
  <Section position="8" start_page="383" end_page="383" type="metho">
    <SectionTitle>
5 Synchronous TAGs as Bimorphisms
</SectionTitle>
    <Paragraph position="0"> The major advantage of characterizing TAG derivation in terms of tree transducers (via the compilation (2)) is the integration of synchronous TAGs into the bimorphism framework. A synchronous TAG (Shieber, 1994) is composed of a set of triples &lt;tL,tR,slurabove&gt; where the two trees tL and tR areelementarytreesandsluraboveisasetoflinksspecifying pairs of linked operable nodes from tL and tR. Without loss ofgenerality, wecan stipulate that each operable node in each tree is impinged upon by exactly one link in slurabove. (If a node is unlinked, the triple can never be used; if overlinked, a set of replacement triples can be &amp;quot;multiplied out&amp;quot;.) In this case, a projection of the triples on first or second component, with a permutation defined by the correspondingprojectionsonthelinks, isexactlya TAG as defined above. Thus, derivations proceed just as in a single TAG except that nodes linked by some link in slurabove are simultaneously operated on by paired trees derived by the grammar.</Paragraph>
    <Paragraph position="1"> In order to model a synchronous grammar formalism as a bimorphism, the well-formed derivations of the synchronous formalism must be characterizable as a regular tree language and the relation between such derivation trees and each of the paired derived trees as a homomorphism of some sort. For synchronous tree-substitution grammars, derivation trees are regular tree languages, and the map from derivation to each of the paired derived trees is a linear complete tree homomorphism.</Paragraph>
    <Paragraph position="2"> Thus, synchronous tree-substitution grammars fall in the class of bimorphisms B(LC,LC). The other direction can be shown as well; all bimorphisms in B(LC,LC) define tree relations expressible by an STSG.</Paragraph>
    <Paragraph position="3"> A similar result follows immediately for STAG.</Paragraph>
    <Paragraph position="4"> Crucially relying on the result above that the derivation relation is a DLCETT, we can use the method of Shieber (2004) directly to characterize the synchronous TAG tree relations as just B(ELC,ELC). We have thus integrated synchronous TAG with the other transducer and synchronous grammar formalisms falling under the bimorphism umbrella.</Paragraph>
  </Section>
class="xml-element"></Paper>