Lab 5 Writeup
Ling 567
Michael Tepper

1. Uzbek matrix declaritives are the syntactic structures that we 
have been building up to this point.  What distinguishes them from 
other clauses is a tensed, finite verb.  Sometimes, matrix declaritive 
clauses may consist of a single verb, if the verb's arguments can 
be recovered from the context (as should have been reported in the
lab 4 writeup).  Uzbek embedded declaritives often-times have exactly
the same syntactic structure as matrix declaritives.  They are marked
by the complementizer suffix (or clitic) -ki on the matrix verb (which 
immediately preceeds (i.e. appears to the left) of the complement ).
Interestingly, this -ki was borrowed into the Turkic languages from 
the Persian 'ke'.  From my grammar resources, it seems that Uzbek is
more comfortable with this construction than Turkish is.  In one of
my grammars, it was the only method for making a declarative embedded clause
that was presented by the author. 

However, Uzbek does do embedded clauses the Turkish way as well (especially
for verbs like "know," and "rembember," less so for verbs like "say.")
Clauses like this are formed from a verbal noun (homophonous w/the past 
participle), affixed by a personal suffix as well as case (whatever 
case the matrix verb takes on its object).  So the order of these sentences
goes [(SUBJ) SUBJembed Vembed+NOM+PERS+CASE Vmatrix+TNS+CASE ]. 

2. My current grammar covers the first ("Persian") way of making 
embedded clauses fairly thoroughly.  However, it does not yet cover 
the second way.  I think that embedded clauses formed from verbal nouns
must be at least somewhat more restricted in Uzbek (as opposed to Turkish).
My resources are really bad when it comes to describing this
particular construction. However, I did figure out how to make the 
verbal noun construction that goes with the matrix verb "to know," so I will
try to get that implemented for next time.

3. The syntactic properties of matrix declaritives were already in place
before this assignment.  However, I did have to change 'roots.tdl', to make
sure that only root-conditions that convey a message (w/ the PRED of that
message constrained to be propositions and questions for know) are 
licensed by the grammar. I guess that's semantic.  Anyhow, for the embedded
declaritives, I added an inflectional rule (it's really more like a 
word to word rule) to add the -ki complementizer suffix to verbs of the
embedded declaritive taking type.  Also, I had to introduce a feature to 
the verb head called ORDER, which marks the special word-order 
requirements of verbs that are marked with -ki.  They no longer appear 
sentence-finally, but instead are promoted to a position just before
the clause they embed. Finally, For the new declarative clause-taking verb 
type,I had to had to make sure that it inherited from the right matrix.tdl
types (the standard ones, suggested by the lab), and I had to connect
up the ARG-ST list to the COMPS feature, as well as declare that my
clause-taking verb actually takes a sentence that conveys a particular
message (in this case, the declarative message relation).

4. I did do a fair bit of code-wrangling to get the semantic properties
of my grammar in order.  As far as the lab itself was concerned, my 
task should have been very easy.  I did not have to deal with complementizer 
word-token that would have to be connected up to the verb semantics
of its argument.  I did, however, screw up when I implemented the 
argument optionality lab last week.  I forgot to constrain the RELS and
HCONS lists of the optional subject rule.  For some reason, this made
sure that the clausal semantics seemed like it applied, but then got lost.
What I mean is, the rules for clausal formation would apply, but
the clausal semantics would not show up on the MRS matrix whenever the
optional subject rule applied.  When I constrained HCONS and RELS
to be empty on the optional subject rule, my clausal semantics
came back.

5. I seem to be producing correct semantic representations for both
matrix and embedded declarative clauses.  I checked them against
the examples in the lab documentation, and I generated from them as well.