Lab 2: Word order, small vocabulary, lexical semantics

Due 4/8/05

Download the Grammar Matrix

• Here's the file: matrix.tar.gz (v0.8.1)
• Save it in your working directory (if on the Treehouse machines, your personal directory inside ~ling567), and unpack it:

  tar xzf matrix.tar
  

Start the LKB and load the grammar Matrix

• Start the LKB: M-x lkb (note change from last time).
• Load the grammar Matrix (the script file is inside the lkb directory.

Personalize your copy of the Matrix

• Rename the file my_language.tdl to reflect the language you are working on, e.g., esperanto.tdl.
• Consider opening it in emacs and adding some comments to the beginning. The comment character is ;.
• Open the file lkb/script and replace my_language.tdl with your new file name. (It only occurs twice, once in a comment (;;;) that you don't need to change, and once in the code.)
• Observe that the bar across the bottom of the emacs window changes when you've made a change to the current buffer.
• Save the changes to script (C-x s), and observe the bar across the bottom changing again.
• Go to the very end of the script file, uncomment the last two lines, and fill in two (or more, if you like) test sentences that you'll be working with. This will save you from having to delete "the dog barks" from the parse dialogue every time you load the LKB.
• Save your changes again.
• Open the file matrix.tdl.
• Make sure you know how to switch between buffers so you can get to matrix.tdl and your renamed my_language.tdl. (C-x b)

Make a small testsuite

Make a small testsuite (lab1.items) illustrating intransitive and transitive sentences in your language. Ungrammatical examples should illustrate ungrammatical word orders, elements of the wrong part of speech showing up as verbal arguments, etc. Your testsuite show also illustrate the determiner optionality facts you discovered. Be sure to include all of your lexical items in the grammatical examples. Use comments in your testsuite file to provide glosses for your items (word by word and `free' translation).

Add lexical types and lexical entries

Note The default place to make changes is your renamed my_language.tdl file. In principle, you should not need to make any changes to matrix.tdl. You may need to use some other files (e.g., for lexical entry and rule instances). In the following instructions, if no particular file is mentioned, use your renamed my_language.tdl file.

• Create lexical types for each kind of word that you have (ignoring case and agreement for now: we'll add them in next week). Verb types should inherit from basic-verb-lex and one of the subcategorization/linking types (see notes in matrix.tdl). The type for nouns should inherit from basic-noun-lex and basic-one-arg. The type for determiners should inherit from basic-determiner-lex and basic-zero-arg. In addition, these new types should specify identities between the elements of ARG-ST and the valence lists, and place appropriate constraints on the HEAD and VAL values of those elements. Empty valence lists should be so specified. Note that unlike in SWB, we differentiate between the SPR of nouns and the SUBJ of verbs. Further, heads and specifiers mutually select each other, with the specifiers using the SPEC feature to do their part. (The SPEC value does not map to anything on ARG-ST.) Note also that we're analyzing all nouns as requiring a specifier. Detless NPs will be handled via a non-branching rule.
• Reload the grammar (LKB > Load > Reload grammar) and fix any errors that the LKB reports (in the LKB interaction window).
• Look at the type definition for one of your lexical types (LKB > View > Type definition). This should show exactly what you typed in, in a slightly different format.
• Look at the expanded type for the same type (LKB > View > Expanded type). All of that additional information is inherited from the supertypes you specified.
• Open the file lexicon.tdl and replace the dummy entry (foo) with a noun instance, inheriting from your noun type:

  penguin := noun-lex &
    [ STEM < "penguin" > ].
  

  Use fully inflected forms for now. We'll add inflectional rules later. This lexical entry is also missing semantics. We'll get to that in a moment.
• Test the entry by reloading the grammar and trying to parse a string with just that word. (I've set things up in this version of the Matrix so that words count as stand alone utterances.)
• Add your remaining lexical entries, and test them.

Add phrase structure rules

• Determine the basic word order of your language.
• Look in the subdirectory matrix/modules. This directory contains, among other things, type and instance files for various word orders. Locate the types file that matches your basic word order (SOV.tdl, OSV.tdl, V-final.tdl, free-order.tdl, etc). In the comments at the top of the file, you find a reference to the "rules" (instance) file you want to use.
• Incorporate the type definitions from the types file you selected into matrix/esperanto.tdl.
• Incorporate the instance definitions from the rules file you selected into matrix/rules.tdl.
• Create a type for head-secifier phrases in your language (with overt specifiers). It should inherit from basic-head-spec-phrase and either head-initial or head-final, as appropriate.
• Add an instance head-spec (or spec-head) in rules.tdl.
• Reload the grammar, and correct any errors detected by the LKB.
• Try parsing a sentence.
• Try parsing your testsuite.
• Debug as necessary.
• Write up #1: Indicate what the basic word order is in your language, as well as the order of nouns and determiners. Provide glossed examples illustrating the generalizations. If you feel that you had to simplify anything about the data in order to do this part of the lab, describe the simplifications.

• In order to make the machine translation exercise work at the end of the quarter, we want to use identical PRED values across all the different grammars. So, we will adopt the following convention:
  • Predicate names are based on English translations of the words in question, using citation forms only (i.e., singular forms for nouns, base forms for verbs).
  • Predicate names follow the following template:

    _Englishtranslation_pos_rel
    

  • ... where pos is drawn from the following set: n, v, j (adjective), r (adverb), p (adposition), q (determiner)
• For determiners, please select from the following inventory:

  'def_q_rel           ; definite
  'indef_q_rel         ; indefinite
  'demonstrative_q_rel ; demonstrative, if your language only has one
  'proximal+dem_q_rel  ; demonstrative, near speaker (cf English 'this')
  'distal+dem_q_rel    ; demonstrative, away from speaker (languages with
                       ; two-way contrast, cf English 'that')
  'hearer+dem_q_rel    ; demonstrative, near hearer (languages with 
                       ; three-way contrast
  'remote+dem_q_rel    ; demonstrative, away from speaker and hearer 
                       ; (languages with three-way contrast)
  

  If this inventory is inadequate to the distinctions expressed by determiners in your language, please talk to me.
• Your lexical entries presently look something like this:

  gato := noun-lex &
    [ STEM < "gato" > ].
  

• For each one, you can add a relation name as follows:

  gato := noun-lex &
    [ STEM < "gato" >,
      SYNSEM.LKEYS.KEYREL.PRED '_cat_n_rel ].
  

• NB: Don't forget the ' at the beginning of the pred name. That tells the LKB it's a string and not a type.
• Now parse a sentence again and look at its MRS and admire the relation names that have appeared there.
• The various views on the MRS available through the menu on the small tree are generated by the LKB on the basis of the feature structure. To see the information in feature structure itself:
  • Click on the small tree, and select "Show enlarged tree".
  • Click on the S at the top of the tree, and select "Feature structure".
  • Scroll the window until you can see the value of the path SYNSEM.LOCAL.CONT.
  • Appreciate the easier-to-read views provided by the LKB!
• Write-up #2: Write up (in a couple of paragraphs) what you've done for the determiners, i.e., which determiners your grammar has, which PRED values you gave them, and why.

• Define a subtype of your lexical type for nouns, which constrains the single element of the SPR list to be [OPT -]. Nouns which require determiners will inherit from this type, all others will continue to inherit from the general lexical type for nouns directly.
• Reload your grammar and test whether it has the right behavior for nouns which require determiners and nouns which don't. (I.e., try both kinds of nouns with and without determiners and see what happens.)
• Check your testsuite to make sure that your coverage on the other sentences has not changed.
• Write-up #3: Write up (in a couple of paragraphs) what you've done for this part, i.e., under which conditions determiners are obligatory/optional, and the sentences you used to test that you're getting it right. (Please gloss your sentences for me!)

• In the LKB window, select "Options > Expand menu".
• In the new (expanded) LKB window, select "Generate > Index". (This tells the LKB to make an index of all the lexical items and rules by the semantic relations they contribute. You'll need to redo it every time you load the grammar.)
• Parse a sentence.
• Click on the small tree and select "Generate".
• Examine the strings that come back. Is there more than one? Are they all grammatical? Do they actually mean the same thing? (If they don't, then theoretically they shouldn't be generated from the same semantic representation.)
• Write-up #4: For your write-up of this section, find a sentence that gives you some spurious string when you parse it and then generate. Describe why the strings are spurious and what information you'd need to add to your grammar to rule them out. Don't forget to gloss the sentences for me! (If you're having a hard time finding a sentence which gives back spurious strings, try adding determiners with different agreement values, if you language has them. If not, and you really can't find such a sentence, submit instead all of the sentences you tried.)

• Be sure your matrix folder includes four write-ups (1 2 3 4). Since I'm curious how much time this process takes, if you're willing, please estimate the amount of time it took you to complete this lab, and indicate it in your write up.
• Compress the folder (.tgz is preferred), and upload it to ESubmit.
• Submit it by midnight Sunday night (preferably by Friday evening :-).