LSA.111 HPSG: Optional Lab

Lab Instructions

Preliminary notes

This material is usually taught in a hands-on lab setting with the instructor present. Since I'm on the other side of the country, I will be present "virtually" through the bulletin board. I strongly encourage you to post questions there frequently, and read the answers to all the questions posted. Grammar engineering can be really cool, but to get to the cool part, it's better not to spend hours chasing down a syntax error. My rule of thumb is if you've pondered something for 10 minutes, then it's time to post.

Note that the implemented system is different from the textbook grammar in many ways. The underlying approach is the same, but do not be surprised in differences in feature geometry etc. When in doubt, ask! (Some of these differences come from the exigencies of implementation, some from the history of the resource we're working with, and some from simplifications made for this lab. An example of the latter is the fact that we're not positing any lexical rules in the lab, but rather just creating apparently unrelated entries in many cases.)

In addition, the LKB/Grammar Engineering FAQ might also prove useful. I recommend reading the guide to TDL syntax. (TDL stands for "type description language", and it's what LKB grammars are written in.)

This lab will step you through getting a starter-grammar from the Matrix web site, and then adding case and/or agreement. If your language has neither (overt) case nor agreement, please contact me (ideally on the bulletin board, or by email: ebender at u dot washington dot edu) and we can work out something else to add.

Preparation

The relevant software has been loaded onto the PCs in the computer classroom at MIT. The course page has instructors on how to install it on your on computer (Windows, Mac OS X, Linux).

The lab preparation instructions detail the information you need to collect about the language you choose to work with in order to complete the lab.

If you don't already know how to use emacs, I strongly encourage you to spend an hour working with the emacs tutorial. Run emacs, then select the tutorial from the help menu.

Download your starter package

As discussed in class, the Matrix contains a language-independent core as well as a collection of modules which allow you to customize it for certain properties of your language. Visit the Matrix configuration page to create and download a customized version of the Matrix.

Start up the LKB, and start parsing

• Start the LKB:
  • On a Mac or a Windows machine, this should involve double-clicking on the LKB icon.
  • On a linux machine, start emacs, then type M-x lkb. (M-x is "meta x", which stands for either esc-x or alt-x).
• Load your grammar:
  • From the LKB top menu (the LKB window on Windows/Linux, the menu called LKB at the top of the screen on a Mac), select "Load > Complete Grammar".
  • Navigate to your matrix directory, then to the lkb directory, and choose the file script.
• Try parsing a sentence:
  • From the LKB top menu, select "Parse > Sentence".
  • If you filled out the "test sentences" part of the Matrix customization page, one of them should appear by default in the dialogue.
  • The menu associated with that field ("prev" on Windows/Linux, just arrows on a Mac) should show the other one as well.
  • Click on "parse".
  • Admire the parse tree that appears.
  • Explore the menu options on the parse tree/individual nodes of the parse tree. (On Windows/Linux, one menu option gets you a window with a larger tree where the individual nodes are clickable. On a Mac, the initial window has clickable nodes.)
  • Try generating from the semantic representation of the sentence:
    • Windows/Linux: Select "generate" from the pop-up window on the small tree.
    • Mac: Select "generate from edge" from the pop-up menu on the S node at the top of the tree.

Add some vocabulary

• Using emacs, open the file lexicon.tdl in your matrix directory.
• Copying the form of the entries that are there, add some lexical entries, such as other case forms of the nouns, other agreement forms of the verbs, etc. NB: sleep and sleeps should have the same predicate name.
• Add one or two first, and the reload the grammar (LKB Top > Load > Reload Grammar).
• Look at the LKB window and observe any error messages that are printed out there. Be sure to scroll up to catch any that may have scrolled off.
• Debug as necessary.
• If you used a lot of different words in your test suite file, hold off on adding them in bulk until you've got case and agreement in your grammar below (or you'll find yourself redoing a bunch of work).

Parse again

• Reparse your original sentence, and generate from its semantic representation.
• If you've added other case or agreement forms for the words in that sentence, your grammar should now literally overgenerate. We'll see how to constrain it below.

Try the batch parse facility

• Make sure the test suite you created (in the preparation instructions) is stored as a plain text file, with stars on the ungrammatical examples. Lines beginning with ';' will be treated as comments.
• From the LKB top menu, select "Parse > Batch parse".
• Navigate to your test suite file.
• Provide an output file in the next dialog.
• The LKB will now attempt to parse all the strings in your file.
• Using emacs, open the output file. It should contain a bunch of lines like this:

  1 The cat chased the dog. 1 9
  2 *the the cat dog chased. 0 6
  

  • The first number is the item number.
  • The numbers after the sentence are the number of parses found and the number of edges in the chart, respectively.

Add case to your grammar

In what follows, when you add or modify a type, the default location is in your language-specific types file, which I will call esperanto.tdl. If you need to modify another file, the directions will say so explicitly.

If your language marks case via distinct forms of nouns

• Define a feature case which is appropriate for the type noun, as follows:

  noun :+ [CASE case].
  

  (The notation :+ specifies that you're adding information to a type already defined, in this case, in matrix.tdl.)

• Now define the type case, and appropriate subtypes for it:

  case := avm.
  nom := case.
  ...
  

  (The notation := specifies that the type named on the left is a subtype of the type named on the right.)

• Next create two subtypes of noun-lex, each with distinct values of SYNSEM.LOCAL.CAT.HEAD.CASE. If your grammar already has subtypes of noun-lex to account for different patterns of determiner obligatoriness/optionality, cross-classify these types with the case types:

  obl-spr-nom-noun-lex := obl-spr-noun-lex & nom-noun-lex.
  

• Edit your noun entries in lexicon.tdl to instantiate the subtypes of noun-lex that you created.
• Reload the grammar and fix any syntax errors reported in the LKB window.

If your language marks case via different determiners

• Define the feature CASE for the type noun as above.
• Create two subtypes of determiner-lex which each bear a different value for SYNSEM.LOCAL.CAT.VAL.SPEC.FIRST.LOCAL.CAT.HEAD.CASE. (We're thus treating the determiners not as bearing case themselves, but as specifying that they only combine with nouns of the appropriate case. Note that the SPEC feature allows specifiers and heads to mutually select each other. To see how this works, examine basic-head-spec-phrase in matrix.tdl.)
• In lexicon.tdl, modify your lexical entries for determiners so that they instantiate your new subtypes, rather than determiner-lex. (A determiner underspecified for case could still instantiate determiner-lex.)
• Reload the grammar and fix any syntax errors reported in the LKB window.
• If case is marked only on determiners (and not on nouns, but possibly on adjectives), nothing further needs to be done for the nouns.
• If case is also marked on nouns, follow the rest of the directions above.

If your language marks case via different adpositions

• Add a feature PFORM appropriate for the type adp as follows:

  adp :+ [PFORM pform].
  

  (The notation :+ specifies that you're adding information to a type already defined, in this case, in matrix.tdl.)

• Now define the type pform, and appropriate subtypes for it:

  pform := avm.
  subj := pform.
  ...
  

  (The notation := specifies that the type named on the left is a subtype of the type named on the right.)

• Create two subtypes of case-marker-p-lex, which each bear a different value for SYNSEM.LOCAL.CAT.HEAD.PFORM.
• Modify lexicon.tdl so that your case marker lexical entries instantiate the new subtypes you created.
• Reload the grammar and fix any syntax errors reported in the LKB window.

All languages with case

• Now edit the lexical types for verbs to constrain the SUBJ and COMPS values to bear appropriate features for CASE or PFORM.
• If intransitive and transitive verbs take the same kind of SUBJ, you should be able to state the appropriate constraint on verb-lex.
• You'll likely need to also constrain the COMPS value on transitive-verb-lex.
• Note that the value of SUBJ and COMPS are both lists of synsems. This means that your constraints will need to look something like this:

  [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CAT.HEAD.CASE nom ] > ].
  

Test your grammar

• Try parsing a sentence with incorrect case on the nouns. Does it still parse?
• Try parsing a sentence with correct case on the nouns does it still parse? Is the parse tree as you would expect?
• Try generating from the semantic representation of this sentence. Are you still overgenerating (with respect to case)?
• Debug as necessary.

Add agreement to your grammar

Case agreement was described in the previous section. In this section, we'll focus on person/number/gender agreement. (If your language has still other kinds of agreement, contact me.) Unlike in the textbook, we'll be treating agreement as selectional restrictions (i.e., we won't be using the feature AGR on verbs). Furthermore, we'll be `housing' the agreement features on the value of INDEX, inside CONT (the equivalent of SEM).

• Define features PER, NUM, GEND appropriate for the type png, as needed. (If your language doesn't have gender agreement between verbs and subjects/objects or nouns and determiners, you don't need the feature GEND.

  png :+ [PER person,
          NUM number,
          GEND gender].
  

• Define the types person, number, and gender (again, as necessary), and appropriate subtypes for each.

  gender := avm.
  masc := gender.
  

• Define subtypes of noun-lex for nouns with different agreement properties.

  3sg-noun-lex := noun-lex &
  [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ PER third,
                                       NUM sg ]].
  

• If these agreement properties cross-classify with specifier optionality or case, create appropriate cross-classified subtypes:

  obl-spr-3sg-nom-noun-lex := 3sg-noun-lex & obl-spr-noun-lex & nom-noun-lex.
  

• Note that for number, if only the determiner actually shows the distinction, you don't need to create multiple noun entries. Since gender and person are inherent properties of the noun, you'll want types for these, even if there is no overt marker for them on the noun itself.
• Modify your entries in lexicon.tdl to instantiate the agreement-specifying subtypes.
• Reload your grammar and correct and syntax errors that are noted in the LKB window.

Determiner-noun agreement

[ SYNSEM.LOCAL.CAT.VAL.SPEC < [ LOCAL.CONT.HOOK.INDEX.PNG [ NUM sg,
                                                            GEND fem ]] > ].

fem-sg-nom-det-lex := fem-sg-det-lex & nom-det-lex.

3sg-verb-lex := verb-lex &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER third,
                                                               NUM sg ]] > ].

3sg-trans-verb-lex := 3sg-verb-lex & transitive-verb-lex.