Dependency grammars

• The basic idea: the structure of a sentence can be represented as a set of relations (dependencies) between words; there are no phrasal nodes.
• Each dependency is a labeled, directed arc between a head and a dependent word.
• Each sentence has one root word which has no head.
• An example
  
• Alternate notation
  
• A family of theories

Dependency grammar and constituency grammar

• More lexical, less abstract than constituency grammars
• Simplifies statement of word-based constraints, such as valency
• Natural way of representing semantic relations
• Natural separation of structural relationships and word order
• A constituency tree can be converted to an unlabeled dependency tree.
• A projective dependency tree can be converted to a constituency tree.

Some possible constraints on dependency trees/grammars

• Treehood: each node other than the root has exactly one parent
  • A dependency tree
    
  • A dependency DAG
    
• Projectivity: a node j's dependents must all lie between j's parent i and any dependents of i on the same side of i as j. Equivalently, all nodes between a node i and a daughter j of i must be descendants of i on the same side of i as j.
  A non-projective dependency tree:
  

Issues in Nivre et al. (1)

• Classifiers
  • Eager learning, e.g., SVM
  • Lazy learning, e.g., MBL
• Greedy parsing
• Deterministic parsing
• History-based feature models
• k-fold cross-validation

Issues in Nivre et al. (2)

• A "universal", language-independent parser
• Projectivity and parsing complexity
• Dealing with non-projective sentences
• Dealing with complex morphology (Turkish)

Extensible Dependency Grammar (Debusmann, etc.)

• A (hand-crafted) grammar framework in which analyses are multigraphs and parsing is by constraint satisfaction.
• Some grammatical sentences to work with
  • The students cook good food.
    

    Wanafunzi	wanapika	chakula	kizuri.
    teachers[cls=2]	cook[sbj=[cls=2]]	food[cls=7]	good[cls=7]

  • The students cook the teacher good food.
    

    Wanafunzi	wanampikia	mwalimu	chakula	kizuri.
    teachers[cls=2]	cook-for[sbj=[cls=2],obj=[cls=1]]	teacher[cls=1]	food[cls=7]	good[cls=7]

  • For the teacher the students are cooking gumbo.
• Some ungrammatical sentences to work with
  • The students cooks teacher good food.
  • The students cook he good food.
  • For the teacher are cooking the students gumbo.
  • Wanafunzi wanapikia chakula nzuri. (piki- requires two objects; adjective doesn't agree with noun).
  • Wanafunzi wanakipikia mwalimu chakula kizuri. (piki- requires object agreement with the first (indirect) object)

XDG overview

• Each type of constraint in the grammar corresponds to a principle
• Some principles: tree, valency, agreement, order
• Each word has attributes (stored in the lexicon) related to one or more of the principles

Agreement attributes

cooks
   agrs: (3, 1)
   agree: [sbj]

wanampikia
   agrs: {sbj: (2), obj: (1)}
   agree: {sbj: sbj, obj: iobj}

chakula
   agrs: (7)
   agree: [adj]

kizuri
   agrs: (7)

N
   agree: [adj]

V
   agree: {sbj: sbj}

VDitrans
   classes: [V]
   agree: {obj: iobj}

Lexical inheritance hierarchy

• cooks → COOK → VDitrans → VTrans → V
• cooks → V3ps → VFin → V

Valency attributes

teacher
   out: {det: !, adj: *}
   in: {obj: ?, sbj: ?, pobj: ?}

cooked
   out: {sbj: !, obj: ?, iobj: ?, pmod: *}
   in: {root: ?, rel: ?, sub: ?}

Valency: syntax and semantics

• Syntactic vs. semantic roles
• Jack likes snakes
  

  A	Jack	le	gustan	las	serpientes.
  to	Jack	to-him	like[3pl]	the	snakes

• For English like, the subject is the "experiencer", the object is the "theme"; for Spanish gustar, it's the reverse.
• Syntactic and semantic relations need to be kept separate.

Representational levels (dimensions)

• In XDG, syntax and semantics appear on separate dimensions.
• An analysis is a multigraph; a given pair of nodes may be connected by arcs on multiple dimensions.
• Syntax vs. semantics
  
• Syntax: constituency vs. word order

Interface dimensions

• Interface dimensions: specify how labels on adjacent dimensions relate
• An example principle
  • Linking End Principle: the daughter of node w on link with label l1 on dimension 1 is the daughter of some node on link with label l2 on dimension 2
  • Examples

    COOK_Trans
       syn
          outs: {sbj: !, obj: !, pmod: ?}
       sem
          outs: {agt: !, pat: !, ben: ?}
       synsem
          linkend: {agt: sbj, pat: obj, ben: pobj}
    

    LIKE
       synsem
          linkend: {exp: sbj, thm: obj}
    

    GUSTAR
       synsem
          linkend: {exp: obj, thm: sbj}
    

Handling word order

V_Trans
   order: [sbj, ^]

Parsing as constraint satisfaction

• Constraint satisfaction
  • <X, D, C>: X a set of variables, D a domain of values, C a set of constraints
  • Constraint — <t, R>: t a tuple of variables, R a set of tuples of values; or an explicit relation between variables
  • Solution — an assignment of the variables that satisfies all of the constraints
  • NP-complete, but heuristics can make it tractable
• Constraint satisfaction as search (as in XDG)
  • Goal?
    • Propagate: for all relevant constraints, infer new domains for their variables if possible
    • Are all variables determined?
  • Extend
    • Distribute: for some variable that is not determined, create two search tree nodes, one with one value (or set of values), the other with the complementary values for that variable
  • Example of propagation
    `?x in {1, 2, 3}, ?y in {1, 2, 3}`
    `C: ?x < ?y`
    `text(infer): ?x in {1, 2}`
  • Example of distribution
    `?y: {1, 2, 3}`
    `text(node1): ?y = 1, text(node2): ?y: {2, 3}`
• Set variables
  • Lower and upper bounds on domain and cardinality
  • Example constraints
    `?s1 = ?s2 cup ?s3`
    `|?s4| < ?i1`

Parsing in XDG

Jack likes snakes .

• Lexicalize, e.g.

  node0
     syn
        ins: {sbj: ?}
  node1
     syn
        outs: {sbj: !}
  

• Based on principles for each dimension,
  • Create variables, e.g.,
    descendants of node1 (likes): `?d1`
    root of sentence: `?text(root)`
    all nodes: `?V`
    daughters on sbj arc of node1 (likes): `?D1text(sbj)`
    mothers on sbj arc of node0 (Jack): `?M0text(sbj)`
  • Instantiate constraints, e.g.,
    `|D1text(sbj)| = 1`
    `|M0text(sbj)| in {0, 1}`
• Progagate constraints.
• Repeatedly distribute and progagate constraints until one or more solutions is found (this example requires no distribution).
• A solution; some variable values:
  `?D1text(sbj) = {0}, ?M0text(sbj) = {1}, ?d1 = {0, 2}, ?text(root) = {3}, ?V = {0, 1, 2, 3}`