;;; -*- Mode: TDL; Coding: utf-8 -*- 

;;; HAG (Hausa Grammar)
;;; Author: Berthold Crysmann 
;;; 2009

;;; Rule types for lexical rules and syntax rules


ccont-1ep-rule :=  phrase-or-lexrule &
		   [STEM [FROM #from,
			  TO #to],
		    C-CONT.RELS.LIST < [CFROM #from,
					CTO #to], ... >].

ccont-2ep-rule :=  ccont-1ep-rule & 
		   [STEM [FROM #from,
			  TO #to],
		    C-CONT.RELS.LIST < [],
				       [CFROM #from,
					CTO #to], ... >].

ccont-3ep-rule :=  ccont-2ep-rule & 
		   [STEM [FROM #from,
			  TO #to],
		    C-CONT.RELS.LIST < [], 
				       [],
				       [CFROM #from,
					CTO #to], ... >].



robust-spelling-irule :=
			add-only-no-ccont-rule &
			lexeme-to-lexeme-rule &
			inflecting-lex-rule &
			no-prefix-lex-rule &
			same-supra-lex-rule &
			nocoord &
			[MORPH #m,
			 ROBUST +,
			 DTR lex-item & [MORPH #m] ].

;; was SUPRA supra_noreent
lexeme-to-word-rule := 
		       same-local-lex-rule &
		       same-modified-lex-rule &
		       same-light-lex-rule &
		       same-non-local-lex-rule &
		       [SUPRA supra,
			INFLECTED +,
			DTR [ SUPRA supra,
			      INFLECTED na-or-- ],
			C-CONT [RELS <! !>,
				HCONS <! !>]].



inher-lkeys-lex-rule := 
			lex-rule &
			[SYNSEM.LKEYS #lk,
			 DTR.SYNSEM.LKEYS #lk].



;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Valence alternations ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;




opt-lex-rule :=
	       const-ltol-rule &
	       inher-lkeys-lex-rule &
	       val-change-only-lex-rule & 
	       same-supra-lex-rule &
	       [INFLECTED na,
		MORPH.DERIVED #deriv,
		SYNSEM [LOCAL.CAT.VAL [SPR #spr,
				       SPEC #spec]],
		DTR [MORPH.DERIVED bool & #deriv,
		     SYNSEM.LOCAL.CAT.VAL [SPR #spr,
					   SPEC #spec]]].


opt-comps-lex-rule :=
		     opt-lex-rule &
		     [SYNSEM.LOCAL.CAT.VAL [SUBJ #subj],
		      DTR.SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
						COMPS < unexpressed & 
							[LOCAL.CONT.HOOK.INDEX index & [--BND -]], ...>]].


;;; Null DO Complement realisation 

opt-do-lex-rule :=
		  opt-comps-lex-rule &
		  [SYNSEM.LOCAL.CAT.VAL [COMPS #comps],
		   DTR.SYNSEM.LOCAL.CAT.VAL [COMPS <[OPT +] . #comps>]].


opt-comp2-lex-rule :=
		  opt-lex-rule &
		  [SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
					 COMPS <#1 . #comps>],
		   DTR.SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
					     COMPS <#1 & [OPT -], 
						    unexpressed &
						    [OPT +,
						     LOCAL [CONT.HOOK.INDEX unbound-ind
									    ]] . #comps>]].



extraction-lex-rule :=
		      inher-lkeys-lex-rule &
		      const-ltol-rule &
		      val-change-only-lex-rule & 
		      same-supra-lex-rule.




comp-extraction-lex-rule :=
			   extraction-lex-rule &
			   [MORPH.DERIVED bool & #deriv,
			    SYNSEM [LOCAL [CONT.HOOK.INDEX.--XTR +,
					   CAT [VAL [SUBJ #subj]]],
				    NON-LOCAL.SLASH <! [CONT.HOOK.INDEX [--GAP +] ] !> ],
			    DTR [MORPH.DERIVED #deriv,
				 SYNSEM.LOCAL.CAT.VAL [SUBJ #subj]]].

		      
;;; DO Complement extraction (pre-inflection)

comp-extra-lex-rule := 
		       comp-extraction-lex-rule &
		       [INFLECTED #infl,
			SYNSEM canonical-synsem & 
				  [LOCAL.CAT [HEAD +nv & [VFORM non-fin],
					      VAL.COMPS #comps ]],
			DTR [INFLECTED #infl & na,
			     SYNSEM [LOCAL.CAT.VAL.COMPS < gap & [BOUND -,
								  NON-LOCAL.SLASH #sl] . #comps>,
				     NON-LOCAL.SLASH #sl]]].


comp2-extra-lex-rule := 
			comp-extraction-lex-rule &
			[INFLECTED #infl,
			 SYNSEM [LOCAL.CAT.VAL.COMPS <#1 . #comps>,
				 NON-LOCAL.SLASH #sl ],
			 DTR [INFLECTED na & #infl,
			      SYNSEM.LOCAL.CAT.VAL.COMPS <#1 & 
							  canonical-synsem & 
							  [OPT -,
							   NON-LOCAL [SLASH 0-dlist,
								      REL 0-dlist,
								      QUE 0-dlist]
							       ],
							  gap & 
							  [BOUND -,
							   NON-LOCAL.SLASH #sl]
							  . #comps > ]].


;;; TODO:

;;; Dative shift (pre-inflection)
;;; Type raising (pre-inflection) DONE
;;; IO complement extraction (post-inflection) DONE


;;; Infl rule types


;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Frame marking irules ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

verbal-irule := 
		no-prefix-lex-rule &
		lexeme-to-word-rule &
		[INFLECTED +,
		 SYNSEM [LOCAL [CAT.HEAD verb & [VFORM non-fin]]],
		 DTR [SYNSEM.LKEYS.--MCLASS vclass,
		      INFLECTED na]].

verb-irule := 
	      verbal-irule &
	      [SYNSEM [LOCAL [CAT.HEAD verb]]].

vn-irule := 
	    lexeme-to-word-rule & 	       
	    no-prefix-lex-rule &
	    [INFLECTED +,
	     SYNSEM.LOCAL [CAT.HEAD verb & [VFORM non-fin]],
	     DTR [INFLECTED na,
		  SYNSEM.LKEYS.--MCLASS v-vn-wa-gr]].

strong-vn-irule :=
		  head-change-only-lex-rule & 
		  nocoord &
		  inflecting-lex-rule &
		  [INFLECTED na,
		   SYNSEM [BOUND -,
			   LOCAL.CAT.HEAD noun & [MOD #mod]],
		   DTR [INFLECTED -,
			SYNSEM [LOCAL.CAT.HEAD verb & [MOD #mod,
						       VFORM non-fin]]]].

noun-irule := 
	      lexeme-to-word-rule &
	      no-prefix-lex-rule &
	      [SYNSEM.LOCAL.CAT.HEAD noun ].


frame-irule :=
	      lexeme-to-word-rule.


a-irule := 
	   frame-irule &
	   [SYNSEM.LOCAL.CAT.VAL.COMPS frame-non-b-c-val-list].

	   
verb-a-irule :=
	       a-irule &
	       const-ltow-rule &
	       same-len-lex-rule &
	       verb-irule & 
	       [DTR [INFLECTED na-or--]].


vn-a-d-irule := 
		a-irule &
		vn-irule &
		[SYNSEM.LOCAL [CONT.HOOK.INDEX.E continuative],
		 DTR.SYNSEM.LKEYS.--MCLASS v-vn-reg-gr].

vn-a-irule := 
	      infl-ltow-rule &
	      vn-a-d-irule &
	      [SYNSEM.LOCAL.CAT.VAL.COMPS frame-a-val-list].

vn-d-irule := 
	      const-ltow-rule &
	      same-supra-lex-rule &
	      vn-a-d-irule &
	      [SYNSEM.LOCAL.CAT.VAL.COMPS frame-non-B-C-val-cons & 
					  <[LOCAL.CAT.HEAD.KEYS.KEY "_wà_v_applic_rel" ], ...> ].

noun-a-irule :=
	       a-irule &
	       same-supra-lex-rule &
	       const-ltow-rule &
	       noun-irule &
	       [INFLECTED +,
		DTR.INFLECTED na].

noun-b-c-irule :=
		 b-c-irule &
		 infl-ltow-rule &
		 noun-irule  &
		 [DTR [INFLECTED na]].


b-c-irule :=
	    frame-irule &
	    [MORPH.COMPLETE bool,
	     SYNSEM.LOCAL.CAT.VAL.COMPS frame-B-C-val-cons].


b-irule :=
	  b-c-irule &
	  [SYNSEM.LOCAL.CAT.VAL.COMPS frame-B-val-cons].
	       
c-irule :=
	  b-c-irule &
	  [SYNSEM.LOCAL.CAT.VAL.COMPS frame-C-val-cons].


verb-c-irule :=
	       verbal-irule &
	       c-irule. 

verb-c-const-irule :=
		     const-ltow-rule & 
		     verb-C-irule.



verb-c-infl-irule :=
		     infl-ltow-rule & 
		     verb-c-irule.

verb-c-short-irule :=
		       verb-c-infl-irule &
		       shorten-lex-rule. 

verb-c-idlen-irule := 
		      verb-c-const-irule &
		      same-len-lex-rule.

verb-b-irule :=
	       verbal-irule &
	       lengthen-lex-rule &
	       b-irule & 
	       infl-ltow-rule &
	       [DTR [INFLECTED na-or--]]. 


;;; DO pronoun inflection
do-pron-irule :=
		no-prefix-lex-rule &
		inflecting-lex-rule &
		same-head-lex-rule &
		same-hc-light-lex-rule &
		same-posthead-lex-rule &
		same-mc-lex-rule &
		same-cont-lex-rule &
		same-ctxt-lex-rule &
		same-agr-lex-rule &
		same-non-local-lex-rule &
		ccont-2ep-rule &
		nocoord &
		[MORPH.COMPLETE bool,
		 INFLECTED +, 
		 C-CONT [RELS <! 
			       [PRED "pron_rel",
				LBL #l,
				ARG0 #0 & [COG-ST in-foc]], 
			       [PRED "pronoun_q_rel",
				ARG0 #0, 
				  RSTR #h] !>,
			 HCONS <! qeq & [HARG #h, 
					 LARG #l] !>],
		 SYNSEM [LOCAL [CAT [HEAD verb,
				     VAL [SUBJ #subj,
					  SPR #spr,
					  SPEC #spec,
					  COMPS #comps]]]],
		 SUPRA [TONE #tone ,
			LEN [LIST < short . #llist>,
			     LAST #llast]],
		 DTR verb-B-irule &
				[SUPRA [TONE #tone ,
					LEN [LIST #llist,
					     LAST #llast]],
				 SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
						       SPR #spr,
						       SPEC #spec,
						       COMPS frame-B-val-cons & 
							    <[OPT -,
							      LOCAL [CAT [HEAD noun,
									  VAL [SUBJ <>,
									       SPR <>,
									       COMPS <>,
									       SPEC <>]],
								     CONT.HOOK [INDEX #0]
									 ],
							      NON-LOCAL [SLASH <! !>]] . #comps>]]]. 


;;; IO pronoun inflection
io-pron-irule :=
		no-prefix-lex-rule &
		inflecting-lex-rule &
		same-head-lex-rule &
		same-hc-light-lex-rule &
		same-posthead-lex-rule &
		same-mc-lex-rule &
		same-cont-lex-rule &
		same-ctxt-lex-rule &
		same-agr-lex-rule &
		same-non-local-lex-rule &
		ccont-2ep-rule &
		nocoord &
		[MORPH.COMPLETE bool,
		 INFLECTED +, 
		 C-CONT [RELS <! 
			       [PRED "pron_rel",
				LBL #l,
				  ARG0 #0 & [COG-ST in-foc]], 
			       [PRED "pronoun_q_rel",
				ARG0 #0, 
				RSTR #h] !>,
			 HCONS <! qeq & [HARG #h, 
					 LARG #l] !>],
		 SYNSEM [LOCAL [CAT [HEAD verb & [KEYS.KEY "_wà_v_applic_rel"],
				       VAL [SUBJ #subj,
					    SPR #spr,
					    SPEC #spec,
					    COMPS <>]]]],
		 SUPRA [TONE <! low, high !>,
			LEN <! short, short !>],
		 DTR [SUPRA [TONE <! low !>,
			     LEN <! short !>],
		      INFLECTED na-or--,
		      SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
					    SPR #spr,
					    SPEC #spec,
					    COMPS frame-B-val-cons & 
						 <[OPT -,
						   LOCAL [CAT [HEAD noun,
							       VAL [SUBJ <>,
								    SPR <>,
								      COMPS <>,
								    SPEC <>]],
							  CONT.HOOK [INDEX #0]
							      ],
						   NON-LOCAL [SLASH <! !>]]>]]]. 


io-resump-irule :=
		  no-prefix-lex-rule &
		  inflecting-lex-rule &
		  same-head-lex-rule &
		  same-hc-light-lex-rule &
		  same-posthead-lex-rule &
		  same-mc-lex-rule &
		  same-cont-lex-rule &
		  same-non-local-lex-rule &
		  same-ctxt-lex-rule &
		  same-agr-lex-rule &
		  nocoord &
		  [MORPH.COMPLETE bool,
		   INFLECTED +, 
		   C-CONT [RELS <! !>,
			   HCONS <!  !>],
		   SYNSEM [LOCAL [CAT [HEAD verb & [KEYS.KEY "_wà_v_applic_rel"],
				       VAL [SUBJ #subj,
					   SPR #spr,
					   SPEC #spec,
					   COMPS <>]]]],
		   SUPRA [TONE <! low, high !>,
			  LEN <! short, short !>],
		   DTR [SUPRA [TONE <! low !>,
			       LEN <! short !>],
			INFLECTED na-or--,
			SYNSEM [LOCAL.CAT.VAL [SUBJ #subj,
					      SPR #spr,
					      SPEC #spec,
					      COMPS frame-B-C-val-cons & 
						   < gap & 
						     [OPT -,
						      LOCAL #sl & [CAT [HEAD noun,
								  VAL [SUBJ <>,
								       SPR <>,
								       COMPS <>,
								       SPEC <>]]
								 ],
						      NON-LOCAL.SLASH  <! #sl !> ]> ],
				NON-LOCAL.SLASH <! #sl !> ]]]. 

;;; Prossessive pronoun inflection

poss-pron-irule :=
		  no-prefix-lex-rule &
		  inflecting-lex-rule &
		  same-head-lex-rule &
		  same-hc-light-lex-rule &
		  same-posthead-lex-rule &
		  same-mc-lex-rule &
		  same-cont-lex-rule &
		  same-ctxt-lex-rule &
		  same-agr-lex-rule &
		  same-non-local-lex-rule &
		  ccont-2ep-rule &
		  nocoord &
		  [MORPH.COMPLETE bool,
		   INFLECTED +, 
		   C-CONT [RELS <! 
				 [PRED "pron_rel",
				  LBL #l,
				  ARG0 #0 & [COG-ST in-foc]], 
				 [PRED "pronoun_q_rel",
				  ARG0 #0, 
				  RSTR #h] !>,
			   HCONS <! qeq & [HARG #h, 
					   LARG #l] !>],
		   SYNSEM [LOCAL [CAT.VAL [SUBJ #subj,
					   SPR #spr,
					   SPEC #spec,
					   COMPS <>]]],
		   DTR [INFLECTED na-or-+,
			SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
					      SPR #spr,
					      SPEC #spec,
					      COMPS frame-B-val-cons &
						   <[OPT -,
						     LOCAL [CAT [HEAD noun,
							    VAL [SUBJ <>,
								 SPR <>,
								 COMPS <>,
								 SPEC <>]],
						     CONT.HOOK [INDEX #0]
							 ],
						    NON-LOCAL [SLASH <! !>]]>]]]. 


;;; Resumptives

poss-resump-irule :=
		    no-prefix-lex-rule &
		    inflecting-lex-rule &
		    same-head-lex-rule &
		    same-hc-light-lex-rule &
		    same-posthead-lex-rule &
		    same-mc-lex-rule &
		    same-cont-lex-rule &
		    same-ctxt-lex-rule &
		    same-agr-lex-rule &
		    nocoord &
		    [MORPH.COMPLETE bool,
		     INFLECTED +, 
		     C-CONT [RELS <! !>,
			     HCONS <!  !>],
		     SYNSEM [LOCAL [CAT.VAL [SUBJ #subj,
					     SPR #spr,
					     SPEC #spec,
					     COMPS <>]],
			     NON-LOCAL [SLASH #sl,
				      REL #rel,
					QUE #que]],
		   DTR [INFLECTED na-or-+,
			SYNSEM [LOCAL.CAT.VAL [SUBJ #subj,
					       SPR #spr,
					       SPEC #spec,
					       COMPS frame-B-C-val-cons &
						    <gap & [OPT -,
							    LOCAL #loc & [CAT [HEAD noun,
									       VAL [SUBJ <>,
										    SPR <>,
										    COMPS <>,
										    SPEC <>]]
									      ],
							    NON-LOCAL [SLASH #sl & <! #loc !> ]]>],
				NON-LOCAL [REL #rel,
					   QUE #que]]]]. 



;;; Type raising rules

noun-poss-tr-lex-rule := 
			 no-prefix-lex-rule &
			 const-ltol-rule &
			 same-head-lex-rule &
			 same-hc-light-lex-rule &
			 same-posthead-lex-rule &
			 same-mc-lex-rule &
			 same-cont-lex-rule &
			 same-ctxt-lex-rule &
			 same-agr-lex-rule &
			 same-non-local-lex-rule &
			 same-supra-lex-rule &
			 ccont-1ep-rule &
			 [MORPH.COMPLETE bool,
			 INFLECTED #infl, 
			  C-CONT [RELS <! [PRED "poss_rel",
					   ARG0 event & [E no_tam],
					   LBL #l,
					   ARG1 #1,
					   ARG2 #2
						] !>,
				  HCONS <! !>],
			  SYNSEM [LOCAL [CAT.VAL [SUBJ #subj,
						 SPR #spr,
						 SPEC #spec,
						 COMPS frame-B-C-val-cons & 
						       <[OPT -,
							 LOCAL [CAT [HEAD noun & [MOD <>],
								     VAL [SUBJ <>,
									  SPR <>,
									  COMPS <>,
									  SPEC <>]],
								CONT.HOOK [INDEX #2]]]>],
					 CONT.HOOK [LTOP #l,
						    INDEX #1 & ref-ind]],
				  NON-LOCAL.SLASH <! !> ],
			  DTR [INFLECTED #infl & -,
			       SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
						     SPR #spr,
						     SPEC #spec,
						     COMPS <>]]]. 


mod-to-prd-tr-lex-rule :=
			 no-prefix-lex-rule &
			 const-ltol-rule &
			 same-hc-light-lex-rule &
			 same-posthead-lex-rule &
			 same-agr-lex-rule &
			 same-mc-lex-rule &
			 same-ctxt-lex-rule &
			 same-non-local-lex-rule &
			 same-supra-lex-rule &
			 [INFLECTED #infl, 
			  C-CONT [RELS <! !>,
				  HCONS <! !>],
			  SYNSEM [LOCAL [CONT.HOOK [LTOP #h,
						    INDEX #i,
						    XARG #x],
					 CAT [HEAD +np & 
						   [MOD <>],
					      VAL [SUBJ <#subj & [LOCAL.AGR #x]>,
						   SPR <>,
						   SPEC <>,
						   COMPS #comps ]]]],
			  DTR [INFLECTED #infl & +,
			       SYNSEM.LOCAL [CONT.HOOK [LTOP #h,
							XARG event-or-ref-index,
							INDEX #i & [E continuative]],
					     CAT [HEAD +np & [MOD < #subj >],
						  VAL [SUBJ <>,
						       SPR <>,
						       SPEC <>,
						       COMPS #comps]]]]]. 

adj-tr-lex-rule :=
		  no-prefix-lex-rule &
		  const-ltol-rule &
		  same-hc-light-lex-rule &
		  same-posthead-lex-rule &
		  same-mc-lex-rule &
		  same-ctxt-lex-rule &
		  same-agr-lex-rule &
		  same-supra-lex-rule &
		  [INFLECTED #infl, 
		   C-CONT [RELS <! !>,
			   HCONS <! !>],
		   SYNSEM [BOUND -,
			   LOCAL [AGR #i,
				  CONT.HOOK [LTOP #h,
					     INDEX #i],
				  CAT [HEAD noun & 
					    [MOD <>],
				       VAL [SUBJ #subj,
					    SPR #spr,
					    SPEC #spec,
					    COMPS frame-B-C-val-cons & 
						 < #mod & 
						   [MODIFIABLE +,
						    MODIFIED notmod,
						    OPT -,
						    BOUND -,
						    NON-LOCAL.SLASH #sl,
						    LOCAL [CONT.HOOK [LTOP #h,
								      INDEX #i],
							   CAT [HEAD noun & [MOD <>],
								VAL [SPR #spr,
								     COMPS <>,
								     SPEC <>]]]]>]]],
			   NON-LOCAL [SLASH #sl,
				      QUE #que,
				      REL #rel] ],
		   DTR [INFLECTED #infl & -,
			SYNSEM [LOCAL [CONT.HOOK [LTOP #h,
						 XARG #i],
				      CAT [HEAD noun & [MOD <#mod>],
					   VAL [SUBJ #subj,
						SPEC #spec,
						COMPS <>]]],
				NON-LOCAL [SLASH <! !>,
					   QUE #que,
					   REL #rel]]]]. 


noun-dem-tr-lex-rule := 
			no-prefix-lex-rule &
			const-ltol-rule &
			same-head-lex-rule &
			same-hc-light-lex-rule &
			same-posthead-lex-rule &
			same-mc-lex-rule &
			same-cont-lex-rule &
			same-ctxt-lex-rule &
			same-agr-lex-rule &
			same-non-local-lex-rule &
			[MORPH.COMPLETE bool,
			 SUPRA [TONE.LIST #tone, 
				LEN.LIST #len,
				TONES <! #tone !>,
				LENGTHS <! #len !>
				],
			 INFLECTED #infl, 
			 C-CONT [RELS <!  !>,
				 HCONS <!  !>],
			 SYNSEM [LOCAL [CAT [HEAD #hd,
					     VAL [SUBJ #subj,
						  SPR <>,
						  SPEC #spec,
						  COMPS frame-B-C-val-cons & 
						       < #spr & 
							 [OPT -,
							  LOCAL [CAT [HEAD bound-det & 
									   [KEYS.KEY dem_q_rel],
								      VAL [SUBJ <>,
									   SPR <>,
									   COMPS <>,
									   SPEC <[LOCAL.CAT.HEAD #hd]>]],
								 CONT [HOOK [INDEX #i & 
										   [COG-ST activated,
										    SPECI +]],
								       HCONS <! qeq & [LARG #ltop]!>]]]>]],
					CONT.HOOK [INDEX #i,
						   LTOP #ltop]],
				 NON-LOCAL.SLASH <! !> ],
			 DTR [INFLECTED #infl & na,
			      SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
						    SPR <#spr>,
						    SPEC #spec,
						    COMPS <>]]]. 


noun-dem-proximate-tr-lex-rule := 
				  noun-dem-tr-lex-rule &
				  [SYNSEM.LOCAL.CAT.VAL.COMPS <[LOCAL.CAT.HEAD.KEYS.KEY dem_q_proximate_rel]>].

noun-dem-remote-tr-lex-rule := 
			       noun-dem-tr-lex-rule &
			       [SYNSEM.LOCAL.CAT.VAL.COMPS <[LOCAL.CAT.HEAD.KEYS.KEY dem_q_remote_rel]>].


;;;;;;;;;;;;;;;;;;
;;; Morphology ;;;
;;;;;;;;;;;;;;;;;;

noun-def-irule :=
		 no-prefix-lex-rule &
		 nocoord &
		 same-head-lex-rule &
		 same-hc-light-lex-rule &
		 same-posthead-lex-rule &
		 same-mc-lex-rule &
		 same-cont-lex-rule &
		 same-ctxt-lex-rule &
		 same-agr-lex-rule &
		 same-non-local-lex-rule &
		 inflecting-lex-rule & 
		 ccont-1ep-rule &
		 [MORPH.COMPLETE bool,
		  INFLECTED +,
		  SYNSEM.LOCAL.CAT.VAL [SUBJ #subj,
					COMPS #comps & <>,
					SPR <>,
					SPEC <>], 
		  C-CONT [HOOK [INDEX #0],
			  RELS <! #quant &
				[PRED "def_q_rel",
				 ARG0 #0 & [SPECI +],
				 RSTR #harg] !>,
			  HCONS <! qeq & [HARG #harg,
					  LARG #larg] !>],
		  DTR [INFLECTED na,
		       SYNSEM.LOCAL [CAT.VAL [SUBJ #subj,
					      COMPS #comps,
					      SPR <[LOCAL.CONT.RELS <! #quant !>,
						    NON-LOCAL.SLASH <! !> ]>,
					      SPEC <>],
				     CONT.HOOK.LTOP #larg]]].

noun-singular-infl-rule := 
			   no-prefix-lex-rule &
			   same-local-lex-rule &
			   same-modified-lex-rule &
			   same-light-lex-rule &
			   same-non-local-lex-rule &
			   inflecting-lex-rule &
			   nocoord & 
			   [C-CONT [RELS <! !>,
				    HCONS <! !>],
			    INFLECTED na,
			    MORPH.MCLASS n-pl-infl,
			    SYNSEM [LOCAL [CAT.HEAD noun,
						 AGR.PNG p-s-g ]],
			    DTR [INFLECTED -]].

noun-singular-const-rule := 
			    no-prefix-lex-rule &
			    same-local-lex-rule &
			    same-modified-lex-rule &
			    same-light-lex-rule &
			    same-non-local-lex-rule &
			    constant-lex-rule &
			    nocoord & 
			    [C-CONT [RELS <! !>,
				     HCONS <! !>],
			     INFLECTED na,
			     SUPRA #sup,
			     MORPH.MCLASS n-pl-infl,
			     SYNSEM  [LOCAL [CAT.HEAD noun,
					     AGR.PNG p-s-g ]],
			     DTR [INFLECTED -,
				  SUPRA #sup]].

noun-plural-const-rule := 
			  no-prefix-lex-rule &
			  same-local-lex-rule &
			  same-modified-lex-rule &
			  same-light-lex-rule &
			  same-non-local-lex-rule &
			  constant-lex-rule &
			  nocoord & 
			  [C-CONT [RELS <! !>,
				   HCONS <! !>],
			   INFLECTED na,
			   MORPH.MCLASS n-pl-infl,
			   SYNSEM [LOCAL [CAT.HEAD noun,
					  AGR.PNG p-p-g ]],
			   DTR [INFLECTED -]].


noun-plural-infl-rule :=
 			no-prefix-lex-rule &
			same-local-lex-rule &
			same-modified-lex-rule &
			same-light-lex-rule &
			same-non-local-lex-rule &
			inflecting-lex-rule &
			nocoord &
			[C-CONT [RELS <! !>,
				 HCONS <! !>],
			 INFLECTED na,
			 MORPH.MCLASS n-pl-infl,
			 SYNSEM  [LOCAL [CAT.HEAD noun,
					 AGR.PNG p-p-g ]],
			 DTR [INFLECTED -]].





;;; Phrasal types

basic-expl-subj-phrase := head-valence-phrase & head-only &
			  head-compositional & 
			  [ INFLECTED #infl,
			    SYNSEM canonical-synsem &
				      [ LOCAL.CAT [ VAL [ SUBJ < >,
							  COMPS #comps,
							  SPR #spr,
							  SPEC #spec ],
						    POSTHEAD #ph ],
					MODIFIED #mod ],
			    C-CONT [ RELS <! !>,
				     HCONS <! !> ],
				HEAD-DTR [ INFLECTED #infl & +,
					   SYNSEM [ LOCAL [ CAT [ VAL [ SUBJ < unexpressed &
									       [ OPT +,
										 LOCAL.CONT [HOOK.INDEX expl-ind,
											     RELS <! !>,
											     HCONS <! !>] ] >,
									COMPS #comps & < >,
									SPR #spr,
									SPEC #spec ],
								  POSTHEAD #ph ],
							    CONT.HOOK.INDEX event ],
						    MODIFIED #mod ] ] ].

basic-head-opt-subj-phrase := head-valence-phrase & head-only &
			      head-compositional & 
			      ccont-2ep-rule &
			      [ INFLECTED #infl,
				SYNSEM canonical-synsem &
					  [ LOCAL.CAT [ VAL [ SUBJ < >,
							      COMPS #comps,
							      SPR #spr,
							      SPEC #spec ],
							POSTHEAD #ph ],
					    MODIFIED #mod ],
				C-CONT [ RELS <! [PRED "pron_rel",
						  LBL #larg,
						  ARG0 #0], 
					       [PRED "pronoun_q_rel",
						RSTR #harg,
						ARG0 #0] !>,
					 HCONS <! qeq & [HARG #harg,
							 LARG #larg]!> ],
				HEAD-DTR [ INFLECTED #infl & +,
					   SYNSEM [ LOCAL [ CAT [ VAL [ SUBJ < unexpressed-reg &
									       [ OPT +,
										 LOCAL.CONT.HOOK.INDEX #0 & [COG-ST in-foc] ] >,
									COMPS #comps & < >,
									SPR #spr,
									SPEC #spec ],
								  POSTHEAD #ph ],
							    CONT.HOOK.INDEX event ],
						    MODIFIED #mod ] ] ].



basic-head-comp-phrase :+ [ SYNSEM.LOCAL.CAT.MC #mc,
			    HEAD-DTR.SYNSEM.LOCAL.CAT.MC #mc].

;;; Using XARG; do not equate entire HOOK
basic-head-mod-phrase-simple := head-mod-phrase & binary-headed-phrase &
  [ SYNSEM [ NON-LOCAL [ SLASH [ LIST #first,
				 LAST #last ],
			 REL 0-dlist ] ],
    HEAD-DTR.SYNSEM 
           [ LOCAL [ CAT [ HEAD #head,
                           VAL #val,
                           POSTHEAD #ph,
                           MC #hmc ],
                     AGR #agr,
                     CONT.HOOK [LTOP #l,
                                INDEX #i]],
             NON-LOCAL #nonloc &
                   [ SLASH [ LIST #middle,
                             LAST #last ] ],
	     LIGHT #light,
	     MODIFIABLE #modifiable,
             MODIFIED #modif ],
    NON-HEAD-DTR.SYNSEM 
           [ LOCAL.CAT [ HEAD [ MOD < [ LOCAL local & 
                                              [ CAT [ HEAD #head,
                                                      VAL #val,
                                                      POSTHEAD #ph,
                                                      MC #hmc ],
                                                AGR #agr,
                                                CONT.HOOK [INDEX #i,
                                                           LTOP #l] ],
                                        NON-LOCAL #nonloc,
					LIGHT #light,
					MODIFIABLE #modifiable,
                                        MODIFIED #modif ] > ],
                         VAL [ COMPS olist,
                               SPR olist ] ],
             NON-LOCAL [ SLASH [ LIST #first,
                                 LAST #middle ],
                         QUE 0-dlist & [ LIST null ] ] ],
    C-CONT.RELS <! !> ].


basic-head-mod-phrase-simple :+ [ SYNSEM.LOCAL.CAT.MC #mc,
				  NON-HEAD-DTR.SYNSEM.LOCAL.CAT.MC #mc ].

head-comp-phrase := basic-head-1st-comp-phrase & 
		    head-initial & 
		    [SYNSEM.MODIFIABLE #m,
		     HEAD-DTR.SYNSEM [MODIFIABLE #m,
				      MODIFIED notmod]].

head-cluster-phrase := basic-head-comp-phrase &
		       head-initial & 
		       [SYNSEM [MODIFIABLE #m ],
			HEAD-DTR.SYNSEM [MODIFIABLE #m,
					 MODIFIED notmod]].


subj-head-phrase := decl-head-subj-phrase & head-final & 
  [ HEAD-DTR.SYNSEM.LOCAL.CAT.VAL [COMPS < >,
				   SUBJ <[BOUND -]>] ].


spec-head-phrase := basic-head-spec-phrase & head-final & 
  [ SYNSEM.MODIFIABLE -,
    HEAD-DTR.SYNSEM.LOCAL.CAT.VAL [SPR <[LOCAL.CAT.HEAD free-det]>,
				   COMPS < > ]].




extracted-subj-phrase := basic-extracted-subj-phrase &
			 head-compositional &
			 [C-CONT [RELS <! !>,
				  HCONS <! !>],
			  SYNSEM [LOCAL [CAT [HEAD verb & [VFORM indep]],
					 CONT.HOOK.INDEX [_REL bool]],
				  NON-LOCAL.SLASH <! [CONT.HOOK.INDEX.--GAP +] !> ],
			  HEAD-DTR.SYNSEM.LOCAL.CAT.VAL [SUBJ <[]>] ].

; Constraint on SUBJ: [LOCAL.CAT.HEAD.CASE npro-case]

head-rel-phrase :=
		  head-mod-phrase &
		  head-initial &
		  head-compositional &
		  [ SYNSEM [  NON-LOCAL [ SLASH [ LIST #first,
						 LAST #last ],
					 REL 0-dlist ] ],
		    HEAD-DTR.SYNSEM 
			   [ MODIFIABLE na-or-+,
			     BOUND -,
			     LOCAL [ CAT [ HEAD noun,
					   VAL [COMPS <>]],
				     AGR #index,
				     CONT.HOOK [INDEX ref-ind & #index,
						LTOP #top]],
			     NON-LOCAL [ SLASH [ LIST #middle,
						 LAST #last ] ] ],
		    NON-HEAD-DTR.SYNSEM [ LOCAL [CAT [ HEAD verb & [VFORM indep,
								   MOD < >   ],
						      VAL [ COMPS olist,
							    SPR olist ] ],
						 CONT.HOOK [INDEX event & 
								  [_REL +,
								   E non-sbj-tam],
							    LTOP #top]],
					  NON-LOCAL [ SLASH [ LIST #first,
						   LAST #middle ],
						      REL <! #index !>,
						      QUE 0-dlist & [ LIST null ] ] ],
		    C-CONT [RELS <! !>,
			    HCONS <! !>] ].



filler-head-phrase := 
		      basic-head-filler-phrase &
		      head-final &
		      head-compositional &
		      [C-CONT [RELS <! [PRED "focus_d_rel",
					LBL #l,
					ARG0 event & [e no_tam],
					ARG1 #1,
					ARG2 #2,
					CFROM #from,
					CTO #to] !>,
			       HCONS <! !>],
		       SYNSEM.NON-LOCAL [REL  <! !> & [LIST #rel1,
							LAST #rel3],
					 QUE [LIST #que1,
					      LAST #que3]],
		       NON-HEAD-DTR [STEM [FROM #from,
					   TO #to],
				     SYNSEM [BOUND -,
					     LOCAL.CONT.HOOK.INDEX #2,
					     NON-LOCAL [REL [LIST #rel1,
							    LAST #rel2],
						       QUE [LIST #que1,
							    LAST #que2]]]],
		       HEAD-DTR [SYNSEM [LOCAL.CONT.HOOK [LTOP #l,
							  INDEX #1],
					 NON-LOCAL [REL [LIST #rel2,
							LAST #rel3],
						   QUE [LIST #que2,
							LAST #que3]]]]].

rel-filler-head-phrase := 
		      basic-head-filler-phrase &
		      head-final &
		      head-compositional &
		      [C-CONT [RELS <! [PRED "topic_d_rel",
					LBL #l,
					ARG0 event & [e no_tam],
					ARG1 #1,
					ARG2 #2,
					CFROM #from,
					CTO #to] !>,
			       HCONS <! !>],
		       SYNSEM.NON-LOCAL [REL  <! [] !> & [LIST #rel1,
							LAST #rel3],
					 QUE [LIST #que1,
					      LAST #que3]],
		       NON-HEAD-DTR [STEM [FROM #from,
					   TO #to],
				     SYNSEM [LOCAL.CONT.HOOK.INDEX #2,
					     NON-LOCAL [REL [LIST #rel1,
							    LAST #rel2],
						       QUE [LIST #que1,
							    LAST #que2]]]],
		       HEAD-DTR [SYNSEM [LOCAL.CONT.HOOK [LTOP #l,
							  INDEX #1],
					 NON-LOCAL [REL [LIST #rel2,
							LAST #rel3],
						   QUE [LIST #que2,
							LAST #que3]]]]].


; Bare NP phrase.  Consider modifying the PRED value of the quantifier relation
; introduced to match the semantic effect of bare NPs in your language.

bare-np-phrase := basic-bare-np-phrase &
		  ccont-1ep-rule &
		  [SYNSEM [MODIFIED notmod,
			   NON-LOCAL #nloc],
		   HEAD-DTR.SYNSEM.NON-LOCAL #nloc,
		   C-CONT.RELS <! [ PRED "unspec_q_rel",
				    ARG0 [COG-ST uniq-or-less,
					  SPECI -]] !> ].



;;; Non-compositional binary rule type (for reduplication)


non-compositional-binary-phrase := 
				   phrase &
				   [STEM [FROM #from,
					  TO #to],
				    SYNSEM.LOCAL [CONT [ RELS [ LIST #first,
								LAST #last ],
							 HCONS [ LIST #scfirst,
								 LAST #sclast ] ]],
				    C-CONT [ RELS [ LIST #middle,
						    LAST #last ],
					     HCONS [ LIST #scmiddle,
						     LAST #sclast ] ],
				    ARGS < sign & 
					   [STEM [FROM #from]],
					   sign & 
					   [STEM [TO #to],
					    SYNSEM.LOCAL local &
						 [ CONT [ RELS [ LIST #first,
								 LAST #middle ],
							  HCONS [ LIST #scfirst,
								  LAST #scmiddle ] ] ] ] > ].

total-reduplication-phrase :=
			     non-compositional-binary-phrase &
			     [INFLECTED +,
			      SUPRA [TONE <! !>,
				     LEN <! !>],
			      SYNSEM [LOCAL [CAT #cat,
					     COORD #coord]],
			      ARGS < word-or-lexrule & 
				    [INFLECTED +,
				     SYNSEM [LOCAL [CAT [HEAD #head],
						    COORD #coord]]], 
				    word-or-lexrule & 
				    [INFLECTED +,
				     SYNSEM [LOCAL [CAT #cat & [HEAD #head],
						    COORD #coord]]]>].




;;; Derivational rule types 

pluractional-lex-rule := 
			 no-prefix-tone-lex-rule &
			 infl-ltol-rule &
			 same-head-lex-rule &
			 same-val-lex-rule &
			 same-hc-light-lex-rule &
			 same-posthead-lex-rule &
			 same-mc-lex-rule &
			 same-cont-lex-rule &
			 same-ctxt-lex-rule &
			 same-agr-lex-rule &
			 same-non-local-lex-rule &
			 same-tone-lex-rule &
			 ccont-1ep-rule &
			 [MORPH.COMPLETE bool,
			  SUPRA [LEN.LIST #llist,
				 TONE #tone,
				 PRFX [LEN <! short !>,
				       TONE <! !> ]],
			  C-CONT [RELS <! [PRED "pluractional_rel",
					   ARG0 event & [E no_tam],
					   LBL #l,
					   ARG1 #1
						] !>,
				  HCONS <! !>],
			  MORPH [MCLASS #mclass,
				 DERIVED +], 
			  SYNSEM [LOCAL [CAT.HEAD verb,
					 CONT.HOOK [LTOP #l,
						    INDEX #1 & 
							 event & 
							 [E real_tam]]]], 
			  DTR  [MORPH [DERIVED na,
				       MCLASS #mclass],
				INFLECTED na,
				SUPRA [LEN.LIST #llist,
				       TONE #tone]
				      ]
					 ].