;;; -*- Mode: TDL; Package: LKB -*-
;;;
;;; Language-specific types and constraints for Haida

;;; Type addenda adding constraints to head types

;;; Types for values of additional features.

;;; Phrase structure rule types

;;;  Types for SOV word order.

comp-head-phrase := basic-head-1st-comp-phrase & head-final.
subj-head-phrase := basic-head-subj-phrase & head-final &
   [ HEAD-DTR.SYNSEM.LOCAL.CAT.VAL.COMPS < > ].

decl-subj-head-phrase := subj-head-phrase & declarative-clause &
  [ SYNSEM.LOCAL.CAT.MC +,
    HEAD-DTR.SYNSEM.LOCAL.CAT [ MC -,
                                HEAD verb &
                                     [ QUES -,
                                       IMP - ] ] ].

int-subj-head-phrase := subj-head-phrase & interrogative-clause &
  [ SYNSEM.LOCAL.CAT.MC +,
    HEAD-DTR.SYNSEM.LOCAL.CAT [ MC -,
                                HEAD verb &
                                     [ QUES +,
                                       IMP - ] ] ].

;;; ERB 2006-05-30

noun :+ [NTYPE ntype].
ntype := avm.
pronoun := ntype.
common := ntype.
proper := ntype.

;;; Rules for building NPs.  Note that the Matrix uses SPR for
;;; the specifier of nouns and SUBJ for the subject (specifier) of verbs.

;;; Bare NP phrase.  Consider modifying the PRED value of the quantifier relation
;;; introduced to match the semantic effect of bare NPs in your language.
;;;
;;; kpt: replace bare-np-phrase with three new subtypes, in lab 5
;;;bare-np-phrase := basic-bare-np-phrase &
;;;   [ C-CONT.RELS <! [ PRED "unspec_q_rel" ] !> ].

pronoun-bare-np-phrase := basic-bare-np-phrase &
   [ HEAD-DTR.SYNSEM.LOCAL [ CAT.HEAD.NTYPE pronoun,
                             CONT.HOOK.INDEX.COG-ST activ-or-more ],
     C-CONT.RELS < ! [ PRED exist_q_rel ] ! > ].

pn-bare-np-phrase := basic-bare-np-phrase &
   [ HEAD-DTR.SYNSEM.LOCAL [ CAT.HEAD.NTYPE proper,
                             CONT.HOOK.INDEX.COG-ST uniq-id ],
     C-CONT.RELS < ! [ PRED exist_q_rel ] ! > ].

cn-bare-np-phrase := basic-bare-np-phrase &
   [ HEAD-DTR.SYNSEM.LOCAL [ CAT.HEAD.NTYPE common,
                             CONT.HOOK.INDEX.COG-ST cog-st ],
     C-CONT.RELS < ! [ PRED exist_q_rel ] ! > ].

;;; Lexical types

;;; Nouns

noun-lex := basic-noun-lex & basic-one-arg &
           [ SYNSEM.LOCAL [ CAT.VAL [ SPR < #spr & [ LOCAL.CAT.HEAD det ] >,
			                    COMPS < >,
			                    SUBJ < >,
			                    SPEC < > ]],
			 ARG-ST < #spr > ].

pronoun-lex := noun-lex &
	[ SYNSEM [ LOCAL.CAT.HEAD.NTYPE pronoun,
		   LKEYS.KEYREL.PRED 'pronoun_n_rel ] ].

proper-noun-lex := noun-lex &
	[ SYNSEM.LOCAL [ CAT.HEAD.NTYPE proper,
	  CONT.HOOK.INDEX.PNG [PER third ] ] ].

common-noun-lex := noun-lex &
	[ SYNSEM.LOCAL [ CAT.HEAD.NTYPE common,
	  CONT.HOOK.INDEX.PNG [PER third ] ] ].

;;; Adjectives - adding these in lab 8
adjective-lex := basic-adjective-lex & intersective-mod-lex &
	[ SYNSEM [ LOCAL [ CAT [ HEAD adj &
								  [ MOD < [ LOCAL [ CAT.HEAD noun,
													CONT.HOOK [ INDEX #ind,
																LTOP #ltop ] ] ] > ],
							 VAL [ SPR < >,
								   SUBJ < >,
								   COMPS < >,
								   SPEC < > ],
							 POSTHEAD + ],
					   CONT.HOOK.LTOP #ltop ],
			   LKEYS.KEYREL.ARG1 #ind ] ].
	
						     

;;; Verbs

ordinary-verb-lex := basic-verb-lex &
  [ SYNSEM.LOCAL [ CAT [ MC -,
                         VAL [ SPR < >,
 			                   SPEC < >,
			                   SUBJ < #subj >] ],
                   CONT.HOOK.XARG #xarg ],
    ARG-ST < #subj &
             [ LOCAL [ CAT [ HEAD noun,
                             VAL [ SPR < >,
                                   COMPS < > ]],
                       CONT.HOOK.INDEX #xarg ]], ... > ].

;;;kpt - attempt to create a verb subtype that takes COMPS first - couldn't get this working
clausal-verb-lex := basic-verb-lex &
  [ SYNSEM.LOCAL [ CAT [ VAL [ SPR < >,
 			             SPEC < >,
			             SUBJ < #subj > ]],
                   CONT.HOOK.XARG #xarg ],
    ARG-ST < [ LOCAL [ CAT [ HEAD noun,
                             VAL [ SPR < >,
                                   COMPS < > ]],
                       CONT.HOOK.INDEX #xarg ]], 
                       #subj,
                       ... > ].

intransitive-verb-lex := ordinary-verb-lex & intransitive-lex-item &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < > ].


agent-intransitive-verb-lex := intransitive-verb-lex &
   [ SYNSEM.LOCAL [ CAT [ HEAD verb,
			              VAL [ SPR < >,
				          SUBJ < #subj & synsem
				                  & [ LOCAL.CAT [ HEAD noun &
							                      [ CASE agent ],
						                            VAL.SPR < > ]] >,
				          COMPS < >,
				          SPEC < > ]]],
                          ARG-ST < #subj > ].


obj-intransitive-verb-lex := intransitive-verb-lex &
   [ SYNSEM.LOCAL [ CAT [ HEAD verb,
			  VAL [ SPR < >,
				SUBJ < #subj & synsem
				       & [ LOCAL.CAT [ HEAD noun &
							    [ CASE obj ],
						       VAL.SPR < > ]] >,
				COMPS < >,
				SPEC < > ]]],
     ARG-ST < #subj > ].



transitive-verb-lex := ordinary-verb-lex & transitive-lex-item &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < #comps >,
     ARG-ST < [ ],
              #comps &
              [ LOCAL.CAT [ VAL [ SPR < >,
                                  COMPS < > ],
                            HEAD noun ] ] > ].
                            
opt-trans-verb-lex := transitive-verb-lex &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < #comps >,
     ARG-ST < [ ],
              #comps &
              [ OPT + ] > ] .
              
required-trans-verb-lex := transitive-verb-lex &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < #comps >,
     ARG-ST < [ ],
              #comps &
              [ OPT - ] > ] .
                            
                            
;;;adding a ditransitive verb type for lab 8
ditransitive-verb-lex := ordinary-verb-lex & ditransitive-lex-item &
	[ SYNSEM.LOCAL.CAT.VAL.COMPS < #comps1, #comps2 >,
	  ART-ST < [ ],
			   #comps1 &               
			   [ LOCAL.CAT [ VAL [ SPR < >,
                                   COMPS < > ],
                             HEAD noun ],
                 OPT - ],
			   #comps2 & 
			   [ LOCAL.CAT [ VAL [ SPR < >,
                                   COMPS < > ],
                             HEAD noun ],
                 OPT - ] > ] .	

                            
;;; kpt: adding for lab 6                            
clause-embedding-verb-lex := ordinary-verb-lex &
	clausal-second-arg-trans-lex-item &
	[ SYNSEM.LOCAL.CAT.VAL.COMPS < #comps >,
          ARG-ST < [ ],
                   #comps &
                   [ LOCAL [ CAT [ VAL [ SPR < >,
                                         COMPS < > ],
                                   HEAD.EMB + ]],
                     OPT - ] > ].
                         
                         
;;;kpt: attempt to create a clausal embedding verb lex that reverses the order of arguments of a regular verb
clause-first-embedding-verb-lex := clausal-verb-lex &
	clausal-first-arg-trans-lex-item &
	[ SYNSEM.LOCAL.CAT.VAL [ COMPS < #comps > ],
          ARG-ST < #comps &
                   [ LOCAL [ CAT [ VAL [ SPR < >,
                                         COMPS < > ] ], 
                             CONT.HOOK.INDEX.SF prop ] ],
                   [ ] > ].

aux-verb-lex := ordinary-verb-lex & trans-first-arg-raising-lex-item &
	[ SYNSEM [ LOCAL.CAT.VAL [ SUBJ < #subj >,
							 COMPS < #comps > ],
			   LKEYS.KEYREL.ARG1 #ltop ],
	  ARG-ST < #subj & [ LOCAL.CAT.HEAD noun ],
			   #comps & [ LOCAL [ CAT.HEAD verb,
								  CONT.HOOK.LTOP #ltop ],
						  OPT - ] > ].



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


;;; Negative adverb

neg-adv-lex := basic-scopal-adverb-lex &
   [ SYNSEM.LOCAL.CAT [ POSTHEAD -,
                        VAL [ SPR < >,
                              COMPS < >,
                              SUBJ < > ] ] ].


;;; Clauses (kpt adding for lab 6)
;decl-clause := declarative-clause & head-only &
;  [ SYNSEM.LOCAL.CAT.VAL [ SUBJ null,
;                           COMPS null ],
;    HEAD-DTR.SYNSEM.LOCAL.CAT [HEAD verb,
;                               HEAD.QUES -,
;                               HEAD.IMP -,
;                               VAL [ COMPS null,
;                                     SPR null ],
;                               MC - ] ].

;;; add interrogative clause for lab 7
;int-clause := interrogative-clause & head-only &
;  [ SYNSEM.LOCAL [ CAT.VAL [ SUBJ null,
;                             COMPS null ]],
;    HEAD-DTR.SYNSEM.LOCAL [ CAT.HEAD [ QUES +,
;                                       IMP - ] ] ].
									 
;;; add imperative clause for lab 7
imp-clause := basic-head-opt-subj-phrase &
  [ HEAD-DTR.SYNSEM.LOCAL.CAT [ HEAD verb &
                                     [ IMP + ],
                                VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.PER second ] > ] ] .

;;;	SYNSEM.LOCAL.CAT [ HEAD.IMP + ],
	  							 
								 
;imp-clause := imperative-clause & head-only &
;  [ SYNSEM.LOCAL.CAT.MC +,
;    HEAD-DTR imp-construction ].
;							  
;;;	  ARG-ST < #subj & 
;;;				[ LOCAL.CONT.HOOK.INDEX.PNG [PER second ] ,;
;;;				  [ ] > ] ] ].


;;;kpt: creating an instance of basic-head-opt-comp-phrase for lab 8
comp-opt-construction := basic-head-opt-comp-phrase &
 [ SYNSEM.LOCAL.CAT.HEAD.IMP - ].

;;;kpt: creating an instance of head-adj-phrase for lab 8
head-adj-phrase-construction := head-adj-int-phrase &
	[ HEAD-DTR.SYNSEM.LOCAL.CAT.HEAD noun,
	  NON-HEAD-DTR.SYNSEM.LOCAL.CAT.HEAD adj ].

;;;sticking this in the adjective rule causes tons of extra parses everywhere.
;;;actually, I get tons of extra parses due to the rule without it as well.
;;; &	[ SYNSEM.LOCAL.CAT.HEAD adj ].


;declarative-clause := non-rel-clause & 
;  [ SYNSEM.LOCAL.CONT.MSG [ PRED question_m_rel,
;			    MARG #marg ],
;    C-CONT [ RELS <! *top* !>,
;	         HCONS <! qeq &
;		     [ HARG #marg,
;		       LARG #ltop ] !> ],
;    HEAD-DTR.SYNSEM.LOCAL.CONT [ MSG no-msg,
;				 HOOK.LTOP #ltop ]].



;;;							   VAL [ SPR < >,
;;;									 COMPS < > ] 
;;;[ SYNSEM.LOCAL.CAT.HEAD verb ]

;;; Coordination

n1-top-coord-rule := basic-n-top-coord-rule & apoly-top-coord-rule &
  [ SYNSEM.LOCAL.COORD-STRAT "1" ].
n1-bottom-coord-rule := conj-last-bottom-coord-rule & n-bottom-coord-phrase &
  [ SYNSEM.LOCAL.COORD-STRAT "1" ].

np1-top-coord-rule := basic-np-top-coord-rule & apoly-top-coord-rule &
  [ SYNSEM.LOCAL.COORD-STRAT "1" ].
np1-bottom-coord-rule := conj-last-bottom-coord-rule & np-bottom-coord-phrase &
  [ SYNSEM.LOCAL.COORD-STRAT "1" ].

s1-top-coord-rule := basic-s-top-coord-rule & apoly-top-coord-rule &
  [ SYNSEM.LOCAL.COORD-STRAT "1" ].
s1-bottom-coord-rule := conj-last-bottom-coord-rule & s-bottom-coord-phrase &
  [ SYNSEM.LOCAL.COORD-STRAT "1" ].


;;;kpt: person, number, gender, added for lab 5 (no gender in Haida)
png :+ [PER person,
	NUM number].

person := *top*.
first := person.
second := person.
third := person.

number := *top*.
sg := number.
pl := number.

;;;kpt: adding quantifier relation types (lab 5)
quantifier_rel := predsort.
pronoun_q_rel := quantifier_rel.
proper_q_rel := quantifier_rel.
reg_q_rel := quantifier_rel.
exist_q_rel := reg_q_rel.

;;;kpt: adding CASE to type noun for lab 5
noun :+ [CASE case].

;;;kpt: defining type CASE for lab 5
case := *top*.
agent := case.
obj := case.

;;;kpt: adding QUES to type verb for lab 7
;;;adding IMP for imperatives
;;;sfd: adding EMB for embedded forms
verb :+ [QUES bool,
		 IMP bool,
		 EMB bool].

;;;kpt: defining present and past tense lexical rules - lab5
past_verb-lex-rule := infl-ltow-rule &
  [ DTR.SYNSEM.LOCAL.CAT [ HEAD verb & 
                                [ QUES - ] ] ].

present_verb-lex-rule := infl-ltow-rule &
  [ DTR.SYNSEM.LOCAL.CAT [ HEAD verb &
                                [ QUES -,
                                  EMB - ] ] ].
	
present_embedded_decl-lex-rule := infl-ltow-rule &
  [ DTR.SYNSEM.LOCAL.CAT [ HEAD verb &
                                [ QUES -,
                                  EMB + ] ] ].
	
;;;kpt: adding future tense lexical rule, for fun
future_verb-lex-rule := infl-ltow-rule &
  [ DTR.SYNSEM.LOCAL.CAT [ HEAD verb &
                                [ QUES -,
                                  EMB - ] ] ].


;;;kpt: adding a lexical rule to put the verb marker on a question verb	
question_verb-lex-rule := infl-ltow-rule &
	[DTR.SYNSEM.LOCAL.CAT [ HEAD verb,
							HEAD.QUES + ] ].
							
;;;kpt: adding imperative lexical rule
imperative_verb-lex-rule := infl-ltow-rule &
	[ SYNSEM.LOCAL.CAT.HEAD.IMP +,
	  DTR.SYNSEM.LOCAL.CAT [ HEAD verb,
							 HEAD.IMP + ] ].
							 
;;;kpt: try to implement a negative adverb lexical rule
neg-adv-lex-rule := infl-ltow-rule &
	[ SYNSEM.LOCAL.CAT.HEAD verb ].