Modular Grammar Design with Typed Parametric Principles

Transcription

1 11 Modular Grammar Design with Typed Parametric Principles Ralph Debusmann, Denys Duchier and Andreas Rossberg Abstract This paper introduces a type system for Extensible Dependency Grammar (xdg) (Debusmann et al., 2004), a new, modular grammar formalism based on dependency grammar. As xdg is based on graph description, our emphasis is on capturing the notion of multigraph, a tuple of arbitrary many graphs sharing the same set of nodes. An xdg grammar consists of the stipulation of an extensible set of parametric principles, which yields a modular and compositional approach to grammar design. Keywords grammar formalisms, dependency grammar, type systems 11.1 Introduction Extensible Dependency Grammar (xdg) (Debusmann et al., 2004) is a general framework for dependency grammar, with multiple levels of linguistic representations called dimensions. Its approach, motivated by the dependency grammar paradigm (Tesnière, 1959, Mel čuk, 1988), is articulated around a description language for multi-dimensional attributed labeled graphs. xdg is a generalization of Topological Dependency Grammar (tdg) (Duchier and Debusmann, 2001). For xdg, a grammar is a constraint that describes the valid linguistic signs as n-dimensional attributed labeled graphs, i.e. n-tuples of graphs sharing the same set of attributed nodes, but having different sets of labeled edges. It is central to xdg that all aspects of these signs are FG-MoL James Rogers (ed.). Copyright c 2009, CSLI Publications. 113

2 114 / Ralph Debusmann, Denys Duchier and Andreas Rossberg stipulated explicitly by principles: the class of models for each dimension, additional properties that they must satisfy, how one dimension must relate to another, and even lexicalization. Yet, no formal account set in the xdg framework has so far explained what exactly these principles are, nor how they can be brought to bear on specific dimensions. In this paper, we show how an xdg grammar can be formally assembled from modular components called parametric principles. This yields a modular and compositional approach to grammar design. Compositional coherence is ensured by a type system whose primary novelty is to accommodate the notion of multi-dimensional graphs. Instantiation of parametric principles not only imposes grammatical constraints, but, through the type system, also determines the necessary structure of grammatical signs. In this perspective, a grammar framework is simply a library of parametric principles such as the one offered by the xdg Development Kit (xdk) (Debusmann and Duchier, 2004). The xdk is a freely available development environment for xdg grammars including a concurrent constraint parser written in the Mozart/Oz programming language (Mozart Consortium, 2005) Extensible Dependency Grammar We briefly illustrate the xdg approach with an example of the German subordinate sentence (dass) einen Mann Maria zu lieben versucht. 1 Figure 1 shows an analysis with two dimensions: id models grammatical function and lp word-order using topological fields (Duchier and Debusmann, 2001, Gerdes and Kahane, 2001) subj vinf obj prt mf mf vcf einen a(acc) det Mann man Maria Maria zu to lieben love versucht tries df d einen a(acc) n Mann man n Maria Maria pf p zu to v lieben love v versucht tries FIGURE 1: Example XDG analysis, ID left, LP right Both dimensions share the same set of nodes (circles) but have different edges. On id, Maria is subject (subj) of control verb versucht, and Mann object (obj) of lieben. On lp, Mann and Maria are both in the Mittelfeld (mf) of versucht, i.e. Mann has climbed to the finite verb. 1 (that) Mary tries to love a man see (Duchier and Debusmann, 2001)

3 Modular Grammar Design with Typed Parametric Principles / 115 The instance of xdg demonstrated above covers only syntax. However, xdg instances can use arbitrary many dimensions of representation, e.g. e.g. including semantics (including predicate-argument structure and scope relationships) (Debusmann et al., 2004), prosody and information structure (Debusmann et al., 2005). In fact, xdg per se is not a grammar formalism but only a general graph description language for multi-dimensional attributed labeled graphs. In order to be used as a grammar formalism, it first needs to be instantiated using appropriate principles (see below). In this respect, it is similar to Head-driven Phrase Structure Grammar (HPSG) (Pollard and Sag, 1994), which per se is only a description language for typed feature structures (Carpenter, 1992), and becomes a grammar formalism only when it is instantiated, using appropriate types for the feature structures and the principles for e.g. head feature percolation and subcategorization. In particular, xdg is more general than other dependency-based grammar formalisms like Meaning Text Theory (MTT) (Mel čuk, 1988), Functional Generative Description (FGD) (Sgall et al., 1986), Word Grammar (WG) (Hudson, 1990) and Free Order Dependency Grammar (FODG) (Holan et al., 2000) since it can accommodate arbitrary many dimensions of representation and arbitrary principles to stipulate the well-formedness conditions. For instance, the dimensions of xdg need not be trees but can also be directed acyclic graphs (dags), e.g. to handle re-entrancies for the modeling of control constructions or relative clauses. In addition, the dimensions can be totally agnostic to word order. In our example above, the id dimension did not state any word order requirements, only the lp dimension did Type System Formalization. Let V be an infinite set of node variables, L a finite set of labels, and A a set of attributes. An attributed labeled graph (V, E, A) consists of a finite set of nodes V V, a finite set of labeled directed edges E V V L between them, and an assignment A : V A of attributes to nodes. An n-dimensional attributed labeled graph ((V, E 1, A 1 ),...,(V, E n, A n )), or multigraph, is a n-tuple of labeled attributed graphs (V, E i, A i ) over the same set of nodes V. To provide a typed account of the xdg framework, we need a satisfactory type for graphs. A first idea is ({V}, {V V L}, V A), where we write {τ} for set of τ, but such a type is very imprecise: it fails to express that the nodes used in the edges (2nd arg) are elements of the graph s set of nodes (1st arg). Since additionally element

4 116 / Ralph Debusmann, Denys Duchier and Andreas Rossberg graphs of a multigraph must be defined over the same set of nodes, some form of dependent typing (Aspinall and Hofmann, 2005) appears inescapable. Given that general systems of dependent types tend to make type-checking undecidable, we sketch instead a stratified system, using a specialised notion of kinds (Pierce, 2002), that is sufficient for our purpose Type structure We assume given a number of disjoint sets of symbols D i called finite domain kinds. Among them, two are distinguished: Nodes and Labels. Much of our type and kinding systems are quite standard. For reasons of space, we only detail the parts which are original to our proposal, and write τ :: κ and e : τ for the judgments that type τ has kind κ and expression e has type τ, omitting kinding and typing contexts. κ ::= top D i domain G c1 c k graph M c1 c k multigraph... D i G v M v τ :: κ κ κ τ :: κ FIGURE 2: Kinds and subkinds τ, τ i ::= c 1 c k domain [f 1 : τ 1,...,f n : τ n ] record {τ} set graph τ 1 τ 2 τ 3 graph (τ 1,..., τ n ) tuple [f 1 : τ 1,...,f n : τ n ] multigraph τ 1 τ 2 function grammar τ grammar!τ singleton... FIGURE 3: Types Finite domain sum types. They are built from symbols drawn from finite domain kinds: we write c 1 c k for a finite domain sum type in kind D i and ǫ Di for its empty sum. Here are their kinding (left) and typing (right) rules: c 1,...,c k symbols in D i c 1 c k :: D i c 1 c k :: D i c i : c 1 c k Kinds G c1 c k and M c1 c k indexed by finite domain sums make it possible to have types that depend on specific subsets of Nodes or Labels

5 Modular Grammar Design with Typed Parametric Principles / 117 without requiring more general term-dependent types. Singleton types. If c 1 c k :: Nodes is the type of nodes of a graph, then {c 1 c k } is the type of a set of these nodes. This is not sufficiently precise to type the set of nodes of the graph because it doesn t express that the latter is a maximal set. To achieve this aim, we introduce a novel, specialised variation of singleton types (Aspinall, 1995, Stone and Harper, 2005). Unlike standard singleton types, our form does not refer to values, hence we avoid the need for dependent types. We write!(c 1 c k ) for the type inhabited by the single value {c 1,..., c k }. Here are the relevant kinding, typing, and subtyping rules: τ :: D i!τ ::!(c 1 c k ) :: {c 1,...,c k } :!(c 1 c k )!τ {τ} Graph types. A graph is defined from finite domain types ν and l for its nodes and labels, and a type a for its attributes. We write G ν for the kind of a graph over node type ν. Kinding and typing rules are: ν :: Nodes l :: Labels a :: V :!ν E : {(ν, ν, l)} A : ν a graph ν l a :: G ν Graph V E A : graph ν l a The typing rule requires the node set to be assigned a singleton type, capturing the precise set of nodes in the type ν. Typing thus precludes the set of edges mentioning invalid nodes. Note also that the syntax of graph kinds in Figure 3 requires ν to be a concrete domain type. Multigraph types. A multigraph is a record of graphs over the same finite domain ν of nodes. We write M ν for its kind. Here are the kinding and typing rules: g 1 :: G ν... g n :: G ν [f 1 : g 1,..., f n : g n ] :: M ν G 1 : g 1 :: G ν... G n : g n :: G ν [f 1 = G 1,..., f n = G n ] : [f 1 : g 1,...,f n : g n ] :: M ν Grammars. An xdg grammar is a set of predicates over the same multigraph type: τ :: M ν grammar τ :: τ :: M ν S : {τ prop} Grammar S : grammar τ Note that, in order to match our intuitions about grammars, the grammar type should be polymorphic in the finite domain type for nodes, otherwise the number of nodes is fixed. This can be achieved by extending the kinding system to admit kind schemes G δ and M δ where δ is a domain variable. An xdg framework is a set, also called a library, of principle templates.

6 118 / Ralph Debusmann, Denys Duchier and Andreas Rossberg 11.4 Typed Templates Attributes are usually given in the form of attribute/value matrices and principles parametrized by values which can be found at specific feature paths. For example, on the syntactic dimension (V, E id, A id ) the agreement tuple assigned to each word must be one of those licensed by its lexical entry: 2 Agr [id = Graph V E id A id ] = v V : A id (v).agr A id (v).lex.agrs We can generalize this into a reusable principle by abstracting over feature paths using access functions: Elem D F 1 F 2 M = let Graph V E A = D(M) in v V : F 1 (A(v)) F 2 (A(v)) but this is not very legible and, for notational convenience, we explore here an alternative that we call templates: Elem d, p 1, p 2 [d = Graph V E A] = v V : A(v).p 1 A(v).p 2 where d, p 1, p 2 are feature path variables. A feature path is a (possibly empty) sequence of features. We write π for a path, ǫ for the empty path, and π 1 π 2 for the concatenation of π 1 and π 2. It is possible to generalize the language by allowing feature paths or feature path variables in types and patterns (and by extension in record dot access) where previously only features were allowed. The intuition of such an extension lies in the congruence [ǫ : τ] τ, [π 1 π 2 : τ] [π 1 : [π 2 : τ]], and in the interpretation of a dot access.π as a postfix function of type [π : τ] τ. Note that, if we write graph ν l a for the type of Elem s argument graph, it is our intention that type inference should require a to match the pattern [p 1 : τ, p 2 : {τ},...]. This can be achieved either with a type system supporting record polymorphism or by adopting an openworld semantics 3 for records and multigraphs, à la ψ-terms of life. For simplicity, in this article we choose the latter. We write p 1, p 2 τ for the type of a template abstracting over feature path variables p 1 and p 2 ; t may contain occurrences of p 1 and p 2. We write τ 1 :: κ 1,...,τ n :: κ n τ to express kinding constraints on the free type variables of τ. The type of Elem is then: Elem : d, p 1, p 2 ν :: Nodes, l :: Labels, τ :: [d : graph ν l [p 1 : τ, p 2 : {τ}]] prop 2 We adopt a pattern matching notation with obvious meaning 3 no closed arities

7 Modular Grammar Design with Typed Parametric Principles / Parametric Principles We now illustrate how typed templates are intended to be used to define parametric principles. 4 We write v l E v for an edge (v, v, l) E, v E v for one with any label, v + E v for the transitive closure, and v E D for the type-raised relation where D = {v v E v }, etc... Tree Principle. It stipulates the set L of edge labels and requires that 1) each node has at most one incoming edge, 2) there is precisely one node with no incoming edge (one root), and 3) there are no cycles: Tree d L [d = Graph V E A] = v V : M V : M E v M 1!v V : M V : M E v M = 0 v V : D V : v + E D v / D Here is the type constraint assigning singleton type!l to L: Tree : d ν :: Nodes, l :: Labels!l [d : graph ν l _] prop Valency Principle. Incoming and outgoing edges must comply with the in and out valencies which stipulate, for each label l L, how many edges labeled with l are licensed: Valency d, p in, p out L [d = Graph V E A] = v V l L : M V : M l E v M A(v).p in.l v V l L : D V : v l E D D A(v).p out.l Writing N for the type of natural numbers, here is the type constraint: Valency : d, p in, p out ν :: Nodes, l :: Labels!l [d : graph ν l [p in : l {N}, p out : l {N}]] prop Climbing Principle. Originating from tdg, this principle expresses that the tree-shape on dimension d 1 is a flattening of that of d 2 : 1) the dominance relation on d 1 must be a subset of that on d 2, 2) on d 1, each node must land on its d 2 -mother or climb higher: Climbing d 1, d 2 [d 1 = Graph V E 1 A 1, d 2 = Graph V E 2 A 2 ] = v V : D 1, D 2 V : v + E 1 D 1 v + E 2 D 2 D 1 D 2 U 1, U 2 V : U 1 + E 1 v U 2 E 1 E2 v U 1 U 2 Climbing : d 1, d 2 ν :: Nodes [d 1 : graph ν, d 2 : graph ν ] prop 4 For lack of space, we present only a few principles. For further information, the reader is referred to e.g. (Debusmann et al., 2004, Debusmann and Duchier, 2004).

8 120 / Ralph Debusmann, Denys Duchier and Andreas Rossberg Lexicon Principle. xdg grammars are typically lexicalized: the record assignments to nodes are then partially determined by a lexicon Lex. The lexicon principle stipulates that each node must be assigned a lexical entry: Lexicon d Lex [d = Graph V E A] = v V : A(v) Lex Here is the corresponding type constraint, stipulating that the graph on dimension d has no edges (since this dimension has only the purpose to carry the lexical entries): Lexicon : d ν :: Nodes, τ :: {τ} [d : graph ν ǫ Labels τ ] prop Lookup Principle. A lexical entry is normally a record having a feature for each dimension. The lookup principle looks up a lexical entry s subrecord for a particular dimension and equates it with the p lex feature of the node s attributes: Lookup d 1, d 2, p lex [d 1 = Graph V E 1 A 1, d 2 = Graph V E 2 A 2 ] = v V : A 1 (v).p lex = A 2 (v).d 1 Lookup : d 1, d 2, p lex ν :: Nodes, τ :: [d 1 : graph ν _ [p lex : τ], d 2 : graph ν _ [d 1 : τ]] prop 11.6 Example ID/LP Grammar We now describe how the grammar of (Duchier and Debusmann, 2001) can be assembled in our typed framework of parametric principles. To better illustrate the compositionality of our approach, we adopt an incremental presentation that derives more complex grammars from simpler ones through operations of composition and restriction: (Grammar S 1 ) ++ (Grammar S 2 ) = Grammar (S 1 S 2 ) (Grammar S 1 ) // S 2 = Grammar (S 1 S 2 ) The grammar requires 3 dimensions: id for syntax, lp for topology, and lex for parametrization by a lexicon. They are respectively characterized by the following sets of labels: L id = {det, subj, obj, vbse, vprt, vinf, prt} L lp = {d, df, n, mf, vcf, p, pf, v, vxf} L lex = Figure 4 shows how grammars for the 3 individual dimensions (G id, G lp, G lex ) are stipulated by instantiation of principles. For example, for G id, instantiation of Tree id L id has three consequences: (1) signs are required to match [id = X ], i.e. to have an id dimension, (2) the

9 References / 121 directed graph on that dimension must have labels in L id, (3) this graph must be a tree. G id+lex is a grammar where the id dimension is restricted by lexical constraints from the lex dimension: it is obtained by combining G id and G lex using the composition operator ++, and connecting them by the Lookup id, lex principle using the restriction operator //. Similarly for G lp+lex. Finally the full grammar G id/lp is obtained by combining G id+lex and G lp+lex and mutually constraining them by the Climbing and Barriers principles. G lex = Grammar {Lexicon lex Lex} G id = Grammar {Tree id L id, Valency id, in, out L id } G id+lex = (G id ++ G lex ) // {Lookup id, lex, lex } G lp = Grammar {Tree lp L lp, Valency lp, in, out L lp, Order lp, on, order, pos, self, Projectivity lp, pos } G lp+lex = (G lp ++ G lex ) // {Lookup lp, lex, lex } G id/lp = (G id+lex ++ G lp+lex ) // {Climbing lp, id, Barriers lp, id, blocks } FIGURE 4: Defining grammars in an incremental and compositional way 11.7 Conclusion In this paper, we have made a threefold contribution: (1) we described a novel system of restricted dependent types capable of precisely describing graphs and multi-dimensional graphs, (2) we introduced a notion of typed templates with which we could express parametric principles, (3) we showed how these could enable a modular and compositional approach to grammar design. Finally we illustrated our proposal with an example reconstruction of an earlier grammar. References Aspinall, David Subtyping with singleton types. In Computer Science Logic, vol. 933 of Lecture Notes in Computer Science. Springer-Verlag. Aspinall, David and Martin Hofmann Dependent types. In B. Pierce, ed., Advanced Topics in Types and Programming Languages, chap. I.2, pages The MIT Press. Carpenter, Bob The Logic of Typed Feature Structures. Cambridge Tracts in Theoretical Computer Science. Cambridge University Press, 32nd edn.

10 122 / Ralph Debusmann, Denys Duchier and Andreas Rossberg Debusmann, Ralph and Denys Duchier XDG Development Kit. rade/mogul/publish/doc/debusmann-xdk/. Debusmann, Ralph, Denys Duchier, Alexander Koller, Marco Kuhlmann, Gert Smolka, and Stefan Thater A Relational Syntax-Semantics Interface Based on Dependency Grammar. In Proceedings of COLING Geneva/CH. Debusmann, Ralph, Oana Postolache, and Maarika Traat A Modular Account of Information Structure in Extensible Dependency Grammar. In Proceedings of the CICLING 2005 Conference. Mexico City/MEX: Springer. Duchier, Denys and Ralph Debusmann Topological Dependency Trees: A Constraint-Based Account of Linear Precedence. In Proceedings of ACL Toulouse/FR. Gerdes, Kim and Sylvain Kahane Word Order in German: A Formal Dependency Grammar Using a Topological Hierarchy. In ACL 2001 Proceedings. Toulouse/FR. Holan, Tomás, Vladislav Kubon, Karel Oliva, and Martin Platek On Complexity of Word-Order. Journal t.a.l. pages Hudson, Richard A English Word Grammar. Oxford/UK: B. Blackwell. Mel čuk, Igor Dependency Syntax: Theory and Practice. Albany/US: State Univ. Press of New York. Mozart Consortium The Mozart-Oz Website. Pierce, Benjamin Types and Programming Languages. The MIT Press. Pollard, Carl and Ivan A. Sag Head-Driven Phrase Structure Grammar. Chicago/US: University of Chicago Press. Sgall, Petr, Eva Hajicova, and Jarmila Panevova The Meaning of the Sentence in its Semantic and Pragmatic Aspects. Dordrecht/NL: D. Reidel. Stone, Christopher and Robert Harper Extensional equivalence and singleton types. Transactions on Computational Logic to appear. Tesnière, Lucien Eléments de Syntaxe Structurale. Paris/FR: Klincksiek.