;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;--------------Phrase Types-------------------;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; The head of head-comp-phrase can't be: ['comp']

; ERB 2007-05-15 Abusing OPT feature again in the analysis
; of INI.  head-comp-phrase must now check for compatibility
; with [ OPT - ].

head-comp-phrase := basic-head-1st-comp-phrase & head-initial &
  [ SYNSEM.LOCAL.CAT.HEAD +nvjrpdmo,
    HEAD-DTR.SYNSEM.LOCAL.CAT.VAL.COMPS.FIRST.OPT - ].

;;; ERB 2007-05-22 Trying to cut down on active edges in the
;;; gen chart.  Since we have waaaaaaaaaaay more verb edges than
;;; noun edges, it makes sense to make this one left-to-right.
;;; Also, then, we have to say that all subjects are [ HEAD noun ].

subj-head-phrase := decl-head-subj-phrase & head-final & 
		    binary-rule-left-to-right &
  [ NON-HEAD-DTR.SYNSEM.LOCAL.CAT.HEAD noun,
    HEAD-DTR.SYNSEM.LOCAL.CAT [ VAL.COMPS < >,
				HEAD.FORM dec-or-subj ] ] .

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

;;; ERB 2007-05-22 This one should be right-to-left.

head-spec-phrase := basic-head-spec-phrase & head-final &
		    binary-rule-right-to-left.

; 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 &
  [ C-CONT.RELS <! [ PRED "exist_q_rel" ] !> ] .

; comp-head-phrase can requires things that are [ HEAD comp ].

comp-head-phrase := basic-head-1st-comp-phrase &
  [ SYNSEM.LOCAL.CAT.HEAD comp ] .

qpart-head-phrase := comp-head-phrase & head-final &
		     binary-rule-right-to-left &
  [ SYNSEM.LOCAL.CAT.MC +,
    HEAD-DTR qpart-lex-item ] .

embedded-comp-head-phrase := comp-head-phrase & head-initial &
  [ SYNSEM.LOCAL.CAT.MC -,
    HEAD-DTR emb-comp-lex-item ] .

imp-phrase := imp-head-opt-subj-phrase &
  [ SYNSEM.LOCAL.CAT.HEAD.FORM imp ].

opt-subj-phrase := decl-head-opt-subj-phrase &
  [ SYNSEM.LOCAL.CAT.HEAD.FORM dec-or-subj ].


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;------------------- Lexical types----------------------;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;**********************
;*-- Complementizers--*
;**********************

; We treat question particles as complementizers.
; Here is the lexical type for complementizers.

; ERB 2007-05-21 Need to put in constraint on form here, or
; the subj forms mess things up on generation.

complementizer-lex-item := raise-sem-lex-item & basic-one-arg &
  [ SYNSEM.LOCAL.CAT [ HEAD comp &
                            [ MOD < > ],
                       VAL [ SPR < >,
                             SUBJ < >,
                             COMPS < #comp > ] ],
    ARG-ST < #comp &
             [ LOCAL.CAT [ HEAD verb & [ FORM dec ],
                           VAL [ SUBJ < >,
                                 COMPS < > ] ] ] > ] .

; Subtype for question particles. Constrains SF to ques.

qpart-lex-item := complementizer-lex-item &
  [ SYNSEM.LOCAL [ CONT.HOOK.INDEX.SF ques ] ].

; Subtype for complementizers in embedded clauses.
; Without this, qpart-lex-item could go through head-initial rule
emb-comp-lex-item := complementizer-lex-item.

;*************
;*-- Nouns --*
;*************
noun-lex-supertype := basic-one-arg & norm-hook-lex-item & no-hcons-lex-item &
   [ SYNSEM [LOCAL.CAT [HEAD noun,
			VAL [SPR < #spr &
				   [ LOCAL.CAT.HEAD det ] >,
                               COMPS < >,
                               SUBJ < >,
                               SPEC < > ]],
             LKEYS.KEYREL noun-relation ],
    ARG-ST < #spr > ] .


noun-lex := noun-lex-supertype & single-rel-lex-item.


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


pronoun-lex := noun-lex &
  [ SYNSEM [ LOCAL [CAT.VAL.SPR < [ OPT + ] >,
		    CONT.HOOK.INDEX [ COG-ST activ-or-more,
				      SPECI +]],
	     LKEYS.KEYREL.PRED "_pronoun_n_rel"]].


dem-pro-lex := noun-lex-supertype &
   [ SYNSEM [ LOCAL [CAT.VAL.SPR < [ OPT + ] >,
		    CONT [ HOOK.INDEX [COG-ST activ-or-more,
				       PNG.PER third],
			   RELS.LIST [FIRST.PRED #pro,
				      REST.FIRST #alt]]],
	      LKEYS [ KEYREL.PRED #pro & "_pronoun_n_rel",
		      ALTKEYREL #alt & event-relation ]]].


;*************
;*-- Verbs --*
;*************

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

intransitive-verb-lex := verb-lex & intransitive-lex-item &
			 neg-can-dtr & default-fv-dtr &
  [ SYNSEM.LOCAL.CAT [ HEAD.AUX -,
		       VAL.COMPS < > ],
    ARG-ST < [ LOCAL.CAT.HEAD noun ] > ] .


transitive-verb-lex := verb-lex & transitive-lex-item & 
		       takes-oc & imp-dtr &
  [ SYNSEM.LOCAL.CAT [HEAD.AUX -,
		      VAL.COMPS < #comps > ],
    ARG-ST < [ LOCAL.CAT.HEAD noun ], #comps &
                                      [ LOCAL.CAT [ VAL [ SPR < >,
                                                          COMPS < > ],
                                                    HEAD noun ] ] > ] .

; ERB 2007-05-15 Making two subtypes, to allow for INI in some cases.
; Since [OPT -] comes in through lexical rules, constrain through OPT-CS.
; The idea is that the no-obj concord rule for INI verbs says OPT-CS type-id.
; Verbs that can't to INI thus say OPT-CS uniq+fam+act, and therefore
; can only go through the other no-obj concord rule (which says OPT -,
; and disallows object drop) or through the object concord rules.

; ERB 2007-07-12 In fact, they have to say OPT-CS in-foc, on the current
; treatment.

no-ini-trans-verb-lex := transitive-verb-lex &
  [ ARG-ST.REST.FIRST.OPT-CS uniq-or-more ].


; first object is optional, but OPT is underspecified so 
; it can go through no-obj-concord-lex-rule
ditransitive-verb-lex := verb-lex & ditransitive-lex-item 
			 & takes-oc & imp-dtr &
   [ SYNSEM.LOCAL.CAT [ HEAD.AUX -,
			VAL.COMPS < #comp1, #comp2 > ],
    ARG-ST < [ LOCAL.CAT.HEAD noun ], #comp1 &
	                              [ LOCAL.CAT [ VAL [ SPR < >,
							  COMPS < > ],
						    HEAD noun ]],
			              #comp2 &
			              [ LOCAL.CAT [ VAL [ SPR < >,
							  COMPS < > ]],
					OPT - ] > ].


; embedded clauses are always propositions.
; ERB 2007-07-12 No.  They always have the same form, but the SF
; value can vary depending on the embedding verb.  Assuming for
; now that there are three types as in English: prop only (tell),
; prop-or-ques (know), and ques only (ask).

clause-comp-verb-lex := clausal-second-arg-trans-lex-item & verb-lex &
			takes-oc & imp-dtr &
  [ SYNSEM.LOCAL.CAT.VAL.COMPS < #comps & [ LOCAL [CAT [HEAD comp,
							VAL  [ SPR < >,
							       SUBJ < >,
							       COMPS < >,
							       SPEC < > ],
							MC - ], 
					  CONT.HOOK.INDEX.SF prop-or-ques ] ] >,
    ARG-ST.REST.FIRST #comps ] .

prop-comp-verb-lex := clause-comp-verb-lex &
  [ SYNSEM.LOCAL.CAT.VAL.COMPS.FIRST.LOCAL.CONT.HOOK.INDEX.SF prop ].

ques-comp-verb-lex := clause-comp-verb-lex &
  [ SYNSEM.LOCAL.CAT.VAL.COMPS.FIRST.LOCAL.CONT.HOOK.INDEX.SF ques ].


aux-verb-lex := trans-first-arg-raising-lex-item-1 & verb-lex & imp-dtr &
 [ SYNSEM [ LOCAL [ CAT [ HEAD.AUX +,
			VAL [ SUBJ <#subj>,
			      COMPS < #comps & [ LOCAL [ CAT [ HEAD verb &
								    [ AUX -,
								      FORM inf],
							       VAL.SUBJ < [] > ],
							 CONT.HOOK.INDEX #index ] ] > ]],
		    CONT.HOOK.INDEX #index ] ],
   ARG-ST < #subj , #comps > ].


; aux-verb-lex := trans-first-arg-raising-lex-item & verb-lex & imp-dtr &
;  [ SYNSEM [ LOCAL [ CAT [ HEAD.AUX +,
; 			VAL [ SUBJ <#subj>,
; 			      COMPS < [ LOCAL.CAT [ HEAD verb &
; 							 [ AUX -,
; 							   FORM inf],
; 						    VAL.SUBJ <#subj> ]]>]],
; 		  CONT [HCONS <! qeq & 
; 			       [ HARG #harg,
; 				 LARG #larg ] !> ] ],
; 	   LKEYS.KEYREL event-relation & 
; 			       [ ARG1 #harg ]],
;    ARG-ST < [],
; 	    [LKEYS.KEYREL.LBL #larg ] > ].




;*****************
;*-- Modifiers --*
;*****************

;;; This is a catch-all class for modifiers of nouns.
;;; Covers demonstratives and qualificatives, which include
;;; adjectives, relatives, and enumeratives.
dem+qual-lex := basic-int-mod-adj-lex & 
  [ SYNSEM [ LOCAL [ CAT [ HEAD.MOD < [ LOCAL.CAT [ HEAD noun,
                                                    VAL.SPR cons ]]>,
			   VAL [ SPR < >,
				 SUBJ < >,
				 COMPS < >,
				 SPEC < > ]]]]].

qualificative-lex := dem+qual-lex &
[ SYNSEM.LOCAL.CAT.POSTHEAD + ].
adjective-lex := qualificative-lex.
relative-lex := qualificative-lex.
enumerative-lex := qualificative-lex.


dem-adj-lex := dem+qual-lex &
[SYNSEM [LOCAL [CAT [HEAD.MOD <[LOCAL.CONT.HOOK.INDEX.COG-ST activ+fam ]>]],
	 LKEYS.KEYREL arg1-relation &
	              [ PRED demonstrative_a_rel ] ] ].

proximal-dem-adj-lex := dem-adj-lex &
[SYNSEM.LKEYS.KEYREL.PRED proximal+dem_a_rel].

remote-dem-adj-lex := dem-adj-lex &
[SYNSEM.LKEYS.KEYREL.PRED remote+dem_a_rel].

hearer-dem-adj-lex := dem-adj-lex &
[SYNSEM.LKEYS.KEYREL.PRED hearer+dem_a_rel].

proximal-dem-pro-lex := dem-pro-lex &
[SYNSEM.LKEYS.ALTKEYREL.PRED proximal+dem_a_rel].

remote-dem-pro-lex := dem-pro-lex &
[SYNSEM.LKEYS.ALTKEYREL.PRED remote+dem_a_rel].

hearer-dem-pro-lex := dem-pro-lex &
[SYNSEM.LKEYS.ALTKEYREL.PRED hearer+dem_a_rel]. 

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

head-verb-adverb-lex := adverb-lex &
  [SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CAT.HEAD verb] > ] .

s-adverb-lex := head-verb-adverb-lex &
  [SYNSEM.LOCAL.CAT.HEAD.MOD < [LOCAL.CAT.VAL.SUBJ < > ] > ] .

light-adverb-lex := adverb-lex &
  [SYNSEM.LOCAL.CAT.HEAD.MOD < [LIGHT +] > ] .

vp-adverb-lex := head-verb-adverb-lex & light-adverb-lex.
  
adv-adverb-lex := light-adverb-lex &
 [ SYNSEM.LOCAL.CAT [ HEAD.MOD < [ LOCAL.CAT.HEAD adv] >,
		      POSTHEAD + ] ].


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;--------------Misc. Type Hierarchy Info-----------;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

head :+ [ AUX bool,
    FORM form] .

+nv :+ [MOD < >].

form := avm .

inf := form .

;  ERB 2007-05-21 For root condition.
dec-or-imp := form.
imp := dec-or-imp.

; ERB 2007-05-21 For neg-fv rule, which seems like it ought to be able
; to head stand-alone clauses or conjuncts.
dec-or-subj := form.
dec := dec-or-subj & dec-or-imp.
subj := dec-or-subj.



;;; Person & Number 
png :+ [ PER person,
         NUM number,
	 NCL nclass].

gend := *top*.
masc := gend.
fem := gend.

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

number := *top*.
sg := number.
du := non-sg.
non-sg := number.
pl := non-sg.

;;; Noun class rules
;;; ERB 2007-05-16 Adding lots of disjunctive classes to 
;;; better handle homophony/syncretism in the various paradigms. 

;;; ERB 2007-07-12 Further adding underspecified types for
;;; `plural' and `singular' for semi.vpm.  It seems that
;;; c14 and above don't form sg/pl pairs.  I'm going to assume
;;; for now that these are abstract concepts etc and therefore
;;; should map to singular in the interlingua.

;;; ERB 2007-07-12 In fact, sg-ncl and pl-ncl have to be supertypes
;;; to c8+c10 et al so that when we have a verb with just that information
;;; in the MRS (because of argument drop), we can still make use of
;;; the info through the semi.

nclass := *top*.

sg-ncl := nclass.
pl-ncl := nclass.

c1+c2 := nclass.
c1+c1a+c3 := sg-ncl.
c1+c3 := c1+c1a+c3.
c1+c1a := c1+c1a+c3.
c2+c2a := pl-ncl.
c1 := c1+c2 & c1+c3 & c1+c1a.
c2 := c1+c2 & c2+c2a.

c1a+c2a := nclass.
c1a := c1a+c2a & c1+c1a.
c2a := c1a+c2a & c2+c2a.

;c4+c9 := nclass.
c3+c4 := nclass.
c3 := c3+c4 & c1+c3.
c4 := c3+c4 & pl-ncl.

c5+c6 := nclass.
c5 := c5+c6 & sg-ncl.
c6 := c5+c6 & pl-ncl.

c7+c8 := nclass.
c8+c10 := pl-ncl.
c7 := c7+c8 & sg-ncl.
c8 := c7+c8 & c8+c10.

c9+c10 := nclass.
c11+c10 := nclass.
c9 := c9+c10 & sg-ncl.
c10 := c9+c10 & c11+c10 & c8+c10.
c11 := c11+c10 & sg-ncl.

c14 := sg-ncl.

; ERB 2007-05-15 Lots of syncretism for these three

c15+c16+c17 := sg-ncl.
c15+c17 := c15+c16+c17.

c15 := c15+c17.
c16 := c15+c16+c17.
c17 := c15+c17.
    

demonstrative_a_rel := predsort.
proximal+dem_a_rel := demonstrative_a_rel. ; close to speaker
distal+dem_a_rel := demonstrative_a_rel.   ; away from speaker
remote+dem_a_rel := distal+dem_a_rel.      ; away from speaker and hearer
hearer+dem_a_rel := distal+dem_a_rel.      ; near hearer
	     

future := tense.
present := tense.
past := tense.

verb-tense-rule-dtr := avm.

takes-oc := avm.

vp-or-adv-modifier := avm.

neg-can-dtr := avm.

imp-dtr := avm.

default-fv-dtr := avm.

neg-fv-dtr := avm.
			     
			     


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;-----------------Lexical Rules-------------------------;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;; Coordination Strategy 1

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

n1-bottom-coord-rule := infl-bottom-coord-rule &
  [ SYNSEM.LOCAL.COORD-STRAT "1",
    SYNSEM.LOCAL.COORD-REL.PRED "_and_coord_rel",
    DTR.SYNSEM.LOCAL.CAT.HEAD noun ] .

;;; VP Coordination Strategy 2 -- copied from Malayalam, with
;;; FORM value changed.   Except, we might as well go with S 
;;; coord only, to keep things under control.

;vp1-top-coord-rule := basic-vp-top-coord-rule & apoly-top-coord-rule &
;  [ SYNSEM.LOCAL.COORD-STRAT "2",
;    LCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD.FORM subj ] .

;vp1-bottom-coord-rule := unary-bottom-coord-rule & vp-bottom-coord-phrase &
;  [ SYNSEM.LOCAL [ COORD-STRAT "2",
;                   COORD-REL.PRED "_and_coord_rel" ] ] .

;;; S Coordination Strategy 2 --- Copied from Malayalam with FORM
;;; value changed.


;;; ERB 2007-05-22 This one seems to be making lots of active
;;; edges in the gen-chart.  See if making it also binary-rule-left-to-right
;;; will help cut that down.  That is, it should only create an 
;;; active edge if it can find something for LCOORD-DTR.


s1-top-coord-rule := basic-s-top-coord-rule & apoly-top-coord-rule &
		     binary-rule-left-to-right &
  [ SYNSEM.LOCAL [ COORD-STRAT "2",
		   CAT.HEAD.FORM #form ],
    LCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD.FORM subj,
    RCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD.FORM #form ] .

s1-bottom-coord-rule := unary-bottom-coord-rule & s-bottom-coord-phrase &
  [ SYNSEM.LOCAL [ COORD-STRAT "2",
                   COORD-REL.PRED "_and_coord_rel" ] ] .



neg-infl-lex-rule := cont-change-only-lex-rule & inflecting-lex-rule &
  [ C-CONT [ HOOK [ XARG #xarg,
                    LTOP #ltop,
                    INDEX #ind ],
             RELS <! event-relation &
                     [ PRED "_neg_r_rel",
                       LBL #ltop,
                       ARG1 #harg ] !>,
             HCONS <! qeq &
                      [ HARG #harg,
                        LARG #larg ] !> ],
    SYNSEM.LKEYS #lkeys,
    DTR subj-concord-lex-rule &
        [ SYNSEM [ LKEYS #lkeys,
                   LOCAL [ CONT.HOOK [ XARG #xarg,
                                       LTOP #larg,
				       INDEX #ind ],
                           CAT.HEAD verb & 
				     [FORM dec,
				      AUX -] ] ] ] ] .



;;; Verb tense information - tried to set this up
;;; so that it could be expanded later if necessary.

;;; ERB 2007-05-16 Added nocoord here to get rid of -M labels.
;;; ERB 2007-05-21 Not sure why we're constraining FORM here, but
;;; maybe it's because negation and tense are incompatible somehow?
;;; ERB 2007-05-21 It seems to be blocking the subjunctive form.
;;; Since default-fv-lex-rule is now adding FORM info, maybe we 
;;; don't need it here at all.

verb-tense-lex-rule := add-only-no-ccont-rule & lexeme-to-lexeme-rule & nocoord &
   [DTR verb-tense-rule-dtr ] .

fut-tense-lex-rule := inflecting-lex-rule & verb-tense-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.E.TENSE future ] .


;;; ERB 2007-05-15 Making present tense rule for -ya-, so
;;; changing this to inflecting.

pres-tense-lex-rule := inflecting-lex-rule & verb-tense-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.E.TENSE present ] .

;;; ERB 2007-05-15 It looks like I also need the zero form
;;; for some of Kelly's examples.  Will possibly need to constrain
;;; one or the other to keep from overgenerating.

pres-tense-lex-rule2 := constant-lex-rule & verb-tense-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.E.TENSE present ] .


;;; Imperative rules
;;; ERB 2007-05-21 This can't be lexeme-to-word either, since that
;;; means no change.  Once again, making up a type.

imperative-verb-lex-rule := head-change-only-lex-rule & nocoord &
  [ DTR imp-dtr & 
	[ INFLECTED -,
	  SYNSEM.LOCAL.CAT.HEAD verb &
		    [ MOD #mod,
		      AUX #aux ]],
    INFLECTED +,
    SYNSEM.LOCAL.CAT [HEAD verb &
			   [FORM imp,
			    AUX #aux,
			    MOD #mod ],
		      MC +]].

sg-imp-verb-lex-rule := constant-lex-rule & imperative-verb-lex-rule & 
  [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NUM sg ] > ].

pl-imp-verb-lex-rule := inflecting-lex-rule & imperative-verb-lex-rule &
  [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NUM non-sg ] > ] .

;pos-imp-lex-rule := lexeme-to-word-rule &
;  [DTR imperative-verb-lex-rule &
;       [SYNSEM.LOCAL.CAT.HEAD.AUX -]].		    

;neg-imp-lex-rule := cont-change-only-lex-rule & const-ltow-rule &
;  [ DTR imperative-verb-lex-rule &
;	[SYNSEM.LOCAL.CAT.HEAD.AUX +] ].
			    

;Potential lexical rules
ability-lex-rule := infl-cont-change-only-ltol-rule.
        
pos-ability-lex-rule := ability-lex-rule & verb-tense-rule-dtr &
[ C-CONT [ RELS <! arg1-ev-relation & 
		   [PRED "_can_v_rel",
		    LBL #lbl,
		    ARG0 #arg0,
		    ARG1 #arg1]!> ,
	   HOOK [ LTOP #lbl,
		  INDEX #arg0,
		  XARG #xarg ],
	   HCONS <! qeq & 
		  [ HARG #arg1,
		    LARG #larg ] !> ],
  DTR default-fv-lex-rule & 
	 [SYNSEM.LOCAL.CONT.HOOK [XARG #xarg,
				  LTOP #larg ]]] .

neg-ability-lex-rule := ability-lex-rule &
[ C-CONT [ RELS <! arg1-ev-relation & 
		   [PRED "_can_v_rel",
		    LBL #lbl,
		    ARG0 #arg0,
		    ARG1 #arg1], 
		 arg1-relation &
		  [PRED "_neg_r_rel",
		   ARG1 #negarg ]!> ,
	   HOOK [ LTOP #lbl,
		  INDEX #arg0,
		  XARG #xarg ],
	   HCONS <! qeq & 
		  [ HARG #arg1,
		    LARG #larg ],
		  qeq &
		  [ HARG #negarg,
		    LARG #lbl ] !> ],
  DTR neg-can-dtr &
	 [SYNSEM.LOCAL.CONT.HOOK [XARG #xarg,
				  LTOP #larg ] ] ] .


; ERB 2007-05-21  There might be a better way to untangle this,
; but for now,  making this a head-change-only ltow rule (which
; type doesn't exist in matrix.tdl).

;inf-verb-lex-rule := infl-ltow-rule &
;  [ SYNSEM.LOCAL.CAT.HEAD.FORM inf,
;    DTR default-fv-lex-rule &
;	[ INFLECTED -]].

inf-verb-lex-rule := head-change-only-lex-rule & nocoord & inflecting-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD verb &
			   [ AUX #aux,
			     MOD #mod,
			     FORM inf ],
     INFLECTED +,
     DTR default-fv-lex-rule &
         [ INFLECTED -,
	   SYNSEM.LOCAL.CAT.HEAD [ AUX #aux,
				   MOD #mod ]]].


fv-lex-rule := infl-add-only-no-ccont-ltol-rule & verb-tense-rule-dtr.

;;; ERB 2007-05-21 For coordination, adding subjunctive FV rule.
;;; For contrast, add FORM value to default-fv-lex-rule too.

default-fv-lex-rule := fv-lex-rule & imp-dtr &
  [ DTR default-fv-dtr,
    SYNSEM.LOCAL.CAT.HEAD.FORM dec ] .

subjunctive-fv-lex-rule := fv-lex-rule & 
  [ DTR default-fv-dtr,
    SYNSEM.LOCAL.CAT.HEAD.FORM subj ].

neg-fv-lex-rule := fv-lex-rule &
  [ DTR neg-ability-lex-rule,
    SYNSEM.LOCAL.CAT.HEAD.FORM dec-or-subj ] .


;;; Class prefix rules
class-prefix-lex-rule := infl-ltow-rule &
   [ DTR common-noun-lex] .


;;; ERB 2007-05-16
c1+c3-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c1+c3,
					NUM sg] ].

c2-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c2,
					NUM non-sg] ].

c1a-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c1a,
					NUM sg] ].

c2a-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c2a,
					NUM non-sg] ].

;c3-prefix-lex-rule := class-prefix-lex-rule &
;   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c3,
;					NUM sg] ].

c4-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c4,
					NUM non-sg] ].

c5-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c5,
					NUM sg] ].

c6-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c6,
					NUM non-sg] ].

c7-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c7,
					NUM sg] ].

c8-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c8,
					NUM non-sg] ].

c9-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c9,
					NUM sg] ].

c10-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c10,
					NUM non-sg] ].

c11-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c11,
					NUM sg] ].

c14-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c14 ] ].

; ERB 2007-05-16
c15+c17-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c15+c17 ] ].

c16-prefix-lex-rule := class-prefix-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c16 ] ].

;c17-prefix-lex-rule := class-prefix-lex-rule &
;   [ SYNSEM.LOCAL.CONT.HOOK.INDEX.PNG [ NCL c17 ] ].


;;; SUBJECT CONCORD RULES

subj-concord-lex-rule := infl-ltow-rule &
   [ DTR verb-tense-lex-rule].

3rd-subj-concord-lex-rule := subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CONT.HOOK.XARG.PNG.PER third ] .

c1+c1a+c3-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [LOCAL.CONT.HOOK.INDEX.PNG.NCL c1+c1a+c3 ] > ] .

c2+c2a-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2+c2a ] > ] .

;c1a-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c1a ] > ] .

;c2a-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2a ] > ] .

;c3-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c3 ] > ] .

; ERB 2007-05-16
; ERB 2007-07-12 In fact, we need to split c4 and c9 in order to
; get the semi working, as we want to predict underspecified noun class
; from input number values, and c4 and c9 don't have the same number.

c4-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c4 ] > ] .

c5-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c5 ] > ] .

c6-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c6 ] > ] .

c7-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c7 ] > ] .

c8+c10-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c8+c10 ] > ] .

c9-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c9 ] > ] .

;c10-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c10 ] > ] .

c11-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c11 ] > ] .

c14-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c14 ] > ] .

c15+c16+c17-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c15+c16+c17 ] > ] .

;c16-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c16 ] > ] .

;c17-subj-concord-lex-rule := 3rd-subj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c17 ] > ] .

1sg-subj-concord-lex-rule := subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER first,
							       NUM sg ] ] > ] .

1non-sg-subj-concord-lex-rule := subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER first,
							       NUM non-sg ] ] > ] .

2sg-subj-concord-lex-rule := subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER second,
							      NUM sg ] ] > ] .

2non-sg-subj-concord-lex-rule := subj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ LOCAL.CONT.HOOK.INDEX.PNG[ PER second,
							      NUM non-sg ] ] > ] .


;;; Object concord lexical rules
;;; ERB 2007-05-16 Added no-coord here.
   
obj-concord-lex-rule := add-only-no-ccont-rule & lexeme-to-lexeme-rule &
			neg-can-dtr & default-fv-dtr & nocoord &
   [ DTR takes-oc & 
	 [ SYNSEM.LOCAL.CAT.HEAD.AUX - ] ].

no-obj-concord-lex-rule := constant-lex-rule & obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ OPT - ], ... > ].

;;; ERB 2007-05-15 Need to add a path for verbs like eat to 
;;; allow INI of object (I think --- we'll see what Sonja says).

;;; ERB 2007-05-15 Hmm ... this was leading to double parses, of 
;;; course, in cases with no object concord and overt objects.  I 
;;; think we should insist on that object in fact being dropped.
;;; Marking it [ OPT + ] now, and making head-comp check for
;;; compatibility with [ OPT - ].

no-obj-concord-lex-rule2 := constant-lex-rule & obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ OPT +, OPT-CS type-id ], ... > ].

;;; ERB 2007-05-15 This one said [ OPT + ] on the complement, but
;;; there is no need.  Just not saying [ OPT - ] does the right thing
;;; (i.e., allows object drop).

;;; ERB 2007-07-17 In fact, we can't say uniq+fam+act here, because
;;; these are the same ones that get used with object drop, when we
;;; want in-foc.  So changing this to uniq-or-more, and putting
;;; activ-or-less on common nouns.  Also adding OPT-CS in-foc.

add-obj-concord-lex-rule := inflecting-lex-rule & obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX [ COG-ST uniq-or-more,
							    SPECI + ],
				    OPT-CS in-foc ], ... > ] .

3rd-obj-concord-lex-rule := add-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.PER third ], ... > ] .

c1+c1a-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c1+c1a ], ... > ] .

c2+c2a-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2+c2a ], ... > ] .

;c1a-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c1a ], ... > ] .

;c2a-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2a ], ... > ] .

c3-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c3 ], ... > ] .

c4-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c4 ], ... > ] .

c5-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c5 ], ... > ] .

c6-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c6 ], ... > ] .

c7-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c7 ], ... > ] .

c8+c10-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c8+c10 ], ... > ] .

c9-obj-concord-lex-rule := 3rd-obj-concord-lex-rule & 
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c9 ], ... > ] .

;c10-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c10 ], ... > ] .

c11-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c11 ], ... > ] .

c14-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c14 ], ... > ] .

c15+c16+c17-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c15+c16+c17 ], ... > ] .

;c16-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c16 ], ... > ] .

;c17-obj-concord-lex-rule := 3rd-obj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c17 ], ... > ] .

1sg-obj-concord-lex-rule := add-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER first,
								NUM sg ] ], ... > ] .

1non-sg-obj-concord-lex-rule := add-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER first,
								NUM non-sg ] ], ... > ] .

2sg-obj-concord-lex-rule := add-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER second,
								NUM sg ] ], ... > ] .

2non-sg-obj-concord-lex-rule := add-obj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CONT.HOOK.INDEX.PNG [ PER second,
								NUM non-sg ] ], ... > ] .


;;; Adjectival concords

adj-concord-lex-rule := infl-ltow-rule &
   [ DTR adjective-lex ] .

3rd-adj-concord-lex-rule := adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [LOCAL.CONT.HOOK.INDEX.PNG.PER third ] > ].

c1+c1a+c3-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [LOCAL.CONT.HOOK.INDEX.PNG.NCL c1+c1a+c3 ] > ] .

c2+c2a-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2+c2a ] > ] .

;c1a-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c1a ] > ] .

;c2a-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2a ] > ] .

;c3-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c3 ] > ] .

c4-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c4 ] > ] .

c5-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c5 ] > ] .

c6-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c6 ] > ] .

c7-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c7 ] > ] .

c8-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c8 ] > ] .

c9-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c9 ] > ] .

c10-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c10 ] > ] .

c11-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c11 ] > ] .

c14-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c14 ] > ] .

c15+c16+c17-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c15+c16+c17 ] > ] .

;c16-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c16 ] > ] .

;c17-adj-concord-lex-rule := 3rd-adj-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c17 ] > ] .

;;; ERB 2007-05-15 Relative concords

relative-concord-lex-rule := infl-ltow-rule &
   [ DTR relative-lex ] .

c1+c1a+c3-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c1+c1a+c3 ] > ].

c2+c2a-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c2+c2a ] > ].

;c3-rel-concord-lex-rule := relative-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c3 ] > ].

c4-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c4 ] > ].

c5-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c5 ] > ].

c6-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c6 ] > ].

c7-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c7 ] > ].

c8+c10-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c8+c10 ] > ].

c9-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c9 ] > ].

;c10-rel-concord-lex-rule := relative-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c10 ] > ].

c11-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c11 ] > ].

c14-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c14 ] > ].

c15+c16+c17-rel-concord-lex-rule := relative-concord-lex-rule &
   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c15+c16+c17 ] > ].

;c16-rel-concord-lex-rule := relative-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c16 ] > ].

;c17-rel-concord-lex-rule := relative-concord-lex-rule &
;   [ SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX.PNG.NCL c17 ] > ].

;;; ERB 2007-05-21 Trying to cut down on the number of active edges
;;; in generation.

head-adj-int-phrase :+ binary-rule-right-to-left.