Why Dependency is not enough for Natural Language Grammars

Beware: this post will be longer than usual and somehow technical. I have been in Barcelona for DEPLING, the first conference explicitly dedicated to Dependency Grammar (DG) formalisms. As Constructive Adpositional Grammars (CxAdGrams, pronounce: “cross-adgrams”) had the same ancestor of DGs, namely Lucien Tesnière, me and Marco Benini had proposed a paper (Gobbo-Benini 2011)that was accepted as a poster presentation. CxAdGrams raised a lot of interest in the participants, and they were — as I expected — rather attacked from different viewpoints.

Here I will explain why CxAdGrams are not a DG formalism strictu sensu, and which advantages you gain in using CxAdGrams instead of DGs. I will refer to the proceedings of DEPLING which are available for free.

First and foremost: CxAdGrams, from the viewpoint of Mel’čuk‘s Meaning-Text Theory (MTT), considers “only” morphological (Morph-D) and syntactic (Synt-D) dependencies. Semantics is simply appended to the morphs: however, CxAdGrams can give account of many pragmatic phenomena — in particular, regarding marked word orders — through information prominence (see Gobbo-Benini’s book for details on this point).

In DGs, all nodes should be terminals (i.e., morphs) while arcs cannot. There is a sort of horror vacui in DG formalisms: empty nodes presupposed by zero morphs are a “grey area”, as Timothy Osborne told me informally, which in DGs are avoided whenever possible.

This principle is good, but in some area this is highly problematic, for example in coordination, as clearly explained by Nicolas Mazziotta in his DEPLING paper. I mean, you can’t really avoid empty nodes because ellipsis (or gapping) does exist.

A good example was provided by Mel’čuk in his paper:

1) old men and women
2) old men and women

In (1) old refers only to men, in (2) to men and women. This ambiguity is semantic, and therefore in CxAdGrams — as in MTT, if I understood correctly — it is respected, i.e., there are two different syntactic representations:

Old men and women

The paper by Kim Gerdes and Sylvain Kahane, which bravely and pragmatically tries to find a (computational) way to put together dependencies and constituents (the Big Taboo for dependency linguists) another example of ellipsis (or gapping) is found:

3) John likes tea and Mary coffee.

Well, it seems to be intuitively clear that its the verbant likes which is elided. At the limit, you can also have John likes tea Mary coffee without and. So what? If you don’t have horror vacui in nodes, you can easily represent the ellipsis as an anaphora, as we do in CxAdGrams, and in this manner you solve once and for all the problems of coordination:

John likes tea and Mary coffee

The representation of adpositional trees is not intuitive at the first sight, especially if you don’t know the four grammar characters (I, O, A, E) borrowed from Tesnière’s Structural Syntax, so perhaps this representation is more familiar for you — they are equivalent:

John likes tea and Mary coffee (alt)

CxAdGrams are syntactic and morphologic too. Through the Tesnièrian notion of transference (French: traslation), the chain of transformations are quite easily to be represented:


The corresponding constructive adpositional tree is as follows (note the generic boxed node D, meaning that the grammar character of the dependent is not important):

Morphology of unconstitutionally

However, I have found Gerdes-Kahane’s notion of fragment, which tries to put together dependencies and constituents, very interesting. This is an example:

In CxAdGrams, we can represent fragments through information hiding (indicated by the triangles):


Another problem in DGs is when trees are non-projective, i.e., when there are crossing edges in the tree representation itself — I’ve found this web page, which gives an account for people involved in parsing issue. Why does non-projectivity pose difficulties?

Let’s see an example of non-projective tree from the DEPLING paper by Mel’čuk. His example is the following:

This is the corresponding non-projective dependency tree (grey circles indicate the crossing edges):

In CxAdGrams, the linearization of adtrees is demanded by a parser (which takes into account the constructions) so that crossing edges because of word order are no more a problem. This sentence is made by three verbal phrases (their governor being indicated by I), where two of them show a considerable degree of information hiding, under the form of the infinitives putare and esse. Nonetheless, part of their valency is still (partially active). Their valency structure is as follows:

X solere Y;
X putare Y Z;
X esse Y (A).

Divalent verbs solere and esse (yes, not monovalent, you have read it correctly) are indicated by I^2, while putare is trivalent, hence it will be indicated by I^3. The corresponding adpositional tree (adtree) is as follows:

Tu solebas meas esse aliquid putare nugas

Please look how valency still operates in infinitives. There are many other observations that could be made after DEPLING, but perhaps I will give them in future posts (or full papers, if they will reveal groundbreaking insights).

2 thoughts on “Why Dependency is not enough for Natural Language Grammars

  1. Sylvain Kahane had some replies for me:

    > About gapping, note that the problem is not to have or not ellipsis but to
    > take into account that not only a simple verb form can be ellipted but more
    > complex chains of verbs:
    > John likes tea and Mary coffee.
    > Jonh would like to drink tea and Mary coffee
    > Marie veut qu’on appelle la police et Jean les pompiers
    > (see for instance Kahane 1997, Bubble trees)
    > And if you allow your grammar to have “would like to drink” or “veut qu’on
    > appelle” as cosntituents you face the problem of possible overgeneration and
    > spurious ambiguities. These questions have been largely debated since the
    > precursory work of Steedman 1987 who gives the first formal account of
    > complex coordination phenomena.
    > For non-projectivity the problem is again not to overgenerate. If you relax
    > projectivity you might obtain unwanted orders. The problem of every theory
    > is to precisely control what order can and cannot be produced. This is not
    > too difficult for English or Romance languages, but can be problematic for
    > German which authorizes a lot of non-projective construction but has very
    > specific constraints on word order (like V2) (see Gerdes & Kahane 2001 ACL).

    CxAdGrams have still not an implementation so to show how they conduct in respect of generation in real-case examples. I will take these observation into account.

    • In principle, we work in two steps: first, we deliberately
      overgenerate the structure of the given language; second,
      through R-transformations, i.e., redundancy bounds, we
      reduce the admitted adtrees to the grammatical ones.
      All depends on how constructions are modelled in the
      constructive dictionary.

      You are true that we don’t (still) have an instance
      that shows how CxAdgrams conduct in respect of
      (over)generation. We decided to start from the
      foundations, having a powerful and elegant model
      of language with a strong formalization — see Appendix B
      of Gobbo Benini’s book (2011).

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s