Proceedings of the 8th International Workshop on Tree Adjoining Grammar and Related Formalisms, pages 9–16,
Sydney, July 2006. c©2006 Association for Computational Linguistics
A constraint driven metagrammar
Joseph Le Roux
LORIA
Institut National
Polytechnique de Lorraine
615, Rue du Jardin Botanique
54 600 Villers-L`es-Nancy
France
leroux@loria.fr
Benoˆıt Crabb´e
HCRC / ICCS
University of Edinburgh
2 Buccleuch Place
EH8 9LW,
Edinburgh, Scotland
bcrabbe@inf.ed.ac.uk
Yannick Parmentier
INRIA / LORIA
Universit´e Henri Poincar´e
615, Rue du Jardin Botanique
54 600 Villers-L`es-Nancy
France
parmenti@loria.fr
Abstract
We present an operational framework al-
lowing to express a large scale Tree Ad-
joining Grammar (TAG) by using higher
level operational constraints on tree de-
scriptions. These constraints first meant
to guarantee the well formedness of the
grammatical units may also be viewed as
a way to put model theoretic syntax at
work through an efficient offline grammat-
ical compilation process. Our strategy pre-
serves TAG formal properties, hence en-
sures a reasonable processing efficiency.
1 Introduction
This paper is concerned with the semi-automatic
grammar development of real-scale grammars.
For natural language syntax, lexicalised TAGs are
made of thousands of trees, carrying an extreme
structural redundancy. Their development and
their maintenance is known to be cumbersome as
the size of the grammar raises significantly.
To counter the lack of generalisations inher-
ent to strong lexicalisation, various proposals for
semi-automatic grammar development have been
carried out: lexical rules or meta-rules (Becker,
2000) and metagrammars: (Candito, 1999; Gaiffe
et al., 2002; Xia, 2001). The aim of these frame-
works is twofold: expressing general facts about
the grammar of a language and factorising the in-
formation to avoid redundancy.
The metagrammar path adopts a different per-
spective from the lexical rule based grammar de-
velopment: instead of describing how a derived
tree is different from a canonical one, grammati-
cal description mainly consists of combining frag-
mentary tree descriptions or building blocks.
The paper is structured as follows. We start
in section 2 by providing motivations and back-
ground information on the framework we are us-
ing. Section 3 shows that the metagrammar frame-
work may be viewed as an offline system allowing
to express high level well-formedness constraints
on elementary grammatical structures while pre-
serving TAG computational and formal proper-
ties. Section 4 shows how to implement effi-
ciently this constraint-based approach with logic
programming techniques and finally section 5 pro-
vides an idea of the performance of the imple-
mented system.
2 eXtensible MetaGrammar (XMG)
By opposition to other metagrammatical frame-
works, XMG (Duchier et al., 2004) uses an expres-
sive though simple language, enabling a mono-
tonic description of a real scale grammar. Mono-
tonicity is important because it means that the or-
der of application of the different operations does
not matter. This is the major drawback of lexical-
rule systems. Moreover, (Crabb´e, 2005b) shows
that it is sufficiently expressive to implement con-
veniently a core TAG for French.
XMG allows the grammar writer to manipulate
tree descriptions through a control language. The
intuition behind is that a metagrammatical lan-
guage needs to provide means to describe syn-
tactic information along two methodological axis
(Crabb´e, 2005b): structure sharing and alterna-
tives. Structure sharing is the axis dedicated to
express factorisation in the grammar, whereas al-
ternatives allow to express regular alternation re-
lationships such as alternatives between the rep-
resentation of a canonical nominal subject and its
interrogative representation, or between an active
9
and a passive verb form1.
Building on this intuition the XMG language al-
lows the user to name partial tree descriptions
within classes. The name of the class can be ma-
nipulated afterwards. For instance the following
tree descriptions on the right of the arrow are as-
sociated with the names stated on the left of the
arrow2:
(1) a. CanonicalSubject →
S
N↓ V
b. RelativisedSubject →
N
N* S
N↓ V
c. VerbalForm →
S
Vdiamondmath
Naming is the main device that allows the gram-
mar writer to express and to take advantage of the
structure sharing axis mentioned above. Indeed
class names can be reused in other descriptions.
Thus names can also be used to describe alterna-
tives. To express, in our simplified example, that a
Subject is an abstract way to name a Relativised-
Subject or a CanonicalSubject, we use a choice op-
erator (∨) as illustrated below:
(2) Subject → CanonicalSubject
∨ RelativisedSubject
Disjunction (non-deterministic choice) is the de-
vice provided by the language to express the
methodological axis of alternatives.
Finally, names can be given to class combina-
tions. To express the composition of two tree de-
scriptions in the language, we use the ∧ operator.
1The passive is a semi-regular alternation, many transi-
tive verbs do not passivise. Our system presupposes a classi-
cal architecture for the computational representation of Tree
Adjoining Grammars such as XTAG, where means to ex-
press such exceptions during the anchoring process are well-
known. In what follows, we therefore consider only tree tem-
plates (or tree schematas) as our working units. Finally the
trees depicted in this paper take their inspiration from the
grammar described by (Abeill´e, 2002).
2To represent the tree descriptions mentioned in this pa-
per, we use a graphical notation. Immediate dominance is de-
picted with a straight line and precedence follows the graphi-
cal order. Note that nodes are decorated with their labels only,
ignoring the names of the variables denoting them. Note also
that we use only the reflexive transitive closure of precedence
between sibling nodes and it is explicitly stated with the sym-
bol ≺∗.
Thus we can say that an IntransitiveVerb is made
by the composition of a Subject and a VerbalForm
as follows:
(3) IntransitiveVerb → Subject ∧ VerbalForm
Given these 3 primitives, the control language
is naturally interpreted as a context free grammar
whose terminals are tree descriptions and where
our composition plays the role of concatenation.
This abstract grammar or metagrammar is further
restricted to be non recursive in order to ensure
that the generated TAG is finite.
Provided the axiom IntransitiveVerb, an inter-
preter for this language generates non determinis-
tically all the sentences of the grammar3 underly-
ing a grammatical description. Thus in our current
example the two sentences generated are those de-
picted on the left hand side of the arrows in Figure
1. On the right hand side of the arrow is depicted
the result of the composition of the tree descrip-
tions.
It remains to make clear what is actually this
composition. The grammatical classes may con-
tain information on tree descriptions and/or ex-
press composition of descriptions stated in other
classes. Tree descriptions take their inspiration
from the logic described in (Rogers and Vijay-
Shanker, 1994). Its syntax is the following:
Description ::= x → y | x →∗ y |
x ≺ y | x ≺∗ y |
x[f:E]
where x,y are node variables, → the dominance
relation, ≺ the precedence relation, ∗ denoting the
reflexive transitive closure of a relation. The last
line associates x with a feature f whose value is
the result of evaluating expression E.
Tree descriptions are interpreted as finite linear
ordered trees being the minimal models of the de-
scription.
Using tree descriptions, the above mentioned
operation of tree “composition” breaks down to a
conjunction of formulas where variables of each
conjunct are in first approximation renamed to
avoid name collisions. Renaming is a crucial dif-
ference with previous approaches to metagrammar
(Candito, 1999; Xia, 2001) where the user had to
manage explicitly a “global namespace”. Here a
specific attention is given to namespace manage-
ment, because this was a bottleneck for real scale
3Understood as compositions of tree fragments.
10
S
N↓ V
Le garc¸on. . .
The boy. . .
^
S
Vdiamondmath
dort
sleeps
)
S
N↓ Vdiamondmath
Le garc¸on dort
The boy who sleeps
N
N* S
N↓ V
(Le garc¸on) qui. . .
(The boy) who. . .
^
S
Vdiamondmath
dort
sleeps
)
N
N* S
N↓ Vdiamondmath
Le garc¸on qui dort
The boy who sleeps
Figure 1: Interpretation of a grammatical description
grammar design. More precisely each class has
its own namespace of identifiers and namespace
merging can be triggered when a class combina-
tion occurs. This merging relies on a fine-grained
import/export mechanism.
In addition to conjunction and disjunction, XMG
is augmented with syntactic sugar to offer some
of the features other metagrammatical formalisms
propose. For instance, inheritance of classes is not
built-in in the core language but is realised through
conjunction and namespace import. Of course,
this restricts users to monotonic inheritance (spe-
cialisation) but it seems to be sufficient for most
linguists.
3 Constraining admissible structures
XMG has been tested against the development of a
large scale French Grammar (Crabb´e, 2005a). To
ease practical grammatical development we have
added several augmentations to the common tree
description language presented so far in order to
further restrict the class of admissible structures
generated by the metagrammar.
Further constraining the structures generated by
a grammar is a common practice in computational
linguistics. For instance a Lexical Functional
Grammar (Bresnan and Kaplan, 1982) further re-
stricts the structures generated by the grammar by
means of a functional uniqueness and a functional
completeness principles. These constraints further
restricts the class of admissible structures gener-
ated by an LFG grammar to verify valency condi-
tions.
For TAG and in a theoretical context, (Frank,
2002) states a set of such well formedness prin-
ciples that contribute to formulate a TAG theory
within a minimalist framework. In what remains
we describe operational constraints of this kind
that further restrict the admissibility of the struc-
ture generated by the metagrammar. By contrast
with the principles stated by (Frank, 2002), we
do not make any theoretical claim, instead we
are stating operational constraints that have been
found useful in practical grammar development.
However as already noted by (Frank, 2002) and
by opposition to an LFG framework where con-
straints apply to the syntactic structure of a sen-
tence as a whole, we formulate here constraints on
the well-formedness of TAG elementary trees. In
other words these constraints apply to units that
define themselves their own global domain of lo-
cality. In this case, it means that we can safely
ignore locality issues while formulating our con-
straints. This is theoretically weaker than formu-
lating constraints on the whole sentential structure
but this framework allows us to generate common
TAG units, preserving the formal and computa-
tional properties of TAG.
We formulate this constraint driven framework
by specifying conditions on model admissibility.
Methodologically the constraints used in the de-
velopment of the French TAG can be classified
in four categories: formal constraints, operational
constraints, language dependent constraints and
theoretical principles.
First the formal constraints are those constrain-
ing the trees generated by the model builder to
be regular TAG trees. These constraints require
the trees to be linear ordered trees with appropri-
ate decorations : each node has a category label,
leaf nodes are either terminal, foot or substitution,
there is at most one foot node, the category of the
foot note is identical to that of the root node, each
tree has at least one leaf node which is an anchor.
11
It is worth noting here that using a different set
of formal constraints may change the target for-
malism. Indeed XMG provides a different set of
formal constraints (not detailed here) that allow to
generate elementary units for another formalism,
namely Interaction Grammars.
The second kind of constraint is a single op-
erational constraint dubbed the colouration con-
straint. We found it convenient in the course
of grammar development. It consists of associ-
ating colour-based polarities to the nodes to en-
sure a proper combination of the fragmentary
tree descriptions stated within classes. Since in
our framework descriptions stated in two different
classes are renamed before being conjoined, given
a formula being the conjunction of the two follow-
ing tree descriptions :
(4)
X
W Z
X
Z Y
both the following trees are valid models of that
formula:
(5) (a)
X
W Z Y (b)
X
W Z Z Y
In the context of grammar development, however,
only (a) is regarded as a desired model. To rule out
(b) (Candito, 1999; Xia, 2001) use a naming con-
vention that can be viewed as follows4: they assign
a name to every node of the tree description. Both
further constrain model admissibility by enforcing
the identity of the interpretation of two variables
associated to the same name. Thus the description
stated in their systems can be exemplified as fol-
lows:
(6)
Xa
Wb Zc
Xa
Zc Yd
Though solving the initial formal problem, this de-
sign choice creates two additional complications:
(1) it constrains the grammar writer to manually
manage a global naming, entailing obvious prob-
lems as the size of the grammatical description
grows and (2) it prevents the user to reuse sev-
eral times the same class in a composition. This
case is a real issue in the context of grammati-
cal development since a grammar writer willing
to describe a ditransitive context with two prepo-
sitional phrases cannot reuse two times a fragment
4They actually use a different formal representation that
does not affect the present discussion.
describing such a PP since the naming constraint
will identify them.
To solve these problems we use a colouration
constraint. This constraint associates unary prop-
erties, colours, to every node of the descriptions.
A colour is taken among the set red(•R), black(•B ),
white (◦W). A valid model is a model in which ev-
ery node is coloured either in red or black. Two
variables in the description interpreted by the same
node have their colours merged following the table
given in Figure 2.
•B •R ◦W ⊥
•B ⊥ ⊥ •B ⊥
•R ⊥ ⊥ ⊥ ⊥
◦W •B ⊥ ◦W ⊥
⊥ ⊥ ⊥ ⊥ ⊥
Figure 2: Colour identification rules.
The table indicates the resulting colour after
a merge. The ⊥ symbol indicates that this two
colours cannot be merged and hence two nodes la-
belled with these colours cannot be merged. Note
that the table is designed to ensure that merging is
not a procedural operation.
The idea behind colouration is that of saturat-
ing the tree description. The colour white repre-
sents the non saturation or the need of a node to
be combined with a resource, represented by the
colour black. Black nodes need not necessarily
be combined with other nodes. Red is the colour
used to label nodes that cannot be merged with
any other node. A sample tree description with
coloured node is as follows:
(7)
X•B
W•R Z•B
X◦W
Z◦W Y•R
Colours contribute to rule out the (b) case and re-
move the grammar writer the burden of managing
manually a “global namespace”.
The third category of constraints are language
dependent constraints. In the case of French, such
constraints are clitic ordering, islands constraints,
etc. We illustrate these constraints with clitic or-
dering in French. In French clitics are non tonic
particles with two specific properties already iden-
tified by (Perlmutter, 1970): first they appear in
front of the verb in a fixed order according to their
rank (8a-8b) and second two different clitics in
front of the verb cannot have the same rank (8c).
For instance the clitics le, la have the rank 3 and
lui the rank 4.
12
S
N↓ V’≺+ ^
V’
Cl↓3 V≺+ ^
V’
Cl↓4 V≺+ ^
S
V’
Vdiamondmath )
S
N↓ V’
Cl↓3 Cl↓4 Vdiamondmath
S
N↓ V’
Cl↓4 Cl↓3 Vdiamondmath
Figure 3: Clitic ordering
(8) a. Jean le3 lui4 donne
John gives it to him
b. *Jean lui4 le3 donne
*John gives to him it
c. *Jean le3 la3 donne
*John gives it it
In the French grammar of (Crabb´e, 2005a) trees
with clitics are generated with the fragments illus-
trated on the left of the arrow in Figure 35. As
illustrated on the right of the arrow, the composi-
tion may generate ill-formed trees. To rule them
out we formulate a clitic ordering constraint. Each
variable labelled with a clitic category is also la-
belled with a property, an integer representing its
rank. The constraint stipulates that sibling nodes
labelled with a rank have to be linearly ordered ac-
cording to the order defined over integers.
Overall language dependent constraints handle
cases where the information independently spec-
ified in different fragments may interact. These
interactions are a counterpart in a metagrammar to
the interactions between independently described
lexical rules in a lexical rule based system. As-
suming independent lexical rules moving canoni-
cal arguments (NP or PP) to their clitic position,
lexical rules fall short for capturing the relative or-
dering among clitics6.
A fourth category of constraints, not imple-
mented in our system so far are obviously the lan-
guage independent principles defining the theory
underlying the grammar. Such constraints could
involve for instance a Principle of Predicate Argu-
ment Coocurrency (PPAC) or even the set of min-
imalist principles described by (Frank, 2002).
4 Efficient implementation
We describe now the implementation of our meta-
grammatical framework. In particular, we will fo-
5Colours are omitted.
6This observation was already made by (Perlmutter, 1970)
in a generative grammar framework where clitics where as-
sumed to be moved by transformations.
cus on the implementation of the constraints dis-
cussed above within XMG.
As mentioned above, a metagrammar corre-
sponds to a reduced description of the grammar.
In our case, this description consists of tree frag-
ments combined either conjunctively or disjunc-
tively. These combinations are expressed using
a language close to the Definite Clause Grammar
formalism (Pereira and Warren, 1980), except that
partial tree descriptions are used as terminal sym-
bols. In this context, a metagrammar can be re-
duced to a logic program whose execution will
lead to the computation of the trees of the gram-
mar.
To perform this execution, a compiler for our
metagrammatical language has been implemented.
This compilation is a 3-step process as shown in
Figure 4.
First, the metagrammar is compiled into in-
structions for a specific virtual machine inspired
by the Warren’s Abstract Machine (Ait-Kaci,
1991). These instructions correspond to the un-
folding of the relations7 contained in the tree de-
scriptions of the metagrammar.
Then, the virtual machine performs unifications
of structures meant to refer to corresponding in-
formation within fragments (e.g. two nodes, two
feature structures ...). Note that the XMG’s virtual
machine uses the structure sharing technique for
memory management, i.e. data are represented by
a pair pattern – environment in which to interpret
it. The consequences are that (a) we save mem-
ory when compiling the metagrammar, and (b) we
have to perform pointer dereferencing during uni-
fication. Even if the latter is time-consuming, it
remains more efficient than structure copying as
we have to possibly deal with a certain amount of
tree descriptions.
Eventually, as a result of this instruction pro-
cessing by the virtual machine, we obtain poten-
7These relations are either dominance or precedence be-
tween node variables, or their reflexive transitive closure, or
the labelling of node variable with feature structures.
13
STEP1
(translation of concrete syntax)
INTO INSTRUCTIONS
CONCRETE SYNTAX
METAGRAMMATICAL
COMPILATION OF 
TREE DESCRIPTION SOLVING
STEP3
(unification of data structures)
STEP2
A SPECIFIC VIRTUAL MACHINE
INSTRUCTIONS BY
EXECUTION OF THE 
INPUT: MetaGrammar
Total tree descriptions OUTPUT: TAGCompiled partial tree descriptions
Figure 4: Metagrammar compilation.
tially total tree descriptions, that have to be solved
in order to produce the expected TAG.
Now, we will introduce XMG’s tree description
solver and show that it is naturally designed to pro-
cess efficiently the higher level constraints men-
tioned above. In particular, we will see that the
description solver has been designed to be easily
extended with additional parametric admissibility
constraints.
4.1 Tree descriptions solving
To find the minimal models corresponding to the
total tree descriptions obtained by accumulating
fragmentary tree descriptions, we use a tree de-
scription solver. This solver has been developed in
the Constraint Programming paradigm using the
constraint satisfaction approach of (Duchier and
Niehren, 2000). The idea is to translate relations
between node variables into constraints over sets
of integers.
Basically, we refer to a node of the input de-
scription in terms of the nodes being equals,
above, below, or on its side (see Figure 5). More
precisely, we associate each node of the descrip-
tion with an integer, then our reference to a node
corresponds to a tuple containing sets of nodes (i.e.
sets of integers).
As a first approximation, let us imagine that we
refer to a node x in a model by means of a 5-tuple
Nix = (Eq, Up, Down, Left, Right) where i is an in-
teger associated with x and Eq (respectively Up,
Down, Left, Right) denotes the set of nodes8 in the
description which are equal, (respectively above,
below, left, and right) of x.
Then we can convert the relations between
nodes of our description language into constraints
on sets of integer.
8I.e. integers.
Eq
Up
Down
Left
Right
Figure 5: Node representation.
For instance, if we consider 2 nodes x and y of
the description. Assuming we associate x with the
integer i and y with j, we can translate the domi-
nance relation x → y the following way9:
Nix! Njy [N
i
x.EqUp  N
j
y.Up^N
i
x.Down  N
j
y.EqDown
^Nix.Left  Njy.Left^Nix.Right  Njy.Right]
This means that if the node10 x strictly dominates
y in the input description, then (i) the set of nodes
that are above or equal x in a valid model is in-
cluded in the set of those that are strictly above y
and (ii) the dual holds for the nodes that are above
and (iii) the set of nodes that are on the left of y is
included in the set of those that are on the left of x
and (iv) similarly for the right part.
Once the constraints framework is settled, we
can search for the solutions to our problem, i.e.
the variable assignments for each of the sets of in-
tegers used to refer to the nodes of the input de-
scription. This search is performed by associating
with each pair of nodes (x,y) of the input descrip-
tion a choice variable denoting the mutually ex-
clusive relations11 between these two nodes. Then
9Ni
x.EqUp corresponds to the disjoint union of N
i
x.Eq and
Nix.Up, similarly for Njx.EqDown with Nix.Eq and Nix.Down.
10One should read the node denoted by the variable x.
11Either x equals y, x dominates y, y dominates x, x pre-
cedes y or y precedes x.
14
we use a search strategy to explore the consistent
assignments to these choices variables (and the as-
sociated assignments for sets of integers referring
to nodes)12. Note that the strategy used in XMG
is a first-fail strategy which leads to very good re-
sults (see section 5 below). The implementation
of this solver has been done using the constraint
programming support of the Mozart Programming
System (The Oz-Mozart Board, 2005).
4.2 Extension to higher-level constraints
solving
An important feature of our approach is that this
system of constraints over integer sets can be
extended so that we not only ensure tree well-
formedness of the outputted trees, but also the re-
spect of linguistic properties such as the unique-
ness of clitics in French, etc.
The idea is that if we extend adequately our
node representation, we can find additional con-
straints that reflects the syntactic constraints we
want to express.
Clitic uniqueness For instance, let us consider
the clitic uniqueness constraint introduced above.
We want to express the fact that in a valid model
φ, there is only one node having a given property
p (i.e. a parameter of the constraint, here the cat-
egory clitic13). This can be done by introducing,
for each node x of the description, a boolean vari-
able px indicating whether the node denoting x in
the model has this property or not. Then, if we call
Vφp the set of integers referring to nodes having the
property p in a model, we have:
px ≡ (Nix.Eq ∩Vφp ) negationslash= ∅
Finally, if we represent the true value with the in-
teger 1 and false with 0, we can sum the px for
each x in the model. When this sum gets greater
than 1, we can consider that we are not building a
valid model.
Colouration constraint Another example of the
constraints introduced in section 3 is coloura-
tion. Colouration represents operational con-
straints whose effect is to control tree fragment
combination. The idea is to label nodes with a
colour between red, black and white. Then, during
12More information about the use of such choice variables
is given in (Duchier, 1999)
13In fact, the uniqueness concerns the rank of the clitics,
see (Crabb´e, 2005b), §9.6.3.
description solving, nodes are identified according
to the rules given previously (see Figure 2).
That is, red nodes are not identified with any
other node, white nodes can be identified with a
black one. Black nodes are not identified with
each other. A valid model in this context is a satu-
rated tree, i.e. where nodes are either black (possi-
bly resulting from identifications) or red. In other
words, for every node in the model, there is at most
one red or black node with which it has been iden-
tified. The implementation of such a constraint
is done the following way. First, the tuples rep-
resenting nodes are extended by adding a integer
field RB referring to the red or black node with
which the node has been identified. Then, con-
sidering the following sets of integers: VR, VB,
VW respectively containing the integers referring
to red, black and white nodes in the input descrip-
tion, the following constraints hold:
x ∈ VR ⇒ Nix.RB = i ∧ Nix.Eq = {i} (a)
x ∈ VB ⇒ Nix.RB = i (b)
x ∈ VW ⇒ Nix.RB ∈ VφB (c)
where VφB represents the black nodes in a model,
i.e. VφB = Vφ ∩VB. (a) expresses the fact that for
red nodes, Nix.RB is the integer i associated with
x itself, and Nix.Eq is a set only containing i. (b)
means that for black nodes, we have that Nix.RB is
also the integer i denoting x itself, but we cannot
say anything about Nix.Eq. Eventually (c) means
that whites nodes have to be identified with a black
one.
Thus, we have seen that Constraint Program-
ming offers an efficient and relatively natural way
of representing syntactic constraints, as ”all” that
has to be done is to find an adequate node repre-
sentation in terms of sets of nodes, then declare the
constraints associated with these sets, and finally
use a search strategy to compute the solutions.
5 Some features
There are two points worth considering here: (i)
the usability of the formalism to describe a real
scale grammar with a high factorisation, and (ii)
the efficiency of the implementation in terms of
time and memory use.
Concerning the first point, XMG has been used
successfully to compute a TAG having more than
6,000 trees from a description containing 293
15
classes14. Moreover, this description has been de-
signed relatively quickly as the description lan-
guage is intuitive as advocated in (Crabb´e, 2005a).
Concerning the efficiency of the system, the
compilation of this TAG with more than 6,000 trees
takes about 15 min with a P4 processor 2.6 GHz
and 1 GB RAM. Note that compared with the
compilation time of previous approaches (Candito,
1999; Gaiffe et al., 2002) (with the latter, a TAG of
3,000 trees was compiled in about an hour), these
results are quite encouraging.
Eventually, XMG is released under the terms of
the GPL-like CeCILL license15 and can be freely
downloaded at http://sourcesup.cru.fr/xmg.
6 Conclusion
Unlike previous approaches, the description lan-
guage implemented by XMG is fully declara-
tive, hence allowing to reuse efficient techniques
borrowed to Logic Programming. The system
has been used successfully to produce core TAG
(Crabb´e, 2005b) and Interaction Grammar (Per-
rier, 2003) for French along with a core French
TAG augmented with semantics (Gardent, 2006).
This paper shows that the metagrammar can be
used to put model theoretic syntax at work while
preserving reasonably efficient processing proper-
ties. The strategy used here builds on constraining
offline a TAG whose units are elementary trees The
other option is to formulate constraints applied
on-line, in the course of parsing, applying on the
whole syntactic structure. In a dependency frame-
work, XDG followed this path (Debusmann et al.,
2004), however it remains unknown to us whether
this approach remains computationally tractable
for parsing with real scale grammars.

References
A. Abeill´e. 2002. Une grammaire ´electronique du franais.
CNRS Editions, Paris.
H. Ait-Kaci. 1991. Warren’s abstract machine: A tuto-
rial reconstruction. In K. Furukawa, editor, Proc. of the
Eighth International Conference of Logic Programming.
MIT Press, Cambridge, MA.
T. Becker. 2000. Patterns in metarules. In A. Abeille and
O. Rambow, editors, Tree Adjoining Grammars: formal,
computational and linguistic aspects. CSLI publications,
Stanford.
Joan Bresnan and Ronal M. Kaplan. 1982. The Mental Rep-
resentation of Grammatical Relations. The MIT Press,
Cambridge MA.
M.H. Candito. 1999. Repr´esentation modulaire et
param´etrable de grammaires ´electroniques lexicalis´ees :
application au franc¸ais et `a l’italien. Ph.D. thesis, Uni-
versit´e Paris 7.
B. Crabb´e. 2005a. Grammatical development with XMG.
Proceedings of the Fifth International Conference on Log-
ical Aspects of Computational Linguistics (LACL05).
B. Crabb´e. 2005b. Repr´esentation informatique de gram-
maires fortement lexicalis´ees : Application `a la gram-
maire d’arbres adjoints. Ph.D. thesis, Universit´e Nancy
2.
R. Debusmann, D. Duchier, and G.-J. M. Kruijff. 2004. Ex-
tensible dependency grammar: A new methodology. In
Proceedings of the COLING 2004 Workshop on Recent
Advances in Dependency Grammar, Geneva/SUI.
D. Duchier and J. Niehren. 2000. Dominance constraints
with set operators. In Proceedings of CL2000, volume
1861 of Lecture Notes in Computer Science, pages 326–
341. Springer.
D. Duchier, J. Le Roux, and Y. Parmentier. 2004. The Meta-
grammar Compiler: An NLP Application with a Multi-
paradigm Architecture. In 2nd International Mozart/Oz
Conference (MOZ’2004), Charleroi.
D. Duchier. 1999. Set constraints in computational linguis-
tics - solving tree descriptions. In Workshop on Declara-
tive Programming with Sets (DPS’99), Paris, pp. 91 - 98.
Robert Frank. 2002. Phrase Structure Composition and Syn-
tactic Dependencies. MIT Press, Boston.
B. Gaiffe, B. Crabb´e, and A. Roussanaly. 2002. A new meta-
grammar compiler. In Proceedings of TAG+6, Venice.
C. Gardent. 2006. Int´egration d’une dimension s´emantique
dans les grammaires d’arbres adjoints. In Actes de La
13`eme ´edition de la conf´erence sur le TALN (TALN 2006).
F. Pereira and D. Warren. 1980. Definite clause grammars
for language analysis —a survey of the formalism and a
comparison to augmented transition networks. Artificial
Intelligence, 13:231–278.
David Perlmutter. 1970. Surface structure constraints in syn-
tax. Linguistic Inquiry, 1:187–255.
Guy Perrier. 2003. Les grammaires d’interaction. HDR en
informatique, Universit´e Nancy 2.
J. Rogers and K. Vijay-Shanker. 1994. Obtaining trees from
their descriptions: An application to tree-adjoining gram-
mars. Computational Intelligence, 10:401–421.
The Oz-Mozart Board. 2005. The Oz-Mozart Programming
System. http://www.mozart-oz.org.
Fei Xia. 2001. Automatic Grammar Generation from two
Different Perspectives. Ph.D. thesis, University of Penn-
sylvania.
