Linguistics 567: Knowledge Engineering for NLP

Lab 8 Due 5/19

Preliminaries

Some of you may have already covered some of this material. If you would like to work on something else this week, let me know what it is.

Run a base-line test suite instance, and save this to submit with your lab. As usual, consider adding to your basic test suite if you have not sufficiently covered the phenomena addressed here.

Part 1: Optional arguments

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.
• In languages with optional agreement marking on the verb, it may be the case that you see the `any old subject' or `any old direct object' being left out pattern only when agreement marking is present. Without agreement marking, you may only find lexically licensed definite/indefinite null instantiation.

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

Create instances of rules

• The Matrix 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.)

Add ditransitive verbs

If you don't already have any verbs that take three arguments, try putting one in:

• 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. (If you're using [incr tsdb()], you might consider making a new skeleton that includes the previous testsuite plus the new items, while keeping your original skeleton around.)

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-verb-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 some, but not all, of your transitive verbs allow indefinite as well as definite interpretations of missing objects, (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 +].

For languages where arugment optionality corresponds to the presence of optional verbal inflection

• Modify your verb inflection lexical rules (if you have them) to change the OPT status of the relevant arguments.
• Consider what the DEF-OPT value of those arguments should be, according to whether the verbal inflection is present or absent.
• Make appropriate changes to DEF-OPT in the lexical entries and lexical rules.

Part 2: Modification

In this part, you will add basic functionality for intersective adjectives and adverbs.

Head-modifier rules

The Matrix distinguishes scopal from intersective modification. We're going to pretend that everything is intersective and just not worry about the scopal guys for now.

• Create an instance of head-adj-int-phrase, an instance of adj-head-int-phrase, or both, depending on whether you need only prehead modifiers, only posthead modifiers, or both.
• Try parsing a transitive sentence. Be surprised by the extra parse. Or, if you don't get an extra parse, try parsing some of your ungrammatical examples from earlier labs. Look at the enlarged trees (or try Parse > Compare) to see what's going on.
• Constrain your existing subtypes of head (verb, noun, det) to be [MOD < >].
• Try parsing the misbehaving sentence again.

Adjectives

• Create a type adjective-lex which inherits from basic-adjective-lex. The following type works for English assuming that:
  1. We're not worried about predicative adjectives or adjectives taking complements for now.
  2. English has both pre-head and post-head modifiers, (head-adj and adj-head), but simple adjectives are (almost) always prehead (hence the value of POSTHEAD).
  3. We're only dealing with intersective adjectives (as stipulated).

  adjective-lex := basic-adjective-lex & intersective-mod-lex &
    [ SYNSEM [ LOCAL [ CAT [ HEAD.MOD < [ LOCAL.CAT [ HEAD noun,
                                                      VAL.SPR ne-list ]]>],
  			   VAL [ SPR < >,
  				 SUBJ < >,
  				 COMPS < >,
  				 SPEC < > ],
  			   POSTHEAD - ]]].
  

• If adjectives in your language agree with nouns in person, number, gender, and/or case, add appropriate constraints to the MOD value of the adjectives. Consider writing lexical rules to create the inflected forms, or at least types representing the different possibilities.
• Create one or more adjective instances.
• (Adjectives separated from the NPs they belong to will have to await further developments. If your language allows this possibility, please document it in your write ups and in your test suites.)

Adverbs

• Create one or more types for adverbs. The following type definition inherits from appropriately-defined Matrix supertypes, and constrains the modified constituent to be verbal.

  adverb-lex := basic-adverb-lex & intersective-mod-lex &
    [ SYNSEM [ LOCAL [ CAT [ HEAD.MOD < [ LOCAL.CAT.HEAD verb ]>],
  			   VAL [ SPR < >,
  				 SUBJ < >,
  				 COMPS < >,
  				 SPEC < > ]]]].
  

• Try parsing a sentence with an adverb and then generating to see where else the adverb can show up. If you language allows multiple attachment sites for the adverb, admire the results. If it doesn't, or doesn't allow *that* many, constrain them further.
• In order to constrain the possible attachment sites for adverbs, you may need to constrain the value of POSTHEAD, or the value of SPR inside MOD or the value of LIGHT inside MOD.

Write up

• Describe the situation with respect to argument optionality in your language (as best you were able to determine it), including glossed examples.
• Describe the lexical types that you made to account for the argument optionality pattern you found and/or any changes to lexical entries.
• Describe how you tested your argument optionality analysis, and any ways in which the grammar is not yet having the correct behavior. Speculate on what might need to be done to fix it.
• Describe the modification facts (for adjectives and adverbs) that you found in your language.
• Describe the constraints you needed to place on lexical types to get the right behavior.
• Describe how you tested your modification analysis, and any ways in which the grammar is not yet having the correct behavior. Speculate on what might need to be done to fix it.

Submit via ESubmit

• Be sure your matrix folder includes your write-up and baseline/final [incr tsdb()] file.
• 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 :-).