Linguistics 471: Grammar Engineering

Lab 5 Due 5/16

The goal of this lab is to allow for unexpressed arguments. As many of you have noticed, there are plenty of languages that don't use pronouns as much as English does, but rather leave the NP out entirely if it was just going to be a pronoun. Generally, the meaning is about as recoverable from context as it is with pronouns (afterall, pronouns only give small clues to the referent in terms of person, number, and gender; among 3rd person referents, that usually leaves a lot of ambiguity). In some languages (e.g., Spanish), this kind of pronoun omission seems to be 'licensed' by the fact that the verbal inflections carry as much information as the pronouns would. In other languages (e.g., Japanese), the verbal inflections don't in fact carry person/number/gender information, but pronouns still aren't required.

Even in English (which likes pronouns so much that it has two expletive [meaningless] ones -- it and there) there are cases where arguments appear to be optional. Prime examples are verbs like eat and drink. The sentence I already ate means 'I already ate something', but the addressee is in no way expected to know what exactly was eaten. This is called indefinite null instantiation (see e.g., Johnson and Fillmore 2000) This contrasts with definite null instantiation (ibid), in which null arguments have definite reference, that is, the utterance is only felicitous if the addressee can determine the referent. English verbs which do this include tell as in I already told you. (Which is a cute example, because it's most likely to be used in a case where the addressee can't determine what exactly s/he was already told, but it's licensed because it means something like 'I already told you the answer to that question'.)

Our general strategy is going to be similar to the way we handled missing determiners. That is, we're going to write unary phrase structure rules in which the mother and single daughter have different valence requirements.

I believe that most languages should fall into one of the following patterns (restricting our attention to verbs and their arguments):

• Any argument can be left out with the definite interpretation. Non-subject arguments of certain verbs can also receive the indefinite interpretation when they are missing.
• Any subject can be left out with the definite interpretation. Non-subject arguments of certain verbs can also be omitted. Their interpretation (definite or indefinite) is lexically determined by the verb.
• Subjects are required, but non-subject arguments of certain verbs can be left out, with definite or indefinite reference depending on the verb.

I've written this assignment based on those three possibilities, and it should be straight-forward to the extent that I'm right :-). If your language instantiates a different pattern, talk to me.

Matrix.tdl patch

There is an updated version of matrix.tdl. 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.

Create instances of rules

• The Matrix (patched version) provides definitions of basic-head-opt-subj-phrase and basic-head-opt-comp-phrase which should be specific enough.
• If your language allows subject pro-drop, create an instance of basic-head-opt-subj-phrase in rules.tdl.
• Parse a sentence without a subject to see if it works.
• If your language allows object pro-drop (in general, or only certain arguments of certain verbs), create an instance of basic-head-opt-comp-phrase.
• Parse a sentence with a missing object to see if it works.
• (At the moment, this might overgenerate, as it should allow any complement to go missing, and not all languages allow that. We'll fix it presently.)

Clean up your verb type hierarchy

We're going to be creating some more subtypes of verbs, so it's time to a little house cleaning, if you haven't already.

• Define a type verb-lex which inherits from basic-verb-lex.
• Make all of your other types which inherited from basic-verb-lex inherit from verb-lex instead.
• Reload your grammar and parse a sentence to make sure things still work. Debug as necessary.
• Now look at all of your subtypes of verb-lex and find what constraints they have in common (e.g., they should all be [HEAD verb].
• Remove all of those repeated constraints from the subtypes and state them once on verb-lex instead.
• Reload your grammar and parse a sentence to make sure things still work. Debug as necessary.
• Look in lexicon.tdl at your verb lexical entries. If there are any constraints on those lexical entries other than values for STEM and LKEYS, move them up to the types instead. You may need to create some new subtypes in the process.
• Reload your grammar and parse a sentence to make sure things still work. Debug as necessary.
• Now run your test suite and check that your coverage hasn't changed. Debug as necessary.

Add ditransitive verbs

• Add a new subtype of verb-lex which inherits from the type ditransitive-lex-item (defined in matrix.tdl). This new subtype should have two elements on its COMPS list, and three things on ARG-S.
• Create at least one instance of the new subtype in lexicon.tdl. Places to look for ditransitive verbs include the translations of give, sell, and tell.
• Some languages don't allow two NP complements, and so you might see PP complements for the first time. If this comes up, talk to me.
• You might find that you need to add a new value of CASE and a corresponding lexical rule.
• Add examples (positive and negative) to your main test suite to test ditransitive verbs.

Add verbal subtypes for argument optionality

For expository purposes, I'm assuming that you have subtypes of verb-lex called trans-verb-lex and ditrans-verb-lex. If you've called them something else, not to worry, just use your corresponding types whenever I mention these.

For languages without general pro-drop of objects

• If you have an example of a transitive verb with an optional argument, create two subtypes of trans-lex.
  • One (for verbs whose arguments are not optional), should say [OPT -] on the complement.
  • The other can leave the value of OPT unspecified, but should possibly specify a value for DEF-OPT, + if the argument gets a definite interpretation when missing, - if the argument gets an indefinite interpretation, and underspecified if it could be either.
  • (You might find that you need multiple subtypes here, if you have examples of different verbs with different behavior.)
• Edit lexicon.tdl so that the lexical entries which used to inherit from trans-verb-lex now inherit from your new subtypes.
• If you have an example of a ditransitive verb with an optional argument, make analogous subtypes of ditrans-verb-lex and change your lexicon accordingly. Note that when dealing with ditransitive verbs, you have to pay attention to both elements of the COMPS list.
• Otherwise, constrain ditrans-verb-lex itself to ensure that both arguments are [OPT -].

For languages with general pro-drop of objects

• If you have an example of a transitive verb for which a missing object can have either definite or indefinite reference (the translation of eat would be a likely suspect), create two subtypes of trans-verb-lex.
  • One specifies [DEF-OPT +] on the complement.
  • The other should leave DEF-OPT unspecified on the complement (thus allowing either interpretation).
• Edit lexicon.tdl so that the lexical entries which used to inherit from trans-verb-lex now inherit from your new subtypes.
• If you have an example of a ditransitive verb which allows indefinite null instantiation for one or more of its arguments, make analogous subtypes of ditrans-verb-lex and change your lexicon accordingly. Note that when dealing with ditransitive verbs, you have to pay attention to both elements of the COMPS list.
• Otherwise, constrain ditrans-verb-lex itself to ensure that both arguments are [DEF-OPT +].

Construct a test suite

• Construct a test suite illustrating argument optionality in your language. Include positive examples (arguments being left out legitimately) and negative examples, if possible (arguments being left out where they shouldn't be). Be sure to include examples of both definite and indefinite null instantiation.
• In addition to making a separate test suite for this assignment, add these sentences to your general test suite.
• Use batch parse to test the syntactic coverage of your grammar over this test suite. Include the resulting test.out file when you turn in your homework, and describe your coverage in your write up. (NB: I'll be allocating points to this description, whether or not you have perfect coverage, so do the write up!)
• Parse some representative sentences one at a time and check the semantics. Is the value of DEF on the relevant arguments correct? Describe the examples you tested and the results you found in your write-up (again, points allocated just for doing the write-up, whether or not your grammar has the right behavior yet).

Write up

• Describe the sentences that you added to your test suite for ditransitive verbs, and any other things you need to add (PPs, a new value for case, etc).
• Describe the situation with respect to argument optionality in your language (as best you were able to determine it).
• Describe the lexical types that you made to account for the pattern you found.
• Describe how you tested your analysis, and any ways in which the grammar is not yet having the correct behavior.

Submit via ESubmit

• Be sure your matrix folder includes your write-up and test.out.
• 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 :-).