Linguistics 471: Grammar Engineering

Lab 6 Due 5/23

Read all the way through the assignment once before starting it. Once again I'll be asking for write ups, and basing a significant portion of the grade on the write up. This means that even if you don't get something working, you can get a lot of partial credit for describing the problem and how you attempted to handle it, and you best guess as to why it's not working. Conversely, you could have everything working properly, but if you don't describe the phenomena (with glossed examples) and how you handle them in your write up, you won't get full credit.

Background

This lab has two goals:

Introduce messages into the semantics of clauses.
Handle the syntactic differences between matrix and subordinate clauses and declarative and (polar) interrogative clauses.

Correction: Contrary to what I said in lecture, MSG is not a HOOK feature. Rather, it is a feature parallel to HOOK. This is important, as we want to systematically identify the C-CONT.HOOK (and therefore the SYNSEM..CONT.HOOK) with the CONT.HOOK of the semantic head daughter if there is one. However, in many cases the CONT.MSG of the phrase and the CONT.MSG of the semantic head daughter will be different.

Semantic representations

This section gives example semantic representations (of the form produced by the "Indexed MRS" option) to compare your results to. The focus of this weeks lab is the message relations: getting the proper number of them, and relating them in the right way to the other relations.

Matrix declarative

Cats sleep.

< h1, e2:SEMSORT:TENSE:ASPECT:MOOD,
{ h3:_cat_n_rel(x4:SEMSORT:BOOL:THIRD:PL),
  h5:indef_q_rel(x4,h7,h6),
  h8:_sleep_v_rel(e2,x4),
  h1:proposition_m_rel(h9)},
{h6 qeq h3,
 h9 qeq h8 }>

Things to note: The proposition_m_rel has the same handle as the (local) top, and the single argument of the proposition_m_rel qeqs the handle of the verb.

Matrix interrogative

Do cats sleep?

< h1, e2:SEMSORT:TENSE:ASPECT:MOOD,
{ h3:_cat_n_rel(x4:SEMSORT:BOOL:THIRD:PL),
  h5:indef_q_rel(x4,h7,h6),
  h8:_sleep_v_rel(e2,x4),
  h1:question_m_rel(h9),
  h9:proposition_m_rel(h10)},
{h6 qeq h3,
 h10 qeq h8 }>

The main difference between this and the previous mrs is addition of the question_m_rel. The local top handle is now the label of the question_m_rel, which takes the proposition_m_rel's handle directly as its sole argument. The argument of the proposition_m_rel is still related via qeq to the label of the _sleep_v_rel.

Embedded declarative (with matrix declarative)

Cats know that dogs sleep.

< h1, e2:SEMSORT:TENSE:ASPECT:MOOD,
{ h3:_cat_n_rel(x4:SEMSORT:BOOL:THIRD:PL),
  h5:indef_q_rel(x4,h7,h6),
  h8:_know_v_rel(e2,x4,h9),
  h10:_dog_n_rel(x11:SEMSORT:BOOL:THIRD:PL),
  h12:_indef_q_rel(x11,h14,h13),
  h15:_sleep_v_rel(e16:SEMSORT:TENSE:ASPECT:MOOD,x11),
  h9:proposition_m_rel(h17),
  h1:proposition_m_rel(h18)},
{h6 qeq h3,
 h13 qeq h10,
 h17 qeq h15,
 h18 qeq h8  }>

Now there are two proposition_m_rels, one for the matrix clause and one for the embedded clause. The arguments of the proposition_m_rels qeq the handles of the verbs, but the argument of _know_v_rel takes the handle of the lower proposition_m_rel directly.

Embedded interrogative (with matrix declarative)

Cats know whether dogs sleep.

< h1, e2:SEMSORT:TENSE:ASPECT:MOOD,
{ h3:_cat_n_rel(x4:SEMSORT:BOOL:THIRD:PL),
  h5:indef_q_rel(x4,h7,h6),
  h8:_know_v_rel(e2,x4,h9),
  h11:_dog_n_rel(x12:SEMSORT:BOOL:THIRD:PL),
  h13:_indef_q_rel(x12,h15,h14),
  h16:_sleep_v_rel(e17:SEMSORT:TENSE:ASPECT:MOOD,x11),
  h9:question_m_rel(h10),
  h10:proposition_m_rel(h18),
  h1:proposition_m_rel(h19)},
{h6 qeq h3,
 h14 qeq h11,
 h18 qeq h16,
 h19 qeq h8  }>

This one is just like the preceding one, except there is a question_m_rel in addition to the proposition_m_rel for the embedded clause. Note that _know_v_rel takes the handle of the embedded question_m_rel as its argument directly (no qeq) and the embedded question_m_rel takes the embedded proposition_m_rel as its argument directly (again, no qeq). The next link in the chain (between the argument of the embedded proposition_m_rel and the _sleep_v_rel) does have a qeq.

Once you've got all of these, matrix interrogatives with embedded declaratives or interrogatives should follow!

`matrix.tdl` patch

There is an updated version of matrix.tdl, which you'll need for this lab. Download it, reload your grammar, and test to make sure your coverage hasn't changed. If it has, talk to me, and I'll help you debug.

Construct a test suite

Include positive examples of each clause type (matrix declarative, matrix interrogative, embedded declarative, embedded interrogative---these latter two will of course be in sentences which also exemplify matrix clauses of some type).
Include negative examples (as many as you can) of clauses with the wrong syntax for their type.
If you have verbs which embed propositions but not questions, or vice versa, include negative examples where they are given the wrong type of complement.

Syntactic differences between clauses

Your first step in this lab should be to cover the syntax of your clause types. Once that it working, worry about the semantics.

Everyone will need to implement a clause-embedding verb type (another subtype of verb-lex). This one should inherit from clausal-second-arg-trans-lex-item (defined in matrix.tdl) as well as verb-lex (defined in esperanto.tdl), and constrain the CAT value of its complement appropriately.

In addition, you may need to implement one or more of the following:

Complementizers (treat as heads taking sentential complements)
Word order variations
Sentence final particles (question markers) (treat as heads taking sentential complements)
Sentence initial particles (question markers) (treat as heads taking sentential complements)
...

Think before you code! There's too much variety across languages in this domain for me to sketch out all the relevant possibilities in this lab, so you'll need to plan out what you're going to try. I'm happy to answer questions as you do.

To give you some guidance, I describe below what I did for English while testing out the matrix for this lab.

Semantic differences between clauses

There are two parts to the problem of getting the semantics right for clauses:

Making sure each clause type gets the right message(s) inserted.
Making sure that the syntax and semantics correlate as they are supposed to (e.g., if there is a word order that is particular to interrogative clauses, it shouldn't get a parse with propositional semantics).

The matrix has done most of the work for (1), it's just a matter of hooking it in to your grammar in the right way. Hopefully, the English examples below will be useful in this regard.

What I did for English

The analyses I'm going to describe here cover a lot of the possibilities, although you might find that what's useful for embedded interrogatives in English is actually what you need for matrix polar questions in your language, etc. That isn't to say that everything you need is here. If it doesn't seem to be, talk to me!

Declarative matrix clauses

The syntax of these matches what I've been doing so far.
To get the semantics right, I had my head-subj-phrase inherit from declarative-clause (defined in matrix.tdl) in addition to the types it already inherits from.
In addition, since declarative-clause as defined leaves the C-CONT.RELS and C-CONT.HCONS underspecified, I needed to bind them off.

head-subj-phrase := basic-head-subj-phrase & head-final & declarative-clause &
  [ SYNSEM.LOCAL.CAT.VAL.COMPS < >,
    HEAD-DTR.SYNSEM.LOCAL.CAT.VAL.COMPS < >,
    C-CONT [ RELS < ! *top* ! >,
             HCONS < ! *top* ! > ]].

Interrogative matrix clauses

English matrix yes-no questions are syntactically marked by subject-auxiliary inversion.
To analyze this, I wrote a lexical rule which applies to auxiliaries only, and moves the subject from the SUBJ list to the beginning of the COMPS list.

It's a lexeme-to-lexeme rule, and I can't copy up the SYNSEM value, so it gets a bit messy copying up every else. Here's the complete version:

inv-lex-rule := const-ltol-rule &
  [ INFLECTED +,
    SYNSEM [ NON-LOCAL #non-loc,
	     LOCAL [ CAT [ HEAD verb &
				[ AUX +,
				  INV +,
				  FORM #form],
			   VAL [ SPR #spr,
				 COMPS < #subj . #comps >,
				 SUBJ < anti-synsem >,
				 SPEC #spec ],
			   MC #mc,
			   HC-LIGHT #hc,
			   POSTHEAD #ph ],
		     CONT #cont,
		     CTXT #ctxt,
		     ARG-S #arg-s,
		     AGR #agr ],
	     LIGHT #light ],
    DTR.SYNSEM [ NON-LOCAL #non-loc,
		 LIGHT #light,
		 LOCAL [ CAT [ HEAD [ AUX +,
				      FORM #form ],
			       VAL [ SPR #spr,
				     COMPS #comps,
				     SUBJ < #subj & synsem >,
				     SPEC #spec ],
			       MC #mc,
			       HC-LIGHT #hc,
			       POSTHEAD #ph ],
			 CONT #cont,
			 CTXT #ctxt,
			 ARG-S #arg-s,
			 AGR #agr ]]].

And here's the really contentful part, without all the rest of the copying:

inv-lex-rule := const-ltol-rule &
  [ INFLECTED +,
    SYNSEM.LOCAL.CAT [ HEAD verb &
                            [ AUX +,
                              INV +,
                              FORM #form],
                       VAL [ COMPS < #subj . #comps >,
                             SUBJ < anti-synsem > ]],
    DTR.SYNSEM.LOCAL.CAT [ HEAD [ AUX +,
                                  FORM #form ],
                           VAL [ COMPS #comps,
                                 SUBJ < #subj & synsem > ]]].

In order to write this rule, I needed to add features AUX (auxiliary) and INV (inverted) (both with default value bool to my type verb. The feature INV keeps track of which phrases are headed by inverted auxiliaries, so I can check for that in constructions like the matrix yes-no question rule.u

In order to associate the right semantics with inverted clauses in English, I wrote a non-branching construction which inherits from the matrix type interrogative-clause. This construction does some semantic work (since the matrix type is underspecified), and also makes sure that its daughter has the appropriate syntax.

yes-no-q-phrase := interrogative-clause & head-only & 
 [ SYNSEM.LOCAL.CAT [ VAL [ SPR #spr & <>,
			    COMPS #comps & <>,
			    SUBJ #subj & < anti-synsem >,
			    SPEC #spec ],
		      MC + ],
   C-CONT [ RELS < ! [ MARG #marg1 ],
		    [ LBL #marg1,
		      PRED proposition_m_rel,
		      MARG #marg2 ] ! >,
	    HCONS < ! qeq & [ HARG #marg2,
			     LARG #hdtop ] ! > ],
   HEAD-DTR.SYNSEM.LOCAL [ CAT [ VAL [ SPR #spr,
				       COMPS #comps,
				       SUBJ #subj,
				       SPEC #spec ],
				 HEAD.INV + ],
			   CONT [ MSG no-msg,
				  HOOK.LTOP #hdtop ]]].

Note that there are two things on C-CONT.RELS. The first is the question_m_rel (supplied by interrogative-clause in matrix.tdl). The second is the proposition_m_rel which needs to be embedded in it. (We don't want to specify both in interrogative-clause itself, since in some cases, you might want a construction like this one whose daughter is already a declarative clause, and hence which already has the proposition_m_rel.) The construction also does the linking between MARGs, LBLs, and LTOPs, using one qeq.
The valence features are copying from daughter to mother, and also checked to make sure that the subject and complement requirements are both satisfied.
Finally, the mother is marked as [CAT.MC +], so that these inverted clauses can be kept out of embedded environments.

Having added this much, I was getting two parses for Can I eat glass?, one which had the yes-no-q rule at the top, and one which didn't. In order to force it to apply, I added a new constraint to my root definition in roots.tdl, requiring a contentful MSG value.

root := phrase &
   [ SYNSEM.LOCAL [ CAT [ HEAD verb & 
                               [ FORM fin ],
                          VAL [ SUBJ < anti-synsem >,
                                COMPS null ]],
                    CONT.MSG message ]].

To make this effective, I also had to say something about the MSG value of the head-comp rule. In anticipation of my treatment of embedded clauses, I make it depend on the MSG value of the daughter. (This means that I will have to rely on other constraints conspiring with this one to rule certain other things as matrix clauses. So far, it works.)

head-comp-phrase := basic-head-comp-phrase & head-initial &
  [ SYNSEM.LOCAL.CONT.MSG #msg,
    HEAD-DTR.SYNSEM.LOCAL.CONT.MSG #msg ].

Accordingly, I constrain verbs to be [MSG no-msg].

verb-lex := basic-verb-lex &
  [ SYNSEM.LOCAL [ CAT [ HEAD verb & [ INV - ],
			 VAL [ SPR < >,
			       SUBJ < #subj & [ LOCAL [ CAT.VAL.SPR < >,
						CONT.HOOK.INDEX #xarg ]] >,
			       SPEC < > ] ],
		   ARG-S < #subj, ... >,
		   CONT [ MSG no-msg,
			  HOOK.XARG #xarg ]]].

Finally, in order to parse Do cats sleep?, I added a semantically empty verb do, which is AUX +, and made sure that main verbs like sleep are AUX -. (This is essentially the HPSG analysis of do-support.)

do-support-lex := no-hcons-lex-item &
[ SYNSEM.LOCAL [ CAT [ HEAD verb & 
                            [ AUX +,
                              INV - ],
		       VAL [ SUBJ < #subj & [ LOCAL [ CAT [ HEAD noun &
								 [ CASE nom ],
							    VAL.SPR < >],
						      CONT.HOOK.INDEX #ind ]]>,
			     SPR < >,
			     COMPS < #comps &
				     [ LOCAL [ CAT [ HEAD verb & 
							  [ FORM base,
							    AUX - ],
						     VAL [ SUBJ < unexpressed-reg >,
							   COMPS < >]],
					       CONT.HOOK #hook & 
						       [ XARG #ind ]]] >,
			     SPEC < > ]],
		 CONT [ HOOK #hook,
			RELS < ! ! >,
			MSG no-msg ],
		 ARG-S < #subj, #comps > ]].

Embedded clauses

English embedded finite declarative and polar interrogative clauses look like matrix declarative clauses with a prepended that or whether (or if).
In many cases, the that is actually optional.
I use the same head-subj rule for embedded clauses, and then combine it with the complementizer (that or whether) via the head-comp rule.
that doesn't need to add any message semantics, but whether does.
whether adds just the question_m_rel, as the embedded proposition_m_rel is already supplied by the head-subj phrase.
In order to define complementizers, I need a new subtype of head. Anticipating the optionality of that, I'll make this subtype similar to verb in that they share a supertype and can both bear the feature FORM.
```
no-mod := head &
	  [ MOD < >].

verbal := no-mod &
	  [ FORM form ].
	
verb := verbal &
	[ AUX bool,
	  INV bool ].

comp := verbal.
```

Here is the lexical type for complementizers. It inherits from basic-one-arg (defined in matrix.tdl), since none of the more specific subcategorization types are appropriate. It has one element on its ARG-S, identified with the sole element of its COMPS list. It requires that element to be a finite declarative clause. It identifies its own HOOK.INDEX with its complements HOOK.INDEX.

complementizer-lex := basic-one-arg &
  [ SYNSEM.LOCAL [ CAT [ HEAD comp,
			 VAL [ SPR < >,
			       SUBJ < anti-synsem >,
			       COMPS < #comps & 
				       [ LOCAL [ CAT [ HEAD verb &
							    [ FORM fin ],
						       VAL [ SUBJ < anti-synsem >,
							     COMPS < > ]],
						 CONT [ MSG.PRED proposition_m_rel,
                                                        HOOK.INDEX #ind ]]] >,
			       SPEC < > ]],
		   CONT.HOOK.INDEX #ind,
		   ARG-S < #comps > ]].

The subtypes for that and whether look like this. Note that neither one needs any HCONS.

that-comp-lex := complementizer-lex &
  [ SYNSEM.LOCAL [ CAT.VAL.COMPS < [ LOCAL.CONT [ MSG #msg,
						  HOOK.LTOP #ltop ]] >,
		   CONT [ MSG #msg,
			  HOOK.LTOP #ltop,
			  RELS < ! ! >,
			  HCONS < ! ! > ]]].

whether-comp-lex := complementizer-lex &
  [ SYNSEM.LOCAL [ CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.LTOP #marg ] >,
		   CONT [ MSG message & #msg &
			      [ LBL #ltop,
				PRED question_m_rel,
				MARG #marg ],
			  HOOK.LTOP #ltop,
			  RELS < ! #msg ! >,
			  HCONS < ! ! > ]]].

There are corresponding instances in lexicon.tdl.

Finally, in order to embed these embedded clauses under something, I need a lexical type for verbs like know:

clausal-comp-verb-lex := main-verb-lex & clausal-second-arg-trans-lex-item &
  [ SYNSEM.LOCAL [ CAT.VAL.COMPS < #comps &
			       [ LOCAL [ CAT [ HEAD verbal &
						    [ FORM fin ],
					       VAL [ SUBJ < anti-synsem >,
						     COMPS < > ],
					       MC - ],
					 CONT.MSG message ]]>,
		   ARG-S < [] , #comps > ]].

Requiring [MSG message] and [MC -] on the complement keeps the inverted strings out (*Cats know do dogs sleep?).

Test your grammar

Use your test suite to check the syntactic coverage of your grammar.
Examine the semantic representations you assign to each of the clause types, and compare them to the examples given in the lab instructions.
Check for overgeneration (syntactic forms associated with one clause type showing up in other clause types, multiple parses for single sentences with spurious clause type assignments or lack of clausal semantics).

Write up

Describe the syntactic properties of the four clause types in your language. Illustrate your points with glossed examples.
Describe the current coverage of your grammar with respect to those properties.
Describe how you handled these syntactic properties (or attempted to handle them).
Describe how you handled the semantic properties (or attempted to handle them).
Indicate which clause types are getting correct semantic representations (according to the examples given at the beginning of this assignment), and how those that aren't differ.

Submit via ESubmit

Be sure your matrix folder includes your write-up.
Consider removing the doc/ subdirectory in order to save space on E-Submit.
Compress the folder, and upload it to ESubmit.
Submit it by midnight Sunday night (preferably by Friday evening :-).

Back to main course page