Lab 6 (Due 2/15)

Preliminaries

These instructions might get edited a bit over the next couple of days. I'll try to flag changes.

As usual, check the write up instructions first.

There are several places in this lab where I ask you to contact me if your grammar requires information not in these instructions. Please read through this lab by class on Wednesday so we can start that conversation in a timely fashion.

Requirements for this assignment

• 0. Make sure you have a baseline test suite corresponding to your lab 5 grammar.
• 1. Add ditransitive verbs.
• 2. Check that matrix polar questions are working, and fix them if necessary.
• 3. Add sentential complment verbs.
• 4. Fix at least one thing about your grammar.
• 5. Test your grammar using [incr tsdb()]. [incr tsdb()] should be part of your test-development cycle. In addition, you'll need to run a final test suite instance for this lab to submit along with your basline.
• 6. Write up the phenomena you have analyzed.

Run a baseline test suite

Before making any changes to your grammar for this lab, run a baseline test suite instance. If you decide to add items to your test suite for the material covered here, consider doing so before modifying your grammar so that your baseline can include those examples. (Alternatively, if you add examples in the course of working on your grammar and want to make the snapshot later, you can do so using the grammar you turned in for Lab 5.)

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 (or main-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-ST.
• Be sure to constrain the CASE, HEAD, SPR, COMPS and OPT/OPT-CS values of the arguments appropriately. Refer to the verb types you got from the customization system for inspiration.
• 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 test suite to test ditransitive verbs. Be sure to illustrate the various word order possibilities, the required CASE values (if applicable), and the argument optionality.

Matrix yes-no questions

The semantics for declarative and interrogative clauses will be the same except for the value of the feature SF (sentential force) on the event index of the main predicate.

The customization script may have provided the right kind of semantics for matrix yes-no questions already. Try parsing an example from your test suite. If it parses, examine the MRS. Is the value of SF on the INDEX of the clause ques? (Or in the case of intonation questions only, do you get prop-or-ques?)

If your yes-no question doesn't parse, or if it does but not with the right semantics, contact me, and we will work out what needs to be done.

Embedded clauses

Clause embedding verbs

We will be using clausal complements as our example of embedded clauses. To do so, we need to create clause-embedding verbs. First, find examples of verbs that can embed propositions and verbs that can embed questions. If you also find verbs that are happy to embed either, we can make use of them. For inspiration, you can look here or here.

• Create another subtype of verb-lex (or main-verb-lex) which inherits from clausal-second-arg-trans-lex-item (the type for verbs like think, ask, and know).
• Constrain the CAT value of the complement appropriately (the feature specifications of S, CP or either depending on what's going on with your embedded clauses). The CONT.HOOK.INDEX.SF should also be constrained to prop-or-ques.
• Create two subtypes, one which constrains the CONT.HOOK.INDEX.SF to prop and one which constrains it to ques.
• Create lexical entries for verbs inheriting from one or the other subtypes (or the supertype) as appropriate.

If your matrix and embedded clauses look the same, you should be able to test this immediately. If not, you'll have to wait until you've implemented the syntax for your embedded clauses.

Complementizers

Some languages mark embedded clauses (declaractive, interrogative or both) with complementizers (e.g., that and whether in English). To implement this, you'll need to do the following. (If your language also marks matrix questions with a question particle, you have some of the following in your grammar already.)

• Create a type complementizer-lex-item which inherits from raise-sem-lex-item and basic-one-arg. It should identify the one thing on the ARG-ST with the sole item of its COMPS list and otherwise have empty valence features. It's HEAD value should be comp.
• If you have both interrogative and declarative complementizers, make subtypes for each, constraining the CONT.HOOK.INDEX.SF on each of them to question and proposition respectively.
• If you have just one kind of comlementizer, you can put the SF constraint on complementizer-lex-item directly.
• Create lexical entries for your complementizers. These do not need any KEYREL information.

Test your embedded clauses. Do they parse as expected? Can you still generate?

Other strategies

Other possible syntactic differences between main and subordinate clauses include:

1. Differences in word order (the general strategy here will be to add more head-subj and head-comp variants, but to constrain some of them to be [MC +] and/or [MC -]).
2. Different verb forms (the general strategy here will be lexical rules which produce the forms of the embedded verbs and give them a distinctive HEAD.FORM value that the embedding verbs and/or complementizers can select for)

Consult with me to work out an analysis for whatever your language is doing in this case.

The feature MC

If your matrix and embedded clauses have different syntactic properties (e.g., presence v.\ absence of complementizers), you'll need to constrain things so that the embedded clause syntax only appears in embedded clauses and vice versa for matrix clause syntax. There are three resources for doing so:

• The root condition
• The selecting context for the embedded clauses (i.e., the embedded verb)
• The feature MC (inside CAT)

If the difference is strictly S v. CP, you don't need the feature MC. Otherwise, you probably will need all three: The root condition will require [MC +], the embedding verb will require [MC -], and the constructions/lexical rules/etc which create the embedded and matrix clauses themselves should set appropriate values for MC.

Be sure your test suite contains negative examples illustrating matrix clause syntax in embedded clauses and vice versa.

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.
• 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).
• Make sure your grammar still generates.

Grammar clean up

This section asks you to find something about your grammar which needs fixing, and fix it (with help from me). This could be something that isn't quite working right from previous labs, or something that is important in your language but doesn't look like it will be otherwise covered in the clas. By Wednesday, please propose something to fix, and post to GoPost so we can start the conversation.

For each of the following phenomena, please include the following your write up:

1. A descriptive statement of the facts of your language.
2. Illustrative IGT examples from your testsuite.
3. A statement of how you implemented the phenomenon (in terms of types you added/modified and particular tdl constraints).
4. If the analysis is not (fully) working, a description of the problems you are encountering.

• Adjectival and adverbial modifiers.
• Agreement between adjectives and head nouns. (If your language doesn't have this, then just say so.)
• Demonstratives and markers of definiteness.
• Argument optionality

In addition, your write up should include a statement of the current coverage of your grammar over your test suite (using numbers you can get from Analyze | Coverage and Analyze | Overgeneration in [incr tsdb()]) and a comparison between your baseline test suite run and your final one for this lab (see Compare | Competence).

Submit your assignment

• Create a tarball of your grammar, your tsdb directory, and your write up. The best way to do this (so that it unpacks most easily when I download from CollectIt) is to cd into the directory containing your lab and do:

  tar czf lab3.tgz *

  (When I download your submission from CollectIt, it comes in a directory named with your UWNetID. The above method avoids extra directory structure inside that directory.)

• Upload the tarball to CollectIt