;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 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: types.tdl ;;; Purpose: Contains basic type hierarchy. See semantics.tdl, lex-types.tdl, ;;; and constructions.tdl for further type hierarchies. ;;; Last modified: 05/11/02 by John Beavers (JTB) ;;; Notes: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; tree_node_label := *top* & [ NODE sign ]. label := lex-sign & [ LABEL-NAME string ]. ;; see lkbpatches meta := sign & [ META-PREFIX string, META-SUFFIX string ]. feat-struc := *top*. ; I've expanded the feature NHD-DTRS to DTRS which contains all the ;sign's daughters and coindexes the head daughter with the HD-DTR ;feature where applicable. Generalizing the feature from being a ;constraint on phrase to being a constraint on all signs allows the ;elimination of the feature STEM from word. ;;;JTB 07/18/01 - Upgraded DTRS to list-of-signs, was previously just ;;;a list. sign := feat-struc & [ ROOT /l false, ORTH *list-of-strings*, SS synsem, DTRS list-of-signs ]. synsem := feat-struc & [ LOC local, SLASH *list-of-locals*, WH *list-of-scope-objs*, REL *diff-list* ]. ;;;JTB 07/18/01 Testing to see if forcing STORE to be empty will have ;;;any effect on dir-is-int-cl and rep-int-cl rules from applying ;;;vacuously to undefined lists. It does but this constraint must go ;;;on "word" or something like it, maybe "expression". Maybe all ;;;lists should default to empty unless specified otherwise? local := feat-struc & [ CAT category, CONT sem-obj, P-STORE *list-of-scope-objs*, Q-STORE *list-of-quants* ]. category := feat-struc & [ HEAD pos, SUBJ list-of-synsems, SPR list-of-synsems, COMPS list-of-synsems ]. ;;;JTB and especially IAS 07/10/01 We're adding a comps < > to ;;;phrase-cat as a lark. ;;;JTB 07/18/01 - Wait, do we NEED a type "phrase-cat"? Why not put ;;;these restrictions on phrase? Funny, that's how the book does it. ;phrase-cat := category & [ COMPS < > ]. ;phrase-cat := category. canon-ss := synsem. noncanon-ss := synsem. gap-ss := noncanon-ss & [ LOC #1, SLASH ]. pro-ss := noncanon-ss & [ SLASH , LOC [ P-STORE , Q-STORE , CAT.HEAD.CASE acc ] ]. ;;; CCB - added the type elip-ss, to mark elliptical constituents. ;;;This has the effect of blocking extraction on those elements since the ;;;type ellip-ss says SLASH explicitly. ;;; JTB 09/21/01 - Adding some sort of cheap semantics, a "prev-rel" ;;; type of relation. ;;;JTB 07/18/01 - Trying to ditch phrase-cat ellip-ss := noncanon-ss & [ SLASH , WH , LOC [ CAT.COMPS < >, P-STORE , Q-STORE , CONT [ NUCL prev-rel, QUANTS ] ] ]. pol-ss := noncanon-ss & [ LOC.CAT.HEAD.MOD < > ]. ;;; <<< >>> SUBTYPES OF SIGN ;;;JTB 7/18/01 - Upgrading daughters of phrases to ;;;list-of-expressions. If this trick works then we won't need to ;;;specificy expression of any daughters of phrases in the entries below. ;;;JTB 07/18/01 - Here's a joke: expression:=sign. ;;;This is the new type to be supertypes of words and phrases (but not ;;;lexemes) for selectional purposes. phrase := expression & [ SS.LOC.CAT [ COMPS < > ], DTRS ne-list-of-expressions ]. lex-sign := sign & [ NEEDS-AFFIX boolean, ARG-ST list-of-synsems ]. ; The Argument Realization Principle has been incorporated into type ; inflected lexeme rather than word, because SLASHed constituents are ; not furmulated into the principle. Instead ARG-ST is the append of ; SUBJ, SPR and COMPS. This neglects extraction (SLASH) which will be ; formulated as non-branching grammar rules, which happen between type ; inflected-lexeme and type word. #| removing the difference list stitching approach for the Argument Realization Principle. I'm instead going to do it using a non-branching rule. SS /l #ss & [ LOC.CAT [ ARG-ST [ LIST #first, LAST #last ], SUBJ [ LIST #first, LAST #second ], SPR [ LIST #second, LAST #third ], COMPS [ LIST #third, LAST #last ] ] ], |# ;;;JTB 08/18/01 - These types are for the no-man's-land between ;;;lexemes and words ;;;JTB 07/18/01 - After moving ARG-ST to lex-sign, we need to be ;;;explicit about the inheritence between the different lexical ;;;levels, so I've added specific movement of ARG-ST. Excepting the ;;;default constraints, I wonder if we can unify these a bit? lexeme := lex-sign. ;;;Lexemes that have been inflected/morphologically set inflected-lexeme := lex-sign & [ NEEDS-AFFIX /l false, SS /l #ss, ARG-ST /l #arg, DTRS < [ SS /l #ss, ARG-ST /l #arg ] > ]. ; lexeme ;;;Lexemes that have had ARP applied to them inflected-lexeme+ARP := lex-sign & [ NEEDS-AFFIX false, ORTH #orth, SS /l #ss & [ LOC.CAT.SUBJ list-of-synsems-wh-none ], ARG-ST #arg, DTRS < [ ORTH #orth, SS /l #ss, ARG-ST #arg ] > ]. ; inflected-lexeme & ;;;Lexemes that have had amalgamation (SLASH, Q-STORE, P-STORE, WH) ;;;applied to them inflected-lexeme+amalg := lex-sign & [ NEEDS-AFFIX false, ORTH #orth, SS /l #ss, ARG-ST /l #arg, DTRS < [ ORTH #orth, SS /l #ss, ARG-ST /l #arg ] > ]. ;;;Words that have had gapped arguments removed from COMPS and SUBJ word := lex-sign & expression & [ NEEDS-AFFIX false, ORTH #orth, SS /l #ss, ARG-ST /l #arg, DTRS < [ ORTH #orth, SS /l #ss, ARG-ST /l #arg ] > ]. ;inflected-lexeme+slash_amalg & punctuation := word & [ SS [ WH , SLASH , LOC [ CONT proposition, CAT [ COMPS < >, SUBJ < >, SPR < >, HEAD punct ], Q-STORE , P-STORE ] ], ARG-ST < > ]. ;;; <<< >>> PARTS OF SPEECH ;;;JTB 06/27/01 is ANA appropriate for type pos? Shouldn't it just be ;;;in nominals? I'm moving it to nominal-cat. pos := feat-struc & [ FORM form-cat, PRED boolean ]. mod-type := feat-struc & [ MOD *list* ]. deg-type := feat-struc & [ DEG boolean ]. spec-type := feat-struc & [ SPEC sem-obj ]. ;;;JTB 07/23/01 - This would be a mighty useful type for dealing with ;;;things that are predicative and thus violate certain constraints: ;pred-type := feat-struc & ;[ PRED boolean ]. ;;;Features for verbal are described in section 4.4 (Features for ;;;Verbals) in Ginzburg and Sag. Rather than adding the additional ;;;feature VFORM I've simply constrained the FORM feature from pos to be ;;;type vform. The feature INF serces to distinguish infinitivals, ;;;i.e. the verb 'to' and the copmlementizer 'for', which are [INF +] ;;;from all other verbs and compementizers which are [INF -]. (Ginzburg ;;;and Sag). ;;;JTB 08/19/01 - Removed INF as it's not in the book and we don't ;;;need it. Added POL to verbs, removed NEG. ;;; JTB 09/21/01 - punct for punctuation. punct := pos. verbal := pos & mod-type & [ FORM vform, IC boolean ]. nonverbal := pos. verb := verbal & [ POL boolean, AUX boolean, INV boolean, MOD < > ]. comp := verbal & [ MODE < > ]. ;;;JTB 08/19/01 - To distinguish verbs from gerunds. v := verb. g := verb. ;;;I've added "topic" to the heirarchy to restrict what can be ;;;topicalized though the head-filler rule. topic := nonverbal. nominal-cat := topic & [ AGR agr-cat, ANA boolean ]. ;;;JTB 07/29/01 - Why the hell are these spec types? Nouns can't be ;;;determiners. Can they? I'm going to quietly remove this and put it ;;;in later if need be. noun := nominal-cat & mod-type & spec-type & [ CASE case, MOD /l < > ]. det := nominal-cat & deg-type & spec-type & [ COUNT boolean, PRED false ]. conj := nonverbal. adv := topic & mod-type. adj := nonverbal & mod-type & deg-type & spec-type. prep := nominal-cat & mod-type & [ FORM pform ]. ;;;In English, agreement is marked on nouns and determiners, but I've ;;;added it on prepositions because my binding theory implementation relys ;;;on PPs having AGR. ;;; <<< >>> AGREEMENT TYPES ;;;JTB 08/18/01 - I'm removing this indexing scheme for now, and ;;;making agreement purely syntactic and indicies simple types. ; referential-index (ref-index) ;ref-index := index. ; explitive-index (expl-index) ;expl-index := index. ;expl-there := expl-index. ;expl-it := expl-index. agr-cat := *value*. pl := agr-cat. sg := agr-cat. non-3sg := agr-cat. 1or3sg := sg. 2per := non-1sg. non-1sg := non-3sg. 1sg := 1or3sg & non-3sg. 1pl := non-1sg & pl. 2sg := 2per & sg. 2pl := 2per & pl. 3pl := non-1sg & pl. 3sg := 1or3sg & [ GEND gend ]. ;pl := 1pl & 2pl & 3pl. gend := *value*. fem := gend. masc := gend. neut := gend. ;;; <<< >>> CLAUSALITY ;;; CCB - Ivan's notes say that the SUBJ list on clause should be ;;;composed of noncan-ss. Why? ;;; CCB - Causing problems with the negation lexical rule. clause := phrase & [ SS [ LOC [ CAT.SUBJ list-of-noncanon-ss, CONT message ], WH ] ]. non-clause := phrase. ;;;JTB 02/16/02 - Changing verb to verbal in core-cl. Hope that don't ;;;screw anything up. ; core-clause (core-cl) core-cl := clause & [ SS.LOC.CAT [ HEAD verbal & [ FORM clausal, MOD < > ] ] ]. ;;;JTB 02/16/01 - Implementing root clauses as in chapter 7, p.267 ; root clause (root-cl) root-cl := core-cl & [ ROOT true, SS.LOC.CONT [ REPRISABLE false, SOA.NUCL.ILLOCUTIONER speaker ] ]. ; root imperative clause - this is new. We're going to make ; ns-imperatives be roots so as to avoid getting things like "I prefer ; leave" where leave is a G&S ns-imp-cl which has an outcome and gets ; selected for by prefer. imp-root-cl := root-cl & [ SS.LOC.CONT.SOA.NUCL order-rel ]. ; factive-clause (factive-cl) factive-cl := core-cl & [ SS.LOC [ CAT.HEAD [ IC false, FORM fin ], CONT fact & [ REPRISABLE false ] ] ]. #| ; relative-clause (rel-cl) rel-cl := clause & [ SS.LOC [ CAT [ HEAD [ IC false, INV false, MOD < [ HEAD noun ] > ] ], CONT fact ] ]. |# ;;; CCB - should decl-cl inherit from hd-ph, or should I add a HD-DTR type? ; declarative-clause (decl-cl) decl-cl := core-cl & hd-ph & [ SS.LOC.CONT austinian & [ SOA #1 ], HD-DTR [ SS.LOC [ CONT #1 ] ] ]. ; interrogative-clause (inter-cl) inter-cl := core-cl & [ SS.LOC.CONT question ]. ;;; The headed-interrogative-clause is constrained by the Wh-Question ;;;Retrieval principle, which requires that the P-STORE value of a ;;;hd-int-cl be the head daughter's P-STORE value, minus some set of ;;;indicies that are included in the clause's PARAM's set. (Note that ;;;the set of retrieved indicies can be the empty set). ;;; I'm treating the P-STORE and the PARAMS as *diff-lists* rather than ;;;sets, so might be making different predictions. CCB - like what? ; headed-interrogative-clause (hd-int-cl) hd-int-cl := inter-cl & hd-ph. #| & [ SS.LOC [ P-STORE [ LIST #first, LAST #last ], CONT [ PARAMS [ LIST #middle, LAST #last ] ] ], HD-DTR.SS.LOC.P-STORE [ LIST #first, LAST #middle ] ]. |# canon-int-cl := hd-int-cl & [ SS.LOC.CAT.HEAD [ IC #1, INV #1 ] ]. ;;; CCB - in-situ constructions are headed by a finite indicative verb ;;;that cannot occur as the complement of an emedding predicate. Subtype ;;;of hd-only-ph (a non-branching headed phrasal type). is-int-cl := hd-int-cl & hd-only-ph & [ SS.LOC.CAT.HEAD verb & [ FORM fin, IC true ] ]. imp-cl := core-cl & hd-only-ph & [ SS.LOC.CONT outcome ]. ; exclamative-clause (excl-cl) excl-cl := core-cl & [ SS.LOC.CONT fact ]. ;;; <<< >>> HEADEDNESS ;;;I've collapsed the Head Feature Principle, the Valence Principle, ;;;and the Semantic Inheritance Principle into a single default ;;;unification constraint on hd-ph. ;;; CCB - I need to be composing the ORTH on all of these phrasal ;;;construtions, so that it inherits from the words to the phrases. ;;;Maybe I should put it in consturctions.tdl? hd-ph := phrase & [ SS /l #1, HD-DTR expression & [ SS /l #1 ] ]. ; hd-punct-phrase (hd-punct-ph) hd-punct-ph := hd-ph & [ HD-DTR #1, DTRS < #1, punctuation > ]. ; head-complement-phrase (hd-comp-ph) hd-comp-ph := hd-ph & [ HD-DTR #1, DTRS < word & #1, ... > ]. nv-hd-comp-ph := hd-comp-ph & [ HD-DTR [ SS.LOC.CAT.HEAD nonverbal ] ]. ;;;JTB 07/18/01 - Trying to eliminate phrasal restrictions and zero ;;;level pumping rules hd-comp-ph-1 := nv-hd-comp-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ] > ]. hd-comp-ph-2 := nv-hd-comp-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ], #2 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ], [ SS #2 ] > ]. ; verb-phrase (vb-ph) vb-ph := hd-comp-ph & [ HD-DTR [ SS.LOC.CAT.HEAD verb & [ AUX #1, POL #1 ] ] ]. vb-ph-1 := vb-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ] > ]. vb-ph-2 := vb-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ], #2 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ], [ SS #2 ] > ]. vb-ph-3 := vb-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ], #2 & [ LOC.CAT [ SPR < >, COMPS < > ] ], #3 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ], [ SS #2 ], [ SS #3 ] > ]. ; elliptical-verb-phrase (ellip-vp) ellip-vp := hd-comp-ph & [ HD-DTR.SS.LOC.CAT [ HEAD verb & [ AUX true ] ] ]. ellip-vp-0 := ellip-vp & [ HD-DTR.SS.LOC.CAT.COMPS < ellip-ss >, DTRS < expression > ]. ellip-vp-1 := ellip-vp & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ], ellip-ss >, DTRS < expression, [ SS #1 ] > ]. ; complementizer-phrase (cp-ph) cp-ph := hd-comp-ph & [ HD-DTR [ SS.LOC.CAT.HEAD comp ] ]. cp-ph-1 := cp-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ] > ]. cp-ph-2 := cp-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT [ SPR < >, COMPS < > ] ], #2 & [ LOC.CAT [ SPR < >, COMPS < > ] ] >, DTRS < expression, [ SS #1 ], [ SS #2 ] > ]. ;;; CCB - Note the cleverness here with this unifying with the ;;;constraint on clause that the SUBJ be a list of non-canonical synsems. ;;;An e-list is... ; head-subject-phrase (hd-subj-ph) hd-subj-ph := hd-ph & [ SS.LOC [ CAT [ SUBJ < > ] ], HD-DTR #1 & [ SS.LOC.CAT [ SUBJ < #2 >, SPR < > ] ], DTRS < [ SS #2 ], #1 > ]. ;;;JTB 07/19/01 Added SPEC restrictions to make spec stuff come out ;;;right. ;;;JTB 09/28/01 Moved SS.LOC.CONT #cont out of HD-DTR and into ;;;hd-spr-ph, where it unified in anyway by hd-ph. This is allow for ;;;the possibility of this unification with the SPR semantics to ;;;override that of the verbal semantics. ; head-specifier-phrase (hd-spr-ph) hd-spr-ph := hd-ph & binary-construction & [ SS.LOC [ CAT [ SPR < > ] ], SS.LOC.CONT #cont, HD-DTR #1 & [ SS.LOC.CAT.SPR < #2 & [ LOC.CAT.HEAD.SPEC #cont ] > ], DTRS < [ SS #2 ], #1 > ]. ; subject-auxilary-inversion-phrase (sai-ph) sai-ph := hd-ph & [ SS.LOC.CAT.SUBJ < >, HD-DTR #1 & [ SS.LOC.CAT [ HEAD verb & [ INV true, AUX true ], SUBJ < #2 > ] ], DTRS < word & #1, [ SS #2 ], ... > ]. ; elliptical sai-ph. sai-ph-0 := sai-ph & [ HD-DTR.SS.LOC.CAT.COMPS < ellip-ss >, DTRS < expression, [ SS.LOC.CAT.SPR < > ] > ]. sai-ph-1 := sai-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 >, DTRS < expression, [ SS.LOC.CAT.SPR < > ], [ SS #1 & [ LOC.CAT.SPR < > ] ] > ]. ;;;CCB - Is a two placed COMPS construction ever needed with sai-ph? ;;;Do auxv-lxms ever have more than one complement? -- Yes, in the case ;;;of the dummy-subject "be". sai-ph-2 := sai-ph & [ HD-DTR.SS.LOC.CAT.COMPS < #1 & [ LOC.CAT.SPR < > ], #2 & [ LOC.CAT.SPR < > ] >, DTRS < expression, [ SS.LOC.CAT.SPR < > ], [ SS #1 ], [ SS #2 ] > ]. sai-ph-3 := sai-ph & [ HD-DTR.SS.LOC.CAT.COMPS < >, DTRS < expression, [ SS.LOC.CAT.SPR < > ] > ]. ; head-adjunct-phrase (hd-adj-ph) hd-adj-ph := hd-ph & non-clause & [ HD-DTR #1 & [ SS #2 ], DTRS < #1, [ SS.LOC.CAT.HEAD [ MOD < #2 > ] ] > ]. ; head-filler-phrase (hd-fill-ph) hd-fill-ph := hd-ph & [ SS [ LOC.CAT.HEAD verb, SLASH [ LIST #rest, LAST #last] ], HD-DTR #1 & [ SS.SLASH [ LIST *cons* & < #2 . #rest>, LAST *null* & #last ] ], DTRS < [ SS [ LOC #2, SLASH ] ], #1 > ]. ;;; CCB - 5/22/00 - added the hd-modifier-ph ;;; JTB - 8/18/01 - Modified post and pre head modifiers. They now do ;;;all of their own stitching and inheritence. This is because the ;;;stitching on the various lexical items was being done at lexeme to ;;;word time and when the modifier phrases were being built more ;;;stitching needed to be done that wasn't allowed for in the tight ;;;diff-lists already built previously. The previous default had been ;;;that hd-ph was a supertype but it insisted, e.g., that Q-STORE of ;;;the HD-DTR and mother were identical. But the mother's Q-STORe ;;;also needed to be identical to the stitch of the modifier and ;;;modifiee (sp?), which is often a contradiction. Default ;;;constraints are of no help because sometimes there are (utterly ;;;erroneous) ways of succeeding in achieving the all the required ;;;unification but it always screwed something up. By removing the ;;;hd-ph supertype and doing it by hand we avoid the problem. ;;;JTB 10/17/01 - Changing these to simply inherit the semantics of ;;;the mod as the semantic head. This will allow them to take care of ;;;adverbs and stuff also, especially constituent negation. post-hd-mod-ph := binary-construction & [ SS [ LOC [ CAT #cat, CONT [ INDEX #index, RESTR [ FIRST.PROP.SOA #soa, REST #restr ] ], Q-STORE [ LIST #qlist1, LAST #qlist_last], P-STORE [ LIST #plist1, LAST #plist_last ] ], SLASH #slash, WH #wh ], DTRS < [ SS #mod & [ LOC [ CAT #cat, CONT [ RESTR #restr, INDEX #index ], Q-STORE [ LIST #qlist1, LAST #qlist2 ], P-STORE [ LIST #plist1, LAST #plist2 ] ], SLASH #slash, WH #wh ] ], [ SS [ LOC [ CAT [ HEAD nominal-cat & [ PRED false, MOD < #mod > ], SPR < >, SUBJ < >, COMPS < > ], CONT #soa, Q-STORE [ LIST #qlist2, LAST #qlist_last], P-STORE [ LIST #plist2, LAST #plist_last ] ], SLASH , WH ] ] > ]. ;;; CCB - 5/22/00 - added the hd-modifier-ph ; pre-head-modifier-phrase (pre-hd-mod-ph) ;;; Removing adj constraint on DTRS.FIRST ... HEAD. ;;; Removing also content, which will be fixed for each of two types. pre-hd-mod-ph := binary-construction & [ SS [ LOC [ CAT #cat, Q-STORE [ LIST #qlist1, LAST #qlist_last], P-STORE [ LIST #plist1, LAST #plist_last ] ], SLASH #slash, WH #wh ], DTRS < [ SS [ LOC [ CAT [ HEAD [ PRED false, MOD < #mod > ], SPR < >, SUBJ < >, COMPS < > ], Q-STORE [ LIST #qlist2, LAST #qlist_last], P-STORE [ LIST #plist2, LAST #plist_last ] ], SLASH , WH ] ], [ SS #mod & [ LOC [ CAT #cat, Q-STORE [ LIST #qlist1, LAST #qlist2 ], P-STORE [ LIST #plist1, LAST #plist2 ] ], SLASH #slash, WH #wh ] ] > ]. ;;; For adjectives when modifying things with scope-objs pre-hd-adj-mod-ph := pre-hd-mod-ph & [ SS.LOC.CONT [ INDEX #index, RESTR [ FIRST.PROP.SOA #soa, REST #restr ] ], DTRS < [ SS.LOC.CONT #soa, SS.LOC.CAT.HEAD.DEG false ], [ SS.LOC.CONT [ RESTR #restr, INDEX #index ] ] > ]. ;;; For adverbs when modifying things with soas. pre-hd-adv-mod-ph := pre-hd-mod-ph & [ SS.LOC.CONT #msoa & [ NUCL.SOA-ARG #vsoa ], DTRS < [ SS.LOC.CONT #msoa ], [ SS.LOC.CONT #vsoa ] > ]. ;;;JTB 7/18/01 - Trying to eliminate pumping rules. ; head-only-phrase (hd-only-ph) hd-only-ph := hd-ph & [ HD-DTR #1, DTRS < #1 > ]. ; non-headed-phrase (non-hd-ph) non-hd-ph := phrase. ;;; The following is the "Filler Inclusion Constrant" which guarantees ;;;that the non head daughter must be WH-specified, and hence that the ;;;filler constituent must properly contain a wh-word. ;;; [ SS.LOC.CONT.PARAMS.LIST.FIRST #1, ;;; DTRS < [ SS.WH #1 & param ], sign > ]. ;;; CCB - I'm not sure if my specification for the wh-quantifier ;;;appearing at the begining of the PARAMS list is going to work. If the ;;;text above is correct, and that it's only to guarantee a wh-specified ;;;thing, then the [ WH g-quant ] should work by itself. ; wh-interrogative-clause (wh-int-cl) wh-int-cl := hd-int-cl & hd-fill-ph & [ SS.LOC.CONT [ PARAMS.LIST.FIRST #1, PROP #2 ], HD-DTR.SS.LOC.CONT proposition & #2, DTRS < [ SS.WH ], expression > ]. ;;; <<< >>> VALUES FOR VARIOUS FEATURES. *value* := *top*. case := *value*. nom := case. acc := case. ;;; <<< >>> Verb Form Types ;;;Abbreviations for VFORM are: fin(ite), nonfin(ite), inf(initive) ;;;participle (part), present patriciple (prp), perfect-participle (pfp), ;;;and passive-participle (pas). vform := form-cat. clausal := vform. fin := clausal. inf := clausal & nonfin. nonfin := vform. base := nonfin. part := nonfin. prp := part. pfp := part. pas := part. form-cat := *value*. ;;;Polar Adverbials. f_pol := form-cat. f_neg := f_pol. f_pos := f_pol. ;;;PFORM types so that verbs can select for specific prepositions. ;;;pdp's don't have interesting types, since they add their own ;;;semantics, but mkp ones do. pform := form-cat. mkp-pform := pform. pdp-pform := pform. loc := mkp-pform. recpt_ben := mkp-pform. to := recpt_ben. for := recpt_ben. about := mkp-pform. with := mkp-pform. of := mkp-pform. at := loc. around := loc. in := loc. on := loc. ; The noun form types distinguish between normal and idiomatic usages. nform := form-cat. normal := nform. ;------------------------------------------------------------------------- boolean := *value*. true := boolean. false := boolean. *list* := *top*. ne-list := *cons* & [ FIRST *top*, REST *list* ]. e-list := *null*. *null* := *list*. *cons* := *list* & [ FIRST *top*, REST *list* ]. *diff-list* := *top* & [ LIST *list*, LAST *list* ]. ;;; CCB - added *e-diff-list* because the inv-decl-cl construction was ;;;leaking - it was creating the sentence "Can Sandy love the cat", so I ;;;constrainted the SLAS value of root to be an *e-diff-list* rather than ;;;just ... which I would have thought should have that definition ;;;anyway. But maybe not for the ARG-ST list stitching. *e-diff-list* := *diff-list* & [ LIST #1 & e-list, LAST #1 ]. string := *value*. ;;; <<< >>> List types. list-of-strings := *list*. ne-list-of-strings := list-of-strings & ne-list & [ FIRST string, REST list-of-strings ]. e-list-of-strings := list-of-strings & e-list. list-of-locals := *list*. ne-list-of-locals := list-of-locals & ne-list & [ FIRST local, REST list-of-locals ]. e-list-of-locals := list-of-locals & e-list. list-of-signs := *list*. ne-list-of-signs := list-of-signs & ne-list & [ FIRST sign, REST list-of-signs ]. e-list-of-signs := list-of-signs & e-list. ;;;JTB 07/18/01 - Make this for daughters so that daughters are always ;;;words or phrases (i.e., expressions) list-of-expressions := list-of-signs. ne-list-of-expressions := list-of-expressions & ne-list & [ FIRST expression & [ ROOT false ], REST list-of-expressions ]. e-list-of-expressions := list-of-expressions & e-list. list-of-synsems := *list*. ne-list-of-synsems := list-of-synsems & ne-list & [ FIRST synsem, REST list-of-synsems ]. e-list-of-synsems := list-of-synsems & e-list. list-of-canon-ss := list-of-synsems. ne-list-of-canon-ss := list-of-canon-ss & ne-list-of-synsems & [ FIRST canon-ss, REST list-of-canon-ss ]. e-list-of-canon-ss := list-of-canon-ss & e-list-of-synsems. list-of-noncanon-ss := list-of-synsems. ne-list-of-noncanon-ss := list-of-noncanon-ss & ne-list-of-synsems & [ FIRST noncanon-ss, REST list-of-noncanon-ss ]. e-list-of-noncanon-ss := list-of-noncanon-ss & e-list-of-synsems. list-of-pro-ss := list-of-noncanon-ss. ne-list-of-pro-ss := list-of-pro-ss & ne-list-of-noncanon-ss & [ FIRST pro-ss, REST list-of-pro-ss ]. e-list-of-pro-ss := list-of-pro-ss & e-list-of-noncanon-ss. list-of-synsems-wh-none := list-of-synsems. ne-list-of-synsems-wh-none := list-of-synsems-wh-none & ne-list-of-synsems & [ FIRST synsem & [ WH ], REST list-of-synsems-wh-none ]. e-list-of-synsems-wh-none := list-of-synsems-wh-none & e-list-of-synsems. list-of-nc-ss-wh-none := list-of-synsems-wh-none & list-of-noncanon-ss. ne-list-of-nc-ss-wh-none := list-of-nc-ss-wh-none & ne-list-of-noncanon-ss & ne-list-of-synsems-wh-none & [ FIRST noncanon-ss & [ WH ], REST list-of-nc-ss-wh-none ]. e-list-of-nc-ss-wh-none := list-of-nc-ss-wh-none & e-list-of-synsems-wh-none & e-list-of-noncanon-ss. ;;; <<< >>> *diff-list* types. *list-of-strings* := *diff-list* & [ LIST list-of-strings, LAST list-of-strings ]. *list-of-locals* := *diff-list* & [ LIST list-of-locals, LAST list-of-locals ]. *list-of-synsems* := *diff-list* & [ LIST list-of-synsems, LAST list-of-synsems ]. *list-of-noncanon-ss* := *diff-list* & [ LIST list-of-noncanon-ss, LAST list-of-noncanon-ss ]. *list-of-canon-ss* := *diff-list* & [ LIST list-of-canon-ss, LAST list-of-canon-ss ]. *list-of-synsems-wh-none* := *list-of-synsems* & [ LIST list-of-synsems-wh-none, LAST list-of-synsems-wh-none ].