;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Ginzburgh and Sag (2002) Implementation
;;; Copyright (c) 2001-2002, John Beavers, Chris Callison Burch, and Ivan Sag
;;; see license.txt (distributed with LKB) for details
;;;
;;; Filename: lexeme-types.tdl
;;; Purpose: Type hierarchy for lexemes, including regular lexemes, 
;;;          auxiliaries, wh-words, the whole lot. 
;;; Last modified: 05/11/02 by John Beavers (JTB)
;;; Notes:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; <<< >>> PART OF SPEECH

;;; VERB LEXEME DEFINITIONS 

;;;JTB 07/18/01 - Trying to ditch all pumping rules.  Here eliminating
;;;phrase restrictions on COMPS and SUBJ and SPR of VPs.

;;;JTB 08/18/01 - Removed ANA false restriction on verbs 

;;;JTB 08/20/01 - Added hard POL false constraint, only way to get a
;;;POL true is via lexical rule.

v-lxm := lexeme & 
 [ SS [ LOC [ CAT [ HEAD verb,
                    SPR < >,
	            SUBJ < [ LOC.CAT [ HEAD noun,
                                       SPR < >,
                                       COMPS < > ] ] > ],
              CONT soa,
              Q-STORE <! !> ],
        WH <! !> ] ].

non-auxv-lxm:= v-lxm &
[ SS.LOC.CAT.HEAD [ INV false,
                    POL false, 
                    AUX false ] ].

auxv-lxm := v-lxm & s-rais &
[ SS.LOC.CAT.HEAD [ POL /l false,
                    FORM /l fin ] ].

;;;JTB 07/18/01 - Trying to ditch all pumping rules.  Here eliminating
;;;phrase restrictions on COMPS and SUBJ and SPR of VPs.

#|
dummy-auxv-lxm :=  v-lxm & 
[ ARG-ST < [ LOC.CAT.HEAD [ AGR expl-index & [ PERNUM 1or3sg ] ] ],
             #1 & [ LOC.CAT  [ HEAD noun,
                               SPR < > ] ],
                  [ LOC.CAT [ HEAD [ PRED true ],
                                     SUBJ < #1 >,
                                     COMPS < > ] ] > ].
|#
;;; NOUN LEXEME DEFINITIONS 

;;;JTB 07/19/01 - Noun semantics is now a scope-obj.  The
;;;determiner/pumping rule/specific lexical entry will determine
;;;whether it's a quant or a param.

;;;JTB 08/18/01 - Removed constraint [ AGR /l ref-index ].

n-lxm := lexeme &
 [ SS.LOC [ CAT [ HEAD noun & [ FORM /l normal, 
	        	        ANA /l false,
                                MOD /l < > ],
                  SUBJ /l < >,
                  SPR /l < >,
                  COMPS /l < > ],
            CONT scope-obj ] ].
	 
pron-lxm := n-lxm & no-args &
 [ SS [ LOC [ CAT [ HEAD noun & [ FORM /l normal, 
                                  ANA /l false ] ],
              Q-STORE /l <! !>,
              P-STORE <! !> ],
        WH <! !> ] ].

;;;JTB 07/17/01 - According to GS Chapter 5, the SPR.WH value and the
;;;WH value of this lexeme should be unified.  This isn't captured
;;;here, although that should be the ultimate effect since the COMPS
;;;for n-lxms is empty and so any stitching will accomplish the same
;;;thing.  Is this good enough?

;;;JTB 07/18/01 - Trying to ditch all pumping rules.  Here eliminating
;;;phrase restrictions on COMPS and SUBJ and SPR.

cn-lxm := n-lxm &
 [ SS.LOC.CAT [ HEAD.AGR #agr,
	        SPR < [ LOC [ CAT [ HEAD det & [ AGR #agr,
                                                 COUNT /l true ],
                                    SPR < > ] ] ] > ],
   SS.LOC.CONT [ INDEX #index, RESTR < [ PROP.SOA.NUCL.INSTANCE #index ] > ] ].

;;;JTB 07/29/01 - For nouns that take a prepositional complement like
;;;picture.

tr-cn-lxm := cn-lxm & str-tr & prep-arg.

pn-lxm := n-lxm &
 [ SS [ LOC [ CAT.HEAD [ PRED false, AGR 3sg ],
              CONT param,
              Q-STORE <! !>,
              P-STORE <! !> ],
        WH <! !>,
        SLASH <! !> ] ].

;;; NON-INFLECTING (CONST-LXM) LEXEME TYPES

const-lxm := lexeme.

det-lxm := inflected-lexeme+amalg &
[ SS [ LOC [ CAT [ HEAD det & [ SPEC /l scope-obj ],
                   SUBJ < >,
                   SPR /l < >,
                   COMPS < > ],
             CONT scope-obj ],
       SLASH <! !> ],
  DTRS < inflected-lexeme >,
  ARG-ST /l < > ].

non-wh-det-lxm := det-lxm &
[ SS [ LOC [ CAT [ HEAD.SPEC /l [ INDEX #index,
                                  RESTR #restr ] ],
             CONT #cont & /l [ INDEX #index,
                               RESTR #restr ],
             Q-STORE <! #cont !>,
             P-STORE <! !> ],
     WH <! !> ] ].

gen-poss-det-lxm := det-lxm &
[ SS [ LOC [ CAT [ HEAD.SPEC [ INDEX #index,
                               RESTR #restr1 ] ],
             CONT #cont,
             Q-STORE <! #cont & 
                        the-rel & 
                        [ INDEX #index,
                          RESTR [ FIRST.PROP.SOA.NUCL poss-rel &
                                                      [ POSS-ED #index ], 
                                  REST #restr1 ] ] !>,
             P-STORE <! !> ],
       WH <! !> ],
  ARG-ST < > ].

;;;JTB 07/18/01 - Trying to ditch all pumping rules.  Here eliminating
;;;phrase restrictions on COMPS and SUBJ and SPR.

p-lxm := const-lxm &
 [ SS.LOC [ CAT [ HEAD prep,
                  SPR < >,
                  COMPS < [ LOC [ CAT [ HEAD noun & [ CASE acc ],
                                        SPR < >,
                                        COMPS  < > ] ] ] > ] ] ].

;;;JTB 07/10/01 marking one shouldn't have a subject, predicative one
;;;should.  07/24/01 Hoping to ditch these two types and make
;;;predicative ones out of non-predicative ones.

mkp-lxm := p-lxm & str-intr &
 [ SS.LOC [ CAT [ HEAD [ PRED false,
                         FORM mkp-pform ],
                  SUBJ < >,
                  COMPS < [ LOC.CONT #cont ] > ],
            CONT #cont ] ].

pdp-lxm := p-lxm & 
 [ SS [ WH <! !>,
        LOC [ CAT [ HEAD [ PRED true,
                           FORM pdp-pform ],
                    SUBJ < synsem & [ LOC [ CAT [ HEAD noun ],
                                            CONT.INDEX #index,
                                            Q-STORE <! !>,
                                            P-STORE <! !> ] ] > ], 
              CONT soa & [ NUCL.ARG #index ] ] ] ].

comp-lxm := const-lxm &
 [ SS [ LOC.CAT [ HEAD comp,
                  SUBJ < >, 
                  SPR < > ],
        WH <! !> ] ].

;;;JTB 08/18/01 - Adjectives will be lexically specified to be
;;;predicative and the non-predicative ones will be derived via
;;;lexical rule at the morphological phase.  They will all, by
;;;default, have SPR values as well although these may be ditched by
;;;pumping rule.

adj-lxm := const-lxm &
 [ SS.LOC [ CAT [ HEAD adj & [ PRED true,
                               FORM normal,
                               DEG /l #deg ],
                  SUBJ < synsem & [ LOC [ CAT.HEAD noun,
                                          CONT.INDEX #index,
                                          Q-STORE <! !>,
                                          P-STORE <! !> ] ] >,
                  SPR /l < [ LOC.CAT.HEAD det & [ DEG #deg ] ] >,
                  COMPS /l < > ],
            CONT soa & [ NUCL.ARG #index ],
            Q-STORE <! !> ] ].

;;; CCB - this is just a quick definiton.  Needs to be fixed.

adv-lxm := const-lxm &
 [ SS.LOC [ CAT [ HEAD adv,
                  SUBJ < >,
                  SPR < >,
                  COMPS < > ],
            CONT soa ] ].

pol-adv-lxm := adv-lxm & 
[ SS [ SLASH <! !>,
       WH <! !>,
       LOC [ CAT.HEAD.MOD < >,
             Q-STORE <! !>,
             P-STORE <! !> ] ] ].


;;; <<< >>> ARGUMENT SELECTION

; no-arguments (no-args)
no-args := lexeme &
[ ARG-ST < > ].

; intransitive (intr)
intr := lexeme &
[ ARG-ST < [ LOC.CAT.HEAD.PRED /l false ], ... > ].

; strict-intransitive (str-intr)
str-intr := intr &
[ ARG-ST < [ LOC.CAT.HEAD.PRED /l false ] > ].

; intransitive-xcomp (intr-xcomp)
intr-xcomp := intr &
[ ARG-ST < [ LOC.CAT.HEAD.PRED /l false ], 
           [ LOC.CAT.HEAD.PRED /l false ] > ].

; transitive (tran)
tran := lexeme &
[ ARG-ST < [ LOC.CAT.HEAD.PRED /l false ], 
           [ LOC.CAT.HEAD.PRED /l false ], ... > ].

; strict-transitive (str-tr)
str-tr := tran &
[ ARG-ST < synsem, synsem > ].

; transitive-xcomp (tran-xcomp)
tran-xcomp := tran &
[ ARG-ST < synsem, synsem, synsem & [ LOC.CAT.HEAD.PRED /l false ]> ].

;;;JTB 07/29/01 - Added <! !> constraints to prevent extra
;;;amalgamation.  02/02/02 - All of this subsumed under pro-ss now.

; subject-control (s-con)
s-con := intr-xcomp &
[ ARG-ST < [ LOC [ CONT [ INDEX #1 ] ] ], 
           [ LOC.CAT [ SUBJ < pro-ss & [ LOC.CONT.INDEX #1 ] >,
                       COMPS < > ] ] > ].

;;;JTB 02/16/01 - Changed supertype to intr-xcomp instead of lexeme.
;;;Why was it lexeme?

; subject-raising (s-rais)
s-rais := intr-xcomp &
[ SS.LOC.CAT.SUBJ < #2 >,
  ARG-ST < #2 & [ LOC [ CAT #1 & [ HEAD.PRED /l false ],
                        CONT #3 ] ], 
           [ LOC.CAT [ SUBJ < [ LOC [ CAT #1,
                                      CONT #3,
                                      Q-STORE <! !>,
                                      P-STORE <! !> ],
                                SLASH <! !> ] >,
                       COMPS < >,
                       HEAD.PRED /l false ] ] > ].

;;; <<< >>> Maximal Subtypes of PART-OF-SPEECH and ARG-SELECTION

; strict-intransitive-verb (siv)
siv := non-auxv-lxm & str-intr.

;;; JTB 02/16/02 - Removing scv verbs from the heirarchy.  We're
;;;collapsing these into ctv verbs and leaving actual control
;;;(co-indexing) to other machinary.  I'll leave s-con in for control
;;;adjectives but that may go, too.

; subject-control-verb (scv)
;scv := non-auxv-lxm & s-con.

; subject-raising-verb (srv)
srv := non-auxv-lxm & s-rais.

; PP-argument (prep-arg)

prep-arg := lexeme &
[ ARG-ST < [ LOC.CAT.HEAD.PRED /l false ], 
           [ LOC.CAT [ HEAD prep & [ PRED false,
                                     FORM mkp-pform ],
                       SPR < >,
                       SUBJ < >,
                       COMPS < > ] ] > ].

; NP-transitive-argument (NP-trans-arg) - Added by CCB 9/9/99
NP-trans-arg := tran &
[ ARG-ST < synsem, [ LOC.CAT [ HEAD noun & [ CASE acc],
                               SPR < >,
                               COMPS < > ] ] > ].

; ditransitive-argument (ditrans-arg) - Added by CCB 9/9/99
ditrans-arg := lexeme &
[ ARG-ST < [ LOC.CAT.HEAD.PRED /l false ], 
           [ LOC.CAT.HEAD.PRED /l false ], 
           [ LOC.CAT.HEAD.PRED /l false ] > ].

; dative-argument (dt-arg) - Added by CCB 9/9/99
dt-arg := ditrans-arg &
[ ARG-ST < synsem, [ LOC.CAT [ HEAD noun & [ CASE acc],
                               SPR < >,
                               COMPS < > ] ], 
                   [ LOC.CAT [ HEAD noun & [ CASE acc],
                               SPR < >,
                               COMPS < > ] ] > ].

; PP-ditransitive (ptv-arg) - Added by CCB 9/9/99
ptv-arg :=  ditrans-arg &
[ ARG-ST < synsem, [ LOC.CAT [ HEAD noun & [ CASE acc],
                               SPR < > ] ],
                   [ LOC.CAT [ HEAD prep & [ PRED false,
                                             FORM mkp-pform ],
                               SPR < >,
                               SUBJ < >,
                               COMPS < > ] ] > ].

; PP-intransitive-verb (piv)
piv := non-auxv-lxm & prep-arg.

; strict-transitive-verb (stv)
stv := non-auxv-lxm & NP-trans-arg.

;;;JTB 02/02/02 - Removed CONT proposition restriction since these
;;;might form outcomes as well.  This is, of course, assuming that
;;;"ctv" is supposed to be for things taking CPs.

;;;JTB 02/15/02 - Ditched form finite and SUBJ <>

ctv := non-auxv-lxm & str-tr &
[ ARG-ST < synsem, [ LOC [ CAT [ HEAD verbal & [IC false],
                                 SPR < >,
                                 COMPS < > ] ] ] > ].

; dative-verb (dtv)
dtv := non-auxv-lxm & dt-arg.

; PP-transitive-verb (ptv)
ptv := non-auxv-lxm & ptv-arg.

;;; <<>> Adjective Lexeme types.

; strict-intransitive-adjective (sia)
sia := adj-lxm & str-intr.

; PP-intransitive-adjective (pia)
pia := adj-lxm & prep-arg.

; strict-transitive-adjective (sta)
sta := adj-lxm & str-tr.

; subject-raising-adjective (sra)
sra := adj-lxm & s-rais.

; subject-control-adjective (sca)
sca := adj-lxm & s-con.

;;;JTB - 07/13/01 finding commonality in wh words.  All CAT features
;;;but HEAD are common, as well as SLASH, REL, DTRS.

wh-lxm:=inflected-lexeme+amalg &
[ SS [ LOC [ CAT [ SUBJ < >,
                   SPR < >,
                   COMPS < > ], 
	     CONT scope-obj],
       SLASH <! !>,
       REL <! !> ],
  ARG-ST < >,        
  DTRS < inflected-lexeme > ].

;;;Exclamative vs. non-exclamative.  All exclamatives are determiners.

wh-lxm-nexcl:=wh-lxm &
[ SS.LOC.CONT #1 & param,
  SS.LOC.P-STORE <! #1 !> ].

wh-lxm-excl:=wh-lxm & wh-det-lxm &
[ SS.LOC.CONT unusual-rel & #1,
  SS.WH <! #1 !> ].

;;; Noun vs. determiner vs. possessive determiner wh-lxms

;;;JTB 08/18/01 - Removed constraint [ AGR ref-index ]

wh-n-lxm:=wh-lxm &
[ SS.LOC.CAT.HEAD noun & [ FORM normal,
	        	   ANA false,
                           MOD < > ],
  SS.LOC.CONT [ INDEX #index,
                RESTR < [ PROP.SOA.NUCL.ARG #index ] > ],
  SS.LOC.Q-STORE <! !> ].

wh-det-lxm := det-lxm &
[ SS.LOC [ CAT.HEAD.SPEC /l [ INDEX #index,
                              RESTR #restr ],
           CONT #cont & /l [ INDEX #index,
                             RESTR #restr ],
           Q-STORE <! !>,
           P-STORE <! #cont !> ] ].

wh-poss-det-lxm := det-lxm &
[ SS [ LOC [ CAT [ HEAD [ DEG true,
                          SPEC [ INDEX #index,
                                 RESTR #restr1 ] ] ],
             CONT param & [ INDEX #ind2, 
                            RESTR < [ PROP.SOA.NUCL person-rel &
                                       [ ARG #ind2 ] ] > ],
             Q-STORE <! the-rel & [ INDEX #index,
                                    RESTR [ FIRST.PROP.SOA.NUCL poss-rel &
                                             [ POSS-ER #ind2,
                                               POSS-ED #index ], 
                                            REST #restr1 ] ] !> ] ] ].

;;; Focused vs. non-focused in the non-exclamatives

wh-lxm-foc:=wh-lxm-nexcl &
[ SS.LOC.CONT.FOC true,
  SS.WH <! !> ].

wh-lxm-unfoc:=wh-lxm-nexcl &
[ SS.LOC.CONT #1 & [ FOC false ],
  SS.WH <! #1 !> ].

;;; Maximal types

wh-n-lxm-unfoc:=wh-n-lxm & wh-lxm-unfoc.
wh-n-lxm-foc:=wh-n-lxm & wh-lxm-foc.
wh-det-lxm-unfoc:=wh-det-lxm & wh-lxm-unfoc.
wh-det-lxm-foc:=wh-det-lxm & wh-lxm-foc.

wh-poss-det-lxm-foc := wh-poss-det-lxm & wh-lxm-foc.
wh-poss-det-lxm-unfoc := wh-poss-det-lxm & wh-lxm-unfoc.

;;;JTB 07/20/01 - Put these here for now.  These are supertypes of
;;;amalgamation rules.  Now split between soa and scope-obj since
;;;things with scope-objects do different things with their Q-STORE
;;;amalg (namely, determiners introduce quantifiers and thus do extra
;;;stitching, although complementizers don't get amalgamated anymore.

inflected-lexeme+amalg-0 := inflected-lexeme+amalg &
[ SS [ SLASH <! !>,
       WH <! !>,
       LOC [ P-STORE <! !> ] ],
  ARG-ST < >,
  DTRS < inflected-lexeme+ARP > ].

inflected-lexeme+amalg-1 := inflected-lexeme+amalg &
 [ SS [ SLASH #slash,
        WH #wh,
        LOC.P-STORE #store ],
  ARG-ST < [ SLASH #slash,
             WH #wh,
             LOC.P-STORE #store ] >,
  DTRS < inflected-lexeme+ARP > ].

inflected-lexeme+amalg-2 := inflected-lexeme+amalg &
[ SS.LOC.P-STORE [ LIST #store_1,
                   LAST #store_last ], 
 ARG-ST < [ LOC.P-STORE [ LIST #store_1,
                          LAST #store_2 ] ], [ LOC.P-STORE [ LIST #store_2,
                                                             LAST #store_last ] ] >,
 SS.SLASH [ LIST #slash_1,
            LAST #slash_last ], 
 ARG-ST < [ SLASH [ LIST #slash_1,
                    LAST #slash_2 ] ], [ SLASH [ LIST #slash_2,
                                                 LAST #slash_last ] ] >,
 SS.WH [ LIST #wh_1,
         LAST #wh_last ], 
 ARG-ST < [ WH [ LIST #wh_1,
                 LAST #wh_2 ] ], [ WH [ LIST #wh_2,
                                        LAST #wh_last ] ] >,
  DTRS < inflected-lexeme+ARP > ].


inflected-lexeme+amalg-3 := inflected-lexeme+amalg &
[ SS.LOC.P-STORE [ LIST #store_1,
                 LAST #store_last ], 
  ARG-ST < [ LOC.P-STORE [ LIST #store_1,
                         LAST #store_2 ] ], [ LOC.P-STORE [ LIST #store_2,
                                                          LAST #store_3 ] ], [ LOC.P-STORE [ LIST #store_3,
                LAST #store_last ] ] >,
 SS.SLASH [ LIST #slash_1,
            LAST #slash_last ], 
 ARG-ST < [ SLASH [ LIST #slash_1,
                    LAST #slash_2 ] ], [ SLASH [ LIST #slash_2,
                                                 LAST #slash_3 ] ], [ SLASH [ LIST #slash_3,
                                                                              LAST #slash_last ] ] >,
 SS.WH [ LIST #wh_1,
         LAST #wh_last ], 
 ARG-ST < [ WH [ LIST #wh_1,
                 LAST #wh_2 ] ], [ WH [ LIST #wh_2,
                                        LAST #wh_3 ] ], [ WH [ LIST #wh_3,
                                                               LAST #wh_last ] ] >,
  DTRS < inflected-lexeme+ARP > ].
        

inflected-lexeme+amalg-4 := inflected-lexeme+amalg &
[ SS.LOC.P-STORE [ LIST #store_1,
                 LAST #store_last ], 
  ARG-ST < [ LOC.P-STORE [ LIST #store_1,
                         LAST #store_2 ] ], [ LOC.P-STORE [ LIST #store_2,
                                                          LAST #store_3 ] ], [ LOC.P-STORE [ LIST #store_3, 
        LAST #store_4 ] ],  [ LOC.P-STORE [ LIST #store_4,
                                          LAST #store_last ] ]  >,
 SS.SLASH [ LIST #slash_1,
            LAST #slash_last ], 
 ARG-ST < [ SLASH [ LIST #slash_1,
                    LAST #slash_2 ] ], [ SLASH [ LIST #slash_2,
                                                 LAST #slash_3 ] ], [ SLASH [ LIST #slash_3,
           LAST #slash_4 ] ],  [ SLASH [ LIST #slash_4,
                                         LAST #slash_last ] ]  >,
 SS.WH [ LIST #wh_1,
         LAST #wh_last ], 
 ARG-ST < [ WH [ LIST #wh_1,
                         LAST #wh_2 ] ], [ WH [ LIST #wh_2,
                                                LAST #wh_3 ] ], 
    [ WH [ LIST #wh_3,
           LAST #wh_4 ] ],  [ WH [ LIST #wh_4,
                                       LAST #wh_last ] ]  >,
  DTRS < inflected-lexeme+ARP > ].

;;;JTB - generalized inflectional rules.  I'll add to this some stuff
;;;about predicative vs. non-predicative.

const-lxm_infl := inflected-lexeme &
[ ORTH #orth,
  DTRS < const-lxm & [ ORTH #orth,
                       NEEDS-AFFIX false ] > ].

;;;JTB 08/18/01 - These rules turn predicative elements (preps, adjs)
;;;into non-predicative ones.  Nouns are handled phrasally so that
;;;composition with quantifiers can happen first.

attrib-prep-lxm_infl := attrib-lxm_infl &
[ SS.LOC.CAT.HEAD prep, 
  DTRS < pdp-lxm > ].

attrib-adj-lxm_infl := attrib-lxm_infl &
[ SS.LOC.CAT.HEAD adj & /l [ SPEC.INDEX #index ],
  SS.LOC.CONT.NUCL.ARG /l #index, 
  DTRS < adj-lxm > ].

;;;JTB 10/17/01 - Changing attrib things so that their content is a
;;;scope-obj so that we can make them the semantic head of
;;;their hd-mod-phs.  This will allow us to do constituent negation
;;;with the same rule, with it acting as the semantic head.

attrib-lxm_infl := const-lxm_infl & 
[ SS.LOC [ CAT [ HEAD [ PRED false,
                        MOD < [ LOC [ CAT.HEAD noun,
                                      CAT.SPR < synsem >,
                                      CONT.INDEX #index ] ] > ],
                 SUBJ < > ],
           CONT.NUCL.ARG #index ],
  DTRS < [ SS.LOC.CAT.HEAD.PRED true ] > ].

;;; <<< AUXILIARY SYSTEM >>>

;;; JTB 09/02/01 - Auxiliaries: I'm going to partially adopt Warner
;;; (2000) in this approach.  He does everything in the type
;;; hierarchy.  I'll still use lexical rules to generate negated forms,
;;; but I'll use the type heirarchy to define all the types of negated and
;;; non-negated auxiliaries that show up.

;;;Four frames

neg-scoping := auxv-lxm.
modality := auxv-lxm.
vacuity := auxv-lxm.
contraction := auxv-lxm.

;;;Two scopings

wide-scope-lxm := neg-scoping.
narrow-scope-lxm := neg-scoping.

;;;Two contractions

nt-aux-lxm := contraction &
[ SS.LOC.CAT.HEAD.POL true ].

non-nt-aux-lxm := contraction.

;;; Two modalities.  Default on base requirement for modal complements
;;; only because of "ought to V" and "used to V", which might be
;;; lexical items (cf ??"Ought obviously to go" and ??"used obviously
;;; to go", also "Ought not go to the store", ??"Ought not to go to
;;; the store" and ?"Used not to go".  Not sure about these, maybe two
;;; of each: non-aux "ought" that takes an infinitival complement and
;;; aux "ought" that takes a base complement.  Also "Ought he go?"
;;; vs. *"Ought he to go?".  "Ought" could be [AUX -] except "He OUGHT
;;; to go".

non-modal-aux-lxm := modality.
modal-aux-lxm := modality &
[ SS.LOC.CAT.HEAD.FORM fin,
  SS.LOC.CONT r-soa,
  ARG-ST < [ LOC.CAT.HEAD.CASE nom ], [ LOC.CAT.HEAD.FORM /l base ] > ].

;;; Two semantic types.  Vacuous have no semantics, contentful do.
;;; The vacuous guys will ARP and amalg here, except for quantifiers which
;;; will be taken care of when negation is.

vacuous-aux-lxm := vacuity &
[ SS [ LOC [ CAT [ SUBJ < #subj >,
                   SPR < >,
                   COMPS < #comp > ],
             Q-STORE <! !>,
             P-STORE [ LIST #plist1, 
                       LAST #plist_last ] ],
       SLASH [ LIST #slash1, 
               LAST #slash_last ],
       WH [ LIST #wh1,
            LAST #wh_last ] ],
  ARG-ST < #subj & [ LOC [ CAT.HEAD.PRED false,
                           P-STORE [ LIST #plist1, 
                                     LAST #plist2 ] ],
                     SLASH [ LIST #slash1, 
                             LAST #slash2 ],
                     WH [ LIST #wh1, 
                          LAST #wh2 ] ],
           #comp & [ LOC [ P-STORE [ LIST #plist2, 
                                     LAST #plist_last ] ],
                     SLASH [ LIST #slash2, 
                             LAST #slash_last ],
                     WH [ LIST #wh2, 
                          LAST #wh_last ] ] > ].

cont-aux-lxm := vacuity.

;;;Subtypes:
;;;[Scope and Contraction]:

nt-wide-scope-lxm := wide-scope-lxm & nt-aux-lxm &
[ SS.LOC.CONT.NUCL neg-rel ].

nt-narrow-scope-lxm := narrow-scope-lxm & nt-aux-lxm &
[ SS.LOC.CONT.NUCL.SOA-ARG.NUCL neg-rel ].

non-nt-wide-scope-lxm := wide-scope-lxm & non-nt-aux-lxm.
non-nt-narrow-scope-lxm := narrow-scope-lxm & non-nt-aux-lxm.

;;;[Vacuity and Contraction]:

cont-nt-lxm := cont-aux-lxm & nt-aux-lxm &
[ SS.LOC.CONT.NUCL.SOA-ARG.NUCL.SOA-ARG #cont,
  ARG-ST < synsem, [ LOC.CONT #cont ] > ].

vacuous-nt-lxm := vacuous-aux-lxm & nt-aux-lxm &
[ SS.LOC.CONT [ QUANTS #quants,
                NUCL.SOA-ARG #cont ],
  ARG-ST < [ LOC.Q-STORE #quants ], 
           [ LOC.CONT #cont ] > ].

cont-non-nt-lxm := cont-aux-lxm & non-nt-aux-lxm.
vacuous-non-nt-lxm := vacuous-aux-lxm & non-nt-aux-lxm.

;;;[Scope and Contraction] and [Vacuity and Contraction]:

cont-nt-wide-scope-lxm := nt-wide-scope-lxm & cont-nt-lxm.
vacuous-nt-wide-scope-lxm := nt-wide-scope-lxm & vacuous-nt-lxm.
cont-nt-narrow-scope-lxm := nt-narrow-scope-lxm & cont-nt-lxm.
;;;No vacuous-narrow combos.

cont-non-nt-wide-scope-lxm := non-nt-wide-scope-lxm & cont-non-nt-lxm  &
[ SS.LOC.CONT.NUCL.SOA-ARG #cont,
  ARG-ST < synsem, [ LOC.CONT #cont ] > ].

vacuous-non-nt-wide-scope-lxm := non-nt-wide-scope-lxm & vacuous-non-nt-lxm  &
[ SS.LOC.CONT.NUCL #nucl,
  ARG-ST < synsem, [ LOC.CONT.NUCL #nucl ] > ].

cont-non-nt-narrow-scope-lxm := non-nt-narrow-scope-lxm & cont-non-nt-lxm.
;;;No vacuous-narrow combos.

;;; Maximal types (Just add modality):
;;; Modal auxiliaries:

wide-scope-modal-lxm := modal-aux-lxm & cont-non-nt-wide-scope-lxm.
narrow-scope-modal-lxm := modal-aux-lxm & cont-non-nt-narrow-scope-lxm.
nt-wide-scope-modal-lxm := modal-aux-lxm & cont-nt-wide-scope-lxm.
nt-narrow-scope-modal-lxm := modal-aux-lxm & cont-nt-narrow-scope-lxm.
;;;No vacuous modals.

;;;Helper Auxiliaries:

cont-wide-scope-aux-lxm := non-modal-aux-lxm & cont-non-nt-wide-scope-lxm. 
cont-nt-wide-scope-aux-lxm := non-modal-aux-lxm & cont-nt-wide-scope-lxm.
vacuous-wide-scope-aux-lxm := non-modal-aux-lxm & vacuous-non-nt-wide-scope-lxm.
vacuous-nt-wide-scope-aux-lxm := non-modal-aux-lxm & vacuous-nt-wide-scope-lxm.
;;;No narrow helpers.

;;; Copula, do, have auxiliaries.  Eventually I'll try to do real inflection.
;;; COPULA

copula := vacuous-aux-lxm &
[ ARG-ST < synsem, [ LOC.CAT.HEAD.PRED true ] > ].

fin-copula := copula & 
[ SS.LOC.CONT /l r-soa,
  SS.LOC.CAT.HEAD.FORM fin,
  ARG-ST < [ LOC.CAT.HEAD.CASE nom ], synsem > ].

non-nt-fin-copula := fin-copula & vacuous-wide-scope-aux-lxm.
nt-fin-copula := fin-copula & vacuous-nt-wide-scope-aux-lxm.

non-fin-copula := copula & vacuous-wide-scope-aux-lxm.

;;;DO

do-lexeme := vacuous-aux-lxm &
[ SS.LOC.CAT [ HEAD.PRED false ],
  ARG-ST < synsem, [ LOC.CAT [ HEAD.FORM base, COMPS < > ] ] >,
  DTRS < auxv-lxm > ].

fin-do-lexeme := do-lexeme &
[ SS.LOC.CONT /l r-soa,
  SS.LOC.CAT.HEAD.FORM fin,
  ARG-ST < [ LOC.CAT.HEAD.CASE nom ], synsem > ].

non-nt-fin-do-lexeme := fin-do-lexeme & vacuous-wide-scope-aux-lxm.
nt-fin-do-lexeme := fin-do-lexeme & vacuous-nt-wide-scope-aux-lxm.

non-fin-do-lexeme := do-lexeme & vacuous-wide-scope-aux-lxm.

do-lxm-unfoc := non-nt-fin-do-lexeme &
[ SS.LOC.CAT.HEAD [ AUX true ] ].

do-lxm-foc := non-nt-fin-do-lexeme &
[ SS.LOC.CAT.HEAD [ POL true ] ].

;;;HAVE

have-lxm := cont-wide-scope-aux-lxm &
[ SS.LOC.CONT.NUCL completed-rel,
  ARG-ST < synsem, [ LOC.CAT.HEAD.FORM pfp ] > ].

nt-have-lxm := cont-nt-wide-scope-aux-lxm &
[ SS.LOC.CONT.NUCL.SOA-ARG.NUCL completed-rel,
  ARG-ST < synsem, [ LOC.CAT.HEAD.FORM pfp ] > ].

;;; Lexical rules to handle auxiliaries.  While everyone else is
;;; inflecting, these guys get negation or not.  The rules are pretty
;;; specialized.  Contentful auxiliaries will become
;;; inflected-lexemes, vacuous ones will become inflected-lexeme+amalg
;;; since they do NOT amalg the normal way but inherit their verbal
;;; complement's quants.  This is complicated by the presence of not,
;;; so care is taken to make sure it's all right.  Assuming
;;; (currently) surface order scoping of quants and not, modulo scoping.

;;; Base type for contentful polar lexemes.

polar-lexeme := inflected-lexeme & 
[ SS.LOC [ CAT [ HEAD [ AUX true,
                        POL true ] ] ],
  ARG-ST < #1, pol-ss & [ LOC.CAT.HEAD adv,
                          LOC.CONT.NUCL pol-rel ], #2 >,
  DTRS < [ SS.LOC [ CAT [ HEAD [ AUX true,
                                 POL false ] ] ],
           ARG-ST < #1, #2 > ] > ].

;;; Base type for vacuous polar lexemes.

polar-lexeme+amalg := inflected-lexeme+amalg & 
[ SS.LOC [ CAT [ HEAD [ AUX true,
                        POL true ],
                 SUBJ < #1 >,
                 COMPS < #pol, #2 > ] ],
  ARG-ST < #1, #pol & pol-ss & [ LOC.CAT.HEAD adv,
                                 LOC.CONT.NUCL pol-rel ], #2 >,
  DTRS < [ SS.LOC [ CAT [ HEAD [ AUX true,
                                 POL false ] ] ],
           ARG-ST < #1, #2 > ] > ].

;;; Polar wide scoping contentful non-contracted lexemes.  Just negate
;;; the semantics of the daughter basically

wide-polar-lexeme := polar-lexeme &
[ SS.LOC.CONT.NUCL #pol-rel & [ SOA-ARG #a-soa ],
  ARG-ST < synsem, [ LOC.CONT.NUCL #pol-rel ], synsem >,
  DTRS < cont-non-nt-wide-scope-lxm & [ SS.LOC.CONT #a-soa ] > ].

;;; Non-polar wide scoping contentful non-contracted lexemes.  Just
;;; move up the heirarchy no sweat.

wide-non-pol-lexeme := inflected-lexeme &
[ DTRS < cont-non-nt-wide-scope-lxm > ].

;;; Polar narrow scoping contentful non-contracted lexemes.  Fix the
;;; (unfixed) semantics as AUX(NOT(COMP(...))).

narrow-polar-lexeme := polar-lexeme &
[ SS.LOC.CONT #a-soa & [ NUCL.SOA-ARG.NUCL #pol-rel & 
                          [ SOA-ARG #c-soa ] ],
  ARG-ST < synsem, [ LOC.CONT.NUCL #pol-rel ], [ LOC.CONT #c-soa ] >,
  DTRS < cont-non-nt-narrow-scope-lxm & [ SS.LOC.CONT #a-soa ] > ].

;;; Non-polar narrow scoping contentful non-contracted lexemes.  Fix
;;; the (unfixed) semantics as AUX(COMP(...)).

narrow-non-pol-aux-lexeme := inflected-lexeme &
[ SS.LOC.CONT #cont & [ NUCL.SOA-ARG #c-soa ],
  ARG-ST < synsem, [ LOC.CONT #c-soa ] >,
  DTRS < cont-non-nt-narrow-scope-lxm & [ SS.LOC.CONT #cont ] > ].

;;; ALL contracted lexemes are fixed up just fine, so just move them
;;; to the next level.

nt-lexeme := inflected-lexeme &
[ DTRS < nt-aux-lxm > ].

;;; Polar wide scoping vacuous non-contracted lexemes.  Put subj
;;; quants above the not and comp quants below, and fix semantics as
;;; NOT(COMP(...)).

wide-vacuous-polar-lexeme := polar-lexeme+amalg &
[ SS.LOC.CONT [ QUANTS #quants,
                NUCL #pol-rel & [ SOA-ARG #a-soa ] ],
  ARG-ST < [ LOC.Q-STORE #quants ], 
           [ LOC.CONT.NUCL #pol-rel ], 
           [ LOC.CONT #a-soa ] >,
  DTRS < vacuous-non-nt-wide-scope-lxm > ].

;;; Non-polar wide scoping vacuous non-contracted lexemes.  Amalgamate
;;; the quants as usual and do nothing else.

wide-vacuous-non-polar-lexeme := inflected-lexeme+amalg &
[ SS.LOC.CONT [ QUANTS [ LIST #qlist1,
                         LAST #qlist_last ] ],
  ARG-ST < [ LOC.Q-STORE [ LIST #qlist1,
                           LAST #qlist2 ] ], 
           [ LOC.CONT.QUANTS [ LIST #qlist2,
                               LAST #qlist_last ] ] >,
  DTRS < vacuous-non-nt-wide-scope-lxm > ].