;;; -*- Mode: TDL; Package: LKB -*- ;;; ;;; HPSG Grammar Matrix ;;; ;;; $Id: matrix.tdl,v 1.51 2008-05-23 01:44:21 sfd Exp $ ;;; ;;; Copyright (c) 2002-2005 ;;; Emily M. Bender, Dan Flickinger, Stephan Oepen ;;; see licence.txt for conditions ;;; ;;; Projects using the Grammar Matrix should reference ;;; http://www.delph-in.net/matrix, the version used ;;; and Bender, Flickiner, & Oepen 2002. ;;; ;;; Based on: ;;; ;;; LinGO Grammar: fundamentals.tdl ;;; Copyright Daniel Flickinger 1994-2001 ;;; Initial development Rob Malouf, 3-Nov-1994 ;;; ;;; JACY Grammar: fundamentals.tdl, mrsbasic.tdl ;;; Developed by Melanie Siegel, Emily M. Bender ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; Top-level feature geometry ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Types for Sign, Word, Phrase, and Lex-Entry sign-min := avm & [ STEM list ]. basic-sign := sign-min & [ KEY-ARG bool ]. sign := basic-sign & [ SYNSEM synsem, ARGS list, INFLECTED bool ]. ; C-CONT encodes the semantic contribution of the rule (phrasal ; or lexical). phrase-or-lexrule := sign & [ SYNSEM canonical-synsem & [ LOCAL.CONT.HOOK #hook], C-CONT mrs-min & [ HOOK #hook] ]. word-or-lexrule-min := sign-min. ; ALTS allow lexical entries to block lexical rule application ; ARG-ST is the argument structure list. It appears only on ; lexical items (words or lexical rules), not on phrases. word-or-lexrule := word-or-lexrule-min & sign & [ ALTS alts-min, ARG-ST list ]. nocoord := sign & [ SYNSEM.LOCAL.COORD - ]. alts-min := avm. alts := alts-min & [ PASSIVE bool ]. no-alts := alts-min. ; Not all words have lex-synsem - e.g. lexical PPs like "tomorrow" are ; phr-synsem since they can be post-nominal modifiers. word := word-or-lexrule & nocoord. lex-item := word-or-lexrule & nocoord. ;; Not all phrases have SYNSEM phr-synsem, since we need to allow the ;; head-comp rules to build signs which are still [ SYNSEM lex-synsem ;; ], for constructions like "twenty-two" and "five fifteen p.m.". So ;; most phrases will assign the type phr-synsem to the value of ;; SYNSEM, but not all. phrase := phrase-or-lexrule. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Affixation ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; non-affix-bearing := word-or-lexrule & [ INFLECTED +, SYNSEM.LKEYS.KEYREL.WLINK cons ]. ; Rule rule := sign & [ RULE-NAME string ]. ; LABEL-NAME and META used for labeling nodes in parse trees tree-node-label := *top* & [ NODE sign ]. label := sign & [ LABEL-NAME string ]. ; For complex node labels, like S/NP meta := sign & [ META-PREFIX string, META-SUFFIX string ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; SYNSEM values ; ERB 2004-05-10 DEF-OPT and OPT are used in the analysis of ; optional complements (null instantiation). DEF-OPT allows words ; to lexically specify how their arguments will be interpreted ; in case of null instantiation. This solution may be superceded ; by a Sem-I based alternative. ; ERB 2007-02-05 Moving to an analysis of discourse status/cognitive ; status of referents following Borthen & Haugereid 2005. Replacing ; DEF and DEF-OPT with COG-ST and OPT-CS. synsem-min := avm & [ OPT bool, OPT-CS cog-st, LOCAL mod-local, NON-LOCAL non-local-min ]. ; The feature LIGHT is used to model phenomena which distinguish ; shorter words from longer ones, or constituents which are lexical ; or nearly so from larger phrases. It is inspired by the work ; of Abeille and Godard (e.g., 2003). lex-or-phrase-synsem := synsem-min & [ LIGHT luk ]. synsem := synsem-min. expressed-synsem := synsem. canonical-synsem := expressed-synsem & [ MODIFIED xmod ]. lex-synsem := canonical-synsem & lex-or-phrase-synsem & [ LOCAL local-min, LIGHT +, LKEYS lexkeys ]. ; ERB (2005-08-10) We want to make sure that head-comp phrases ; don't have the feature LKEYS, even if they are LIGHT +. phr-synsem-min := canonical-synsem & lex-or-phrase-synsem & [ LOCAL local-min ]. phr-synsem := phr-synsem-min & [ LIGHT - ]. non-canonical := synsem & [ LOCAL.CONT.HOOK.INDEX event-or-ref-index ]. expressed-non-canonical := non-canonical & expressed-synsem. gap := expressed-non-canonical & [ LOCAL #local, NON-LOCAL [ REL 0-dlist, QUE 0-dlist, SLASH 1-dlist & [ LIST < #local > ] ] ]. unexpressed := synsem-min & [ NON-LOCAL [ SLASH 0-dlist, REL 0-dlist, QUE 0-dlist ] ]. unexpressed-reg := unexpressed & non-canonical. anti-synsem := unexpressed & "A contrasting type to ordinary synsems (expressed and unexpressed) which is sometimes useful. No longer explicitly used in the Matrix.". ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; LOCAL & NON-LOCAL values mod-local := avm. ; sfd 08/02/2005: Added COORD and COORD-REL for coordination. COORD ; is a bool that's used to enforce the syntax of coordination. ; COORD-REL is the coordination relation. local-min := mod-local & [ CAT cat-min, CONT mrs-min, AGR individual, COORD bool, COORD-REL coordination-relation, COORD-STRAT string ]. local := local-min & [ CTXT ctxt-min ]. ; Types for distinguishing scopal v. intersective modifiers. ; (These types are used in the MOD value of modifiers, and ; referenced by the scopal/intersective head-adjunct rules.) scopal-mod := local. intersective-mod := local. non-local-min := avm. non-local := non-local-min & [ SLASH 0-1-dlist, QUE 0-1-dlist, REL 0-1-dlist ]. non-local-none := non-local & [ SLASH 0-dlist & [ LIST < > ], QUE 0-dlist, REL 0-dlist ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; CAT values cat-min := avm. ; ERB 2004-05-05 Following ERG, add a feature HC-LIGHT which indicates ; whether a head-comp phrase projected from a head is treated as light ; or heavy. That is, whether or not a phrase consisting of heads and ; complements is light or heavy is taken to be a lexical property of ; the head. ; MC stands for 'Main clause', and is used to distinguish phenomena ; which can only occur in main (+) or subordinate clauses (-). The ; value of MC is luk, allowing for a third possibility of na, for ; not applicable. cat := cat-min & [ HEAD head-min, VAL valence-min, MC luk, HC-LIGHT luk, POSTHEAD bool ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; HEAD head-min := avm. ; It is expected that head will have many more features, but it ; is not yet clear which are relevant crosslinguistically. In ; the English grammar, HEAD features include CASE, PRD, AUX, INV, ; TAM, and VFORM. (Re: TAM --- it is sometimes useful to have the ; semantic information encoded in EVENT.E accessible via the head ; path.) head := head-min & [ MOD list, KEYS keys_min ]. ; (ERB 2004-08-19) We had previously shied away from defining head ; types because even head types that are expected to occur across ; all languages are probably grouped differently in the head subhierarchy ; for different languages. There are plenty of things which we ; think will be the same across languages, however. Thus the current ; strategy is to allow for all possible groupings of head types, ; and expect most of the disjunctive types to be ignored in most ; languages. Perhaps one day the LKB will be modified so that ; users can declare certain types to suppress in the hierarchy ; displays. ; One recent LKB addition which will be helpful here is the ; type addendum statements (':+'). Head types often bear ; features, but none are declared for any of these Matrix head ; types, since we don't yet know of any universal ones. With ; the new ':+' notation, you can add constraints (including feature ; declarations) to existing types. We encourage you to use this ; when adding information to Matrix types, but not to types defined ; solely within your grammar. For example: ; CASE on nouns: ; noun :+ ; [ CASE case ]. ; VFORM on verbs and complementizers ; +vc :+ ; [ FORM form]. ; We expect that particular grammars will need to add new head ; types, and may find that the new types should inherit from ; existing disjunctions. If you do this, we encourage you to ; make use of type addendum statements (':+') to add a comment ; to the existing disjunction, e.g.: ; co-verb := +jv. ; +jv :+ ; "Adjectives, verbs, and co-verbs.". ; Anticipated future developments include Lisp commands for ; generating the appropriate type addenda and/or additional ; types when you want to add a new head type. ; Our basic inventory of head types will consist of ; verb (v), noun (n), adjective (j), adverb (r), adposition (p), ; complementizer (c), determiner (d), number-name (m), ; and conjunction (o). The letters in parentheses indicate ; the abbreviation for each part of speech used in the disjunctive ; types. Each disjunctive type is also associated with ; a documentation string explaining the disjuncts. ; With all the disjuntive types, we need 510 types to encode this. ; The parent types are in a separate file called head-types.tdl, with ; just the leaves here. conj := +mo & +do & +co & +po & +ro & +jo & +vo & +no. num := +mo & +dm & +cm & +pm & +rm & +jm & +vm & +nm. det := +do & +dm & +cd & +pd & +rd & +jd & +vd & +nd. comp := +co & +cm & +cd & +pc & +rc & +jc & +vc & +nc. adp := +po & +pm & +pd & +pc & +rp & +jp & +vp & +np. adv := +ro & +rm & +rd & +rc & +rp & +jr & +vr & +nr. adj := +jo & +jm & +jd & +jc & +jp & +jr & +vj & +nj. verb := +vo & +vm & +vd & +vc & +vp & +vr & +vj & +nv. noun := +no & +nm & +nd & +nc & +np & +nr & +nj & +nv. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; VAL valence-min := avm. valence := valence-min & [ SUBJ list, SPR list, COMPS list, SPEC list, --KEYCOMP avm ]. keys_min := avm. keys := keys_min & [ KEY predsort, ALTKEY predsort ]. ; One of a grammatically salient inventory of semantic sorts, such as ; 'animate' or 'time' semsort :< sort. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; CONT values ; ; HOOK : Externally visible attributes of a sign ; RELS diff-list ; List of semantic relations ; HCONS diff-list ; Scope constraints: list of qeq's mrs-min := avm. ; ERB 2007-01-21 Removing feature MSG here (moving it to a feature--SF--- ; of events). mrs := mrs-min & [ HOOK hook, RELS diff-list, HCONS diff-list ]. ; HOOK values include ; LTOP ; Local top handle ; INDEX ; The salient nominal instance or event ; XARG ; The external (controlled) argument of a phrase hook := avm & [ LTOP handle, INDEX individual, XARG individual ]. ; MRSs are divided into psoas (with a distinguished event) and ; nom-objs (with a distinguished index). We use a polymorphic ; attribute name INDEX for both of these, to simplify manipulation of ; these objects; for example, modifying PPs assign as their ARG's ; value the INDEX of the phrase they modify, whether it's an N-bar ; (with a ref-ind value) or a VP (with an event value). Similarly ; useful for coordination. psoa := mrs & [ HOOK.INDEX event ]. nom-obj := mrs & [ HOOK.INDEX index ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; LKEYS attributes, providing pointers to semantic relations and complement ; predsorts in lexical types: ; KEYREL relation ; Pointer to main relation in RELS ; ALTKEYREL relation ; Pointer to an alternate relation in RELS ; --COMPKEY predsort ; Pointer to the first complement's KEY predsort ; --OCOMPKEY predsort ; Pointer to the oblique complement's KEY predsort lexkeys := avm & [ KEYREL relation, ALTKEYREL relation, --COMPKEY predsort, --OCOMPKEY predsort ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; CTXT values ctxt-min := avm. ctxt := ctxt-min & [ ACTIVATED bool, PRESUP diff-list ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Basic semantic types ; The message represents the semantic type of a clause (cf. Ginzburg & ; Sag 2000). All clauses have messages. Elements that take clauses ; as semantic arguments should end up with the LBL of the clause as ; the value of ARGn, L/R-HNDL, etc. The MARG (message argument) of a ; message is a handle that qeqs the LBL of the main verb in the clause. ; This leaves room for quantifiers to scope at each clause without ; allowing scope ambiguity between quanitifers and messages, as it is ; not clear what that would mean. ; ERB 2007-01-21 Moving to a message free universe. ;basic_message := relation. ;message := basic_message & ; [ PRED message_m_rel, ; MARG handle ]. ;no-msg := basic_message. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Message preds ; ERB 2007-01-21 Moving to a message free universe. ;message_m_rel := predsort. ;command_m_rel := message_m_rel. ;prop-or-ques_m_rel := message_m_rel. ;for COMPS of e.g. 'know' ;proposition_m_rel := prop-or-ques_m_rel. ;abstr-ques_m_rel := prop-or-ques_m_rel. ;question_m_rel := abstr-ques_m_rel. ; Subtype of int_rel for tag questions and structures in other languages ; with equivalent pragmatics. ;ne_m_rel := abstr-ques_m_rel. ; Constrains handle of scopable argument HARG relative to one ; outscoped LARG handle (the "H" is mnemonic for either "higher" or ; "hole" argument, while the "L" is mnemonic for either "lower" or ; "label" argument. qeq := avm & [ HARG handle, LARG handle ]. semarg := avm & "INSTLOC is used by generator to index input. Changed from value instloc to value string in July 2004. The grammar should never need to make reference to it beyond this." [ INSTLOC string ]. handle := semarg. individual := semarg & [ SORT semsort ]. ; The INDEX value of a nom-obj is an index (expletive or ; referential). ; ERB 2004-05-10 Add a feature DEF which encodes definiteness ; for (in)definite null instantiation, and possibly other uses. ; The null instantiation use might get superceded by a Sem-I based ; solution. ; ERB 2007-02-05 Moving to an analysis of discourse status/cognitive ; status of referents following Borthen & Haugereid 2005. Replacing ; DEF and DEF-OPT with COG-ST and OPT-CS. ; ERB 2007-05-16 Can't put SPECI inside COG-ST, or the generator won't ; pay attention to the value of COG-ST. So, making it parallel. index := individual & [ COG-ST cog-st, SPECI bool ]. ; ERB 2007-02-05 Hierarchy from Borthen and Haugereid of possible ; COG-ST values. Departing from B&H analysis by putting SPECI on ; this type (as well as by making COG-ST a feature of indicies rather ; than parallel to the indices in the next level up). cog-st := avm. activ-or-less := cog-st. uniq-or-more := cog-st. uniq+fam+act := activ-or-less & uniq-or-more. fam-or-less := activ-or-less. fam-or-more := uniq-or-more. activ+fam := uniq+fam+act & fam-or-more. uniq+fam := uniq+fam+act & fam-or-less. uniq-or-less := fam-or-less. activ-or-more := fam-or-more. type-id := uniq-or-less. uniq-id := uniq-or-less & uniq+fam. familiar := uniq+fam & activ+fam. activated := activ+fam & activ-or-more. in-foc := activ-or-more. ; This is the type of the index of the phrase modified by predicative ; PPs, which can either modify a ref-ind nominal or an event VP. event-or-ref-index := individual. ; Expletives get distinguished index type so they can be ; selected semantically. In English, this type has subtypes ; for it and there. Most languages have at most one expletive, ; so those aren't included here. expl-ind := index. ref-ind := index & event-or-ref-index & [ PNG png ]. ; Types encoding agreement information, analyzed as a part of the ; index, following Pollard & Sag 1994. Which subtypes and features ; are appropriate seems highly language dependent. The agreement ; system of English doesn't justify a full cross-classification of ; number and gender, so the features of png are PN and GENDER in the ; English grammar. (See Flickinger 2000.) Sag & Wasow 1999 declare ; GENDER as a feature of the png type 3sg. png := avm. ; Create subtypes of tense, aspect and mood as appropriate. tense := sort. aspect := sort. mood := sort. tam := avm & [ TENSE tense, ASPECT aspect, MOOD mood ]. ; ERB 2006-10-05 First pass at de-messaging. I'm going to leave ; the messages in for now, but add a feature MESG to events. Will ; have to update once I see what Dan has actually done with the ERG. ; ERB 2006-10-05 Update this little hierarchy enventually to ; include commands, etc. ; ERB 2007-01-21 Consider renaming the feature MSG to something more ; reminiscent of illocutionary force? ; ERB 2007-01-22 MSG renamed SF. iforce := avm. prop-or-ques := iforce. prop := prop-or-ques. ques := prop-or-ques. comm := iforce. event := event-or-ref-index & [ E tam, SF iforce ]. ; Coordinated phrases have coordinated indices as their INDEX ; values. These are meant to be interpreted as pointers to ; the set of coordinated indices. coord-index := event-or-ref-index. coord-event := coord-index & event. coord-ref-ind := coord-index & ref-ind. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Basic relation types ; Relations are classified according to the types of arguments they take. All ; relations have a handle. In addition, quantifier relations have a bound ; variable and a restriction, nominal relations have an instance, and event ; relations have an event. Furthermore, nominal relations and event relations ; can have additional roles, depending on their meaning. ; WLINK links semantic relation to input string elements, more or less. ; This becomes useful whenever a grammar is used in some application. relation := avm & [ LBL handle, WLINK list, PRED predsort ]. ; Abstract relation subtypes. We recommend not positing a type ; for each lexical relation, but rather using the feature PRED ; to distinguish different lexical relations of the same type. ; Relation types are modified in one of two circumstances: ; ; (i) A feature needs to be introduced that is relevant for some ; relations and not others, or ; ; (ii) Something in the grammar needs to make reference to a family ; of relations that are not otherwise distinguished by a type. arg0-relation := relation & [ ARG0 individual ]. arg1-relation := arg0-relation & [ ARG1 semarg ]. arg12-relation := arg1-relation & [ ARG2 semarg ]. arg123-relation := arg12-relation & [ ARG3 semarg ]. arg1234-relation := arg123-relation & [ ARG4 semarg ]. event-relation := arg0-relation & [ ARG0 event ]. arg1-ev-relation := arg1-relation & event-relation. arg12-ev-relation := arg1-ev-relation & arg12-relation. arg123-ev-relation := arg12-ev-relation & arg123-relation. arg1234-ev-relation := arg123-ev-relation & arg1234-relation. ; Noun relations noun-relation := arg0-relation & [ ARG0 ref-ind ]. ; Relational nouns like 'picture' or 'claim' take an additional semantic ; argument noun-arg1-relation := noun-relation & arg1-relation. ; 02-12-2009 gcs extracted carg-relation from named-relation carg-relation := relation & [ CARG string ]. named-relation := noun-relation & carg-relation & [ PRED named_rel ]. ; coordinating and subordinating conjunctions subord-or-coord-relation := relation & [ L-HNDL handle, R-HNDL handle ]. coordination-relation := subord-or-coord-relation & [ C-ARG coord-index, L-INDEX individual, R-INDEX individual ]. ; NB: "if_then_rel" is now a PRED value of subord-relation. subord-relation := subord-or-coord-relation. ; quantifier relation quant-relation := arg0-relation & [ ARG0 ref-ind, RSTR handle, BODY handle ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; predsorts norm_rel := predsort. named_rel := norm_rel. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Head types ; Values for head features such as CASE, VFORM, ... ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Sorts for atomic values ; person, number and gender ; clause mode ; voice ; mood ; pronoun type ; Three-valued sort evoking Polish logician Jan Lukasiewicz luk := sort. ; These types allow the statement of constraints (e.g., in ; subcategorization) of the form: If you care, you must have ; the value + (-), but you don't have to care. Useful for keeping ; down the number of constructions and subcategorization types. na-or-+ := luk. na-or-- := luk. +-or-- := luk. na := na-or-+ & na-or--. bool := luk. + := bool & na-or-+ & +-or--. - := bool & na-or-- & +-or--. ; Three-valued sort for distinguishing unmodified signs from both ; left-modified and right-modified signs PERIPH indicates whether this ; modifier is left- or right-peripheral in its phrase - e.g., "the IBM ; temporary employees" but "*the IBM five employees" xmod := sort & [ PERIPH luk ]. notmod-or-rmod := xmod. notmod-or-lmod := xmod. notmod := notmod-or-rmod & notmod-or-lmod. hasmod := xmod. lmod := hasmod & notmod-or-lmod. rmod := hasmod & notmod-or-rmod. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Basic types sort := *top*. predsort := sort. atom := predsort. no-pred := predsort. avm := *top*. list := avm. cons := list & [ FIRST *top*, REST *top* ]. 0-1-list := list. 1-list := 0-1-list & cons & [ REST null ]. null := 0-1-list. 1-plus-list := cons & [ REST cons ]. diff-list := avm & [ LIST list, LAST list ]. 0-1-dlist := diff-list & [ LIST 0-1-list ]. 0-dlist := 0-1-dlist & [ LIST #list, LAST #list ]. ; ADD DOC -- don't use for lists which are constructive. ; might be good now -- circular structure check? ; dpf will look into it. -- remove null? 1-dlist := 0-1-dlist & [ LIST 1-list & [ REST #rest ], LAST #rest ]. ; This type shows the basic form for diff-list appends. ; It is not meant to be used as a supertype. Actual instances ; of diff-list append will involve different features in different ; relationships to each other & the feature geometry. dl-append := avm & [APPARG1 [LIST #first, LAST #between], APPARG2 [LIST #between, LAST #last], RESULT [LIST #first, LAST #last]]. integer := atom. ; NB: strings should be enclosed in double quotes, e.g., [PRED "named_rel"]. string := atom. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Some useful kinds of lists ; A list of optional arguments. olist := list. ocons := olist & cons & [ FIRST unexpressed & [ OPT + ], REST olist ]. onull := olist & null. ; The LinGO grammar also makes use of a prolist -- or list ; of synsems of type pro-ss. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Lexical rules ; Grammars should be monotonic in their construction of semantic ; representations. That is, as the tree is built, no relations should ; ever be thrown away. This has implications for the way lexical rules ; are written. If two forms are related to each other, and one has ; more semantic relations than the other, it has to be the output. ; We are interested in cases where this constraint is or appears to ; be problematic. lex-rule := phrase-or-lexrule & word-or-lexrule & [ NEEDS-AFFIX bool, SYNSEM.LOCAL.CONT [ RELS [ LIST #first, LAST #last ], HCONS [ LIST #hfirst, LAST #hlast ] ], DTR #dtr & word-or-lexrule & [ SYNSEM.LOCAL.CONT [ RELS [ LIST #first, LAST #middle ], HCONS [ LIST #hfirst, LAST #hmiddle ] ], ALTS #alts ], C-CONT [ RELS [ LIST #middle, LAST #last ], HCONS [ LIST #hmiddle, LAST #hlast ]], ALTS #alts, ARGS < #dtr > ]. ; Lexical rules vary on two dimensions: whether they are lexeme-to-lexeme ; or lexeme-to-word and whether or not they involve spelling changes. ; Accordingly, we define four subtypes of lex-rule, which have ; four cross-classified glb subtypes: ; Note that the lexeme/word distinction is represented via a feature ; [INFLECTED bool] rather than as a type. We find this more convenient, ; as it allows certain words to be [INFLECTED +] from the start without ; having to twist the hierarchy too much (especially if one makes use ; of defaults). ; Lexeme-to-word rules are hypothesized to monotonically add synsem ; information. ; ERB 2005-04-14 But it's a bad idea to copy the whole synsem ; value, since that means identifying RELS and HCONS lists, breaking ; the diff-list append. lexeme-to-word-rule := same-local-lex-rule & same-modified-lex-rule & same-light-lex-rule & same-non-local-lex-rule & [ INFLECTED +, DTR [ INFLECTED - ], C-CONT [RELS <! !>, HCONS <! !>]]. ; Lexeme-to-lexeme rules can make more radical changes to the SYNSEM value. ; (ERB 2004-02-11) This used to inherit from "lexeme" but now there is no ; such type. What was its purpose? (ERB 2007-02-13) Perhaps it was used ; to encode the lexeme/word distinction, now handled by the feature ; INFLECTED. ; (ERB 2007-02-12) Removing identity of MC here because this to can be ; changed by ltol rules. Creating a new type same-mc-lex-rule, etc. lexeme-to-lexeme-rule := lex-rule & [ INFLECTED #infl, DTR.INFLECTED #infl ]. ; ERB 2005-04-13 Add a few subtypes that copy up most other information, ; so that folks don't have to keep doing this. ; ERB 2005-04-14 If we copy the whole LOCAL value, ; we're copying RELS and HCONS, which means we can't ; add any sem through C-CONT. Thus what is 'logically' ; same-local is really a bunch of smaller identities. ;same-local-lex-rule := lexeme-to-lexeme-rule & ; [ SYNSEM.LOCAL #local, ; DTR.SYNSEM.LOCAL #local ]. ; ERB 2005-04-14 Don't want any of these inheriting ; from lexeme-to-lexeme because they're supertypes ; to lexeme-to-word. This part of the hierarchy probably ; needs to be cleaned up a bit. same-local-lex-rule := same-cat-lex-rule & same-cont-lex-rule & same-ctxt-lex-rule & same-agr-lex-rule. same-non-local-lex-rule := lex-rule & [ SYNSEM.NON-LOCAL #nl, DTR.SYNSEM.NON-LOCAL #nl ]. ; ERB 2007-05-16 Not everything is inside LOCAL or NON-LOCAL. same-modified-lex-rule := lex-rule & [ SYNSEM.MODIFIED #mod, DTR.SYNSEM.MODIFIED #mod ]. same-light-lex-rule := lex-rule & [ SYNSEM.LIGHT #light, DTR.SYNSEM.LIGHT #light ]. same-ctxt-lex-rule := lex-rule & [ SYNSEM.LOCAL.CTXT #ctxt, DTR.SYNSEM.LOCAL.CTXT #ctxt ]. ; ERB 2005-04-14 Can't just identify CONT values,since ; that makes it impossible to add any RELS/HCONS through ; C-CONT. Instead this type should identify HOOK. ; ERB 2005-05-16 Copy MSG too! ; ERB 2007-01-21 Making MSG a feature (SF) of events. ; ERB 2007-02-20 Copy daughter's HOOK to C-CONT rather than to mother's ; HOOK, for uniformity. same-cont-lex-rule := lex-rule & [ C-CONT [ HOOK #hook ], DTR.SYNSEM.LOCAL.CONT [ HOOK #hook ]]. same-agr-lex-rule := lex-rule & [ SYNSEM.LOCAL.AGR #agr, DTR.SYNSEM.LOCAL.AGR #agr ]. same-cat-lex-rule := lex-rule & [ SYNSEM.LOCAL.CAT #cat, DTR.SYNSEM.LOCAL.CAT #cat ]. same-head-lex-rule := lex-rule & [ SYNSEM.LOCAL.CAT.HEAD #head, DTR.SYNSEM.LOCAL.CAT.HEAD #head ]. same-val-lex-rule := lex-rule & [ SYNSEM.LOCAL.CAT.VAL #val, DTR.SYNSEM.LOCAL.CAT.VAL #val ]. same-hc-light-lex-rule := lex-rule & [ SYNSEM.LOCAL.CAT.HC-LIGHT #hcl, DTR.SYNSEM.LOCAL.CAT.HC-LIGHT #hcl ]. same-posthead-lex-rule := lex-rule & [ SYNSEM.LOCAL.CAT.POSTHEAD #ph, DTR.SYNSEM.LOCAL.CAT.POSTHEAD #ph ]. same-mc-lex-rule := lex-rule & [ SYNSEM.LOCAL.CAT.MC #mc, DTR.SYNSEM.LOCAL.CAT.MC #mc ]. no-ccont-lex-rule := lex-rule & [ C-CONT [ RELS <! !>, HCONS <! !> ]]. ; ERB 2007-05-16 Realized I haven't been copying up MODIFIED ; and LIGHT. Fixing that. non-local-change-only-lex-rule := same-local-lex-rule & same-modified-lex-rule & same-light-lex-rule & no-ccont-lex-rule. local-change-only-lex-rule := same-non-local-lex-rule & same-modified-lex-rule & same-light-lex-rule & no-ccont-lex-rule. ; ERB 2004-04-13 The only permissible changes to CONT are ; inside HOOK. If any RELS or HCONS need to be added, they ; should be added through the lex-rule's C-CONT. For this reason, ; this type does not inherit from no-ccont-lex-rule, and any ; subtypes/instances should properly constrain the values of ; C-CONT.RELS and C-CONT.HCONS. No relations may be dropped. ; ERB 2004-04-14 But identifying RELS and HCONS is no good, ; because that breaks the diff-list append that should ; let you add info through C-CONT. So just go with the ; text warning above. cont-change-only-lex-rule := same-non-local-lex-rule & same-modified-lex-rule & same-light-lex-rule & same-ctxt-lex-rule & same-cat-lex-rule & same-agr-lex-rule. ctxt-change-only-lex-rule := local-change-only-lex-rule & same-cont-lex-rule & same-cat-lex-rule & same-agr-lex-rule. agr-change-only-lex-rule := local-change-only-lex-rule & same-cont-lex-rule & same-cat-lex-rule & same-ctxt-lex-rule. cat-change-only-lex-rule := local-change-only-lex-rule & same-ctxt-lex-rule & same-cont-lex-rule & same-agr-lex-rule. head-change-only-lex-rule := cat-change-only-lex-rule & same-val-lex-rule & same-hc-light-lex-rule & same-posthead-lex-rule & same-mc-lex-rule. mc-change-only-lex-rule := cat-change-only-lex-rule & same-val-lex-rule & same-hc-light-lex-rule & same-posthead-lex-rule & same-head-lex-rule. ; ERB 2005-04-13 When using val-change-only-lex rule, be sure ; to constrain the values of all of the VAL features (SPR, SUBJ, ; COMPS and SPEC) on the mother. val-change-only-lex-rule := cat-change-only-lex-rule & same-head-lex-rule & same-hc-light-lex-rule & same-posthead-lex-rule & same-mc-lex-rule. ; ERB 2007-02-13 These two should only be inherited by ltol types, ; since they are redundant with constraints on lexeme-to-word-rule. add-only-rule := same-local-lex-rule & same-modified-lex-rule & same-light-lex-rule & same-non-local-lex-rule. add-only-no-ccont-rule := add-only-rule & no-ccont-lex-rule. ; Spelling changing rules. The LKB identifies these rules based ; on the NEEDS-AFFIX value. inflecting-lex-rule := lex-rule & [ NEEDS-AFFIX + ]. ; Spelling-preserving rules copy up the STEM (orthography) of ; the daughter. constant-lex-rule := lex-rule & [ STEM #stem, DTR [ STEM #stem ]]. ; Cross-classified types packaing spelling change status and ; feature copying. const-ltol-rule := lexeme-to-lexeme-rule & constant-lex-rule & nocoord. infl-ltol-rule := lexeme-to-lexeme-rule & inflecting-lex-rule & nocoord. const-ltow-rule := lexeme-to-word-rule & constant-lex-rule & nocoord. infl-ltow-rule := lexeme-to-word-rule & inflecting-lex-rule & nocoord. infl-non-local-change-only-ltol-rule := non-local-change-only-lex-rule & infl-ltol-rule. infl-local-change-only-ltol-rule := local-change-only-lex-rule & infl-ltol-rule. infl-cont-change-only-ltol-rule := cont-change-only-lex-rule & infl-ltol-rule. infl-ctxt-change-only-ltol-rule := ctxt-change-only-lex-rule & infl-ltol-rule. infl-agr-change-only-ltol-rule := agr-change-only-lex-rule & infl-ltol-rule. infl-cat-change-only-ltol-rule := cat-change-only-lex-rule & infl-ltol-rule. infl-head-change-only-ltol-rule := head-change-only-lex-rule & infl-ltol-rule. infl-val-change-only-ltol-rule := val-change-only-lex-rule & infl-ltol-rule. ; ERB 2005-04-26 Take care with the following two rules. While ; they likely won't be circular for parsing (since the surface form ; of the word will usually limit the number of times each can apply) ; they can easily spin in generation. To make the input and output ; incompatible, I recommend constraining the type of the DTR to ; something incompatible with the type of the rule. infl-add-only-ltol-rule := add-only-rule & infl-ltol-rule. infl-add-only-no-ccont-ltol-rule := add-only-no-ccont-rule & infl-ltol-rule. const-non-local-change-only-ltol-rule := non-local-change-only-lex-rule & const-ltol-rule. const-local-change-only-ltol-rule := local-change-only-lex-rule & const-ltol-rule. const-cont-change-only-ltol-rule := cont-change-only-lex-rule & const-ltol-rule. const-ctxt-change-only-ltol-rule := ctxt-change-only-lex-rule & const-ltol-rule. const-agr-change-only-ltol-rule := agr-change-only-lex-rule & const-ltol-rule. const-cat-change-only-ltol-rule := cat-change-only-lex-rule & const-ltol-rule. const-head-change-only-ltol-rule := head-change-only-lex-rule & const-ltol-rule. const-val-change-only-ltol-rule := val-change-only-lex-rule & const-ltol-rule. ; ERB 2005-04-14 Take care when using the following two types ; not to create circular rules. They may still be useful (the ; latter is employed in the Slave grammar), but you'll need to ; make sure that the DTR type is incompatible with the rule type. const-add-only-ltol-rule := add-only-rule & const-ltol-rule. const-add-only-no-ccont-ltol-rule := add-only-no-ccont-rule & const-ltol-rule. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Phrase structure rules ; Headed phrases must obey the Head Feature Principle and the Revised ; Marking Principle. They do not all obey the NLFP with respect to ; QUE, but it appears that all CLAUSE phrases account for QUE on ; mother and non-head-dtr. Hence moved the QUE coreference to ; NON-CLAUSE. Headed phrases also identify the value of AGR on mother ; and head daughter, unlike e.g. the coordination schemata which ; identify HEAD but not AGR. ; ; sfd 08/02/2005: Added constraints on COORD and COORD-REL. COORD ; must be "-" for all phrases that aren't participating in ; coordination. Also identify the COORD-REL so it gets passed up. headed-phrase := phrase & [ SYNSEM.LOCAL [ CAT.HEAD head & #head, AGR #agr, COORD -, COORD-REL #crel ], HEAD-DTR.SYNSEM.LOCAL local & [ CAT.HEAD #head, AGR #agr, COORD -, COORD-REL #crel ] ]. headed-phrase :+ [ SYNSEM.LOCAL [ COORD -, COORD-REL #crel ], HEAD-DTR.SYNSEM.LOCAL [ COORD -, COORD-REL #crel ]]. non-headed-phrase := phrase. ; Most but not all phrases have SYNSEM phr-synsem; head-complement ; constructions have their SYNSEM type determined by the head-dtr. phrasal := phrase & [ SYNSEM phr-synsem ]. ; ERB 2005-05-04 If messages are introduced by unary rules at the ; top of each clause, most phrase types should say [MSG no-msg] ; on the mother. The exceptions to this are the clauses themselves ; and coordination constructions. ; ERB 2005-05-11 This is not the right way to do it. There are ; going to be cases (e.g., quantifiers) where we want the MSG ; of the head daughter copied up to the mother. Let's try ; making (normal) lexical items MSG no-msg, and having the no-msg-phrase ; copy the info up. Make no-msg-phrase inherit from headed-phrase. ; Non-headed phrases will have to say something about the MSG ; of the mother. ; ERB 2007-01-21 Getting rid of message relations. SF will now ; be a feature of the EVENT, so it will go up the semantic head path ; anyway. (Need to be careful about not setting it too early.) ;no-msg-phrase := headed-phrase & ; [ SYNSEM.LOCAL.CONT.MSG #msg, ; HEAD-DTR.SYNSEM.LOCAL.CONT.MSG #msg ]. ; Head/nexus phrases pass up the REL and QUE values of the head daughter ; (which has amalgamated the REL and QUE values of its arguments as in ; Sag 1997) to the mother. head-nexus-rel-phrase := headed-phrase & [ SYNSEM.NON-LOCAL.REL #rel, HEAD-DTR.SYNSEM.NON-LOCAL.REL #rel ]. head-nexus-que-phrase := headed-phrase & [ SYNSEM.NON-LOCAL.QUE #que, HEAD-DTR.SYNSEM.NON-LOCAL.QUE #que ]. ; ERB 2005-05-04 If messages are introduced by unary rules at the ; top of each clause, most phrase types should say [MSG no-msg] ; on the mother. The exceptions to this are the clauses themselves ; and coordination constructions. ; ERB 2007-01-21 Removed supertype no-msg-phrase. head-nexus-phrase := head-nexus-rel-phrase & head-nexus-que-phrase. ; In a head/local dependent phrase, the SLASH feature of the mother is ; token-identical to that of the head daughter, which has already amalgamated ; the SLASH values of its arguments. See discussion of head-nexus-phrase for ; treatment of REL and QUE. head-valence-phrase := head-nexus-phrase & [ SYNSEM.NON-LOCAL.SLASH #slash, HEAD-DTR.SYNSEM.NON-LOCAL.SLASH #slash ]. ; All phrases are either unary or binary. basic-unary-phrase := phrase & [ STEM #stem, 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 #stem, SYNSEM.LOCAL local & [ CONT [ RELS [ LIST #first, LAST #middle ], HCONS [ LIST #scfirst, LAST #scmiddle ] ] ] ] > ]. unary-phrase := basic-unary-phrase & [ INFLECTED +, ARGS < [ INFLECTED + ] > ]. basic-binary-phrase := phrase & [ SYNSEM.LOCAL.CONT [ RELS [ LIST #first, LAST #last ], HCONS [ LIST #scfirst, LAST #sclast ] ], C-CONT [ RELS [ LIST #middle2, LAST #last ], HCONS [ LIST #scmiddle2, LAST #sclast ] ], ARGS < sign & [ SYNSEM.LOCAL local & [ CONT [ RELS [ LIST #first, LAST #middle1 ], HCONS [ LIST #scfirst, LAST #scmiddle1 ] ] ] ], sign & [ SYNSEM.LOCAL local & [ CONT [ RELS [ LIST #middle1, LAST #middle2 ], HCONS [ LIST #scmiddle1, LAST #scmiddle2 ] ] ] ] > ]. binary-phrase := basic-binary-phrase & [ INFLECTED +, ARGS < [ INFLECTED + ], [ INFLECTED + ] > ]. basic-binary-headed-phrase := headed-phrase & basic-binary-phrase & [ NON-HEAD-DTR sign & [ SYNSEM.LOCAL.COORD - ] ]. binary-headed-phrase := basic-binary-headed-phrase & binary-phrase. ; ERB (2007-02-13) Adding these for handling constructions where a marker ; shows up simultaneously on both ends of the phrase, such as negation ; in Hausa and question marking in ASL. (For the latter case, what's ; really going on is a non-manual sign extending the length of the clause, ; but a convenient single-line representation uses left and right brackets ; to show the duration of the non-manual.) basic-ternary-phrase := phrase & [ SYNSEM.LOCAL.CONT [ RELS [ LIST #first, LAST #last ], HCONS [ LIST #scfirst, LAST #sclast ] ], C-CONT [ RELS [ LIST #middle3, LAST #last ], HCONS [ LIST #scmiddle3, LAST #sclast ] ], ARGS < sign & [ SYNSEM.LOCAL local & [ CONT [ RELS [ LIST #first, LAST #middle1 ], HCONS [ LIST #scfirst, LAST #scmiddle1 ] ] ] ], sign & [ SYNSEM.LOCAL local & [ CONT [ RELS [ LIST #middle1, LAST #middle2 ], HCONS [ LIST #scmiddle1, LAST #scmiddle2 ] ] ] ], sign & [ SYNSEM.LOCAL local & [ CONT [ RELS [ LIST #middle2, LAST #middle3 ], HCONS [ LIST #scmiddle2, LAST #scmiddle3 ] ] ] ]> ]. ternary-phrase := basic-ternary-phrase & [ INFLECTED +, ARGS < [ INFLECTED +, SYNSEM.LOCAL.COORD - ], [ INFLECTED +, SYNSEM.LOCAL.COORD - ], [ INFLECTED +, SYNSEM.LOCAL.COORD - ] > ]. ternary-headed-phrase := headed-phrase & ternary-phrase. ; ERB (2007-02-12) Hypothesizing for now that these will never be fulfilling ; valence requirements of the head, so just copy that up. ; ERB (2007-02-26) Clearly this shouldn't be head-compositional, since ; we're using it for negation in Hausa and ASL. ternary-head-middle-phrase := ternary-headed-phrase & [ SYNSEM.LOCAL.CAT.VAL #val, HEAD-DTR #head & [ SYNSEM.LOCAL.CAT.VAL #val ], ARGS.REST.FIRST #head ]. ; For more effecient parsing, designate one argument or the other ; as the KEY-ARG: that which should be unified with first. binary-rule-left-to-right := rule & [ ARGS < [ KEY-ARG + ] , [ KEY-ARG bool ] > ]. binary-rule-right-to-left := rule & [ ARGS < [ KEY-ARG bool ], [ KEY-ARG + ] > ]. ; ERB 2005-05-04 If messages are introduced by unary rules at the ; top of each clause, most phrase types should say [MSG no-msg] ; on the mother. The exceptions to this are the clauses themselves ; and coordination constructions. Basic-head-only is for ; the clauses. ; ERB 2007-01-21 Removing no-msg-phrase. head-only := unary-phrase & headed-phrase & [ HEAD-DTR #head, ARGS < #head > ]. ;head-only := basic-head-only & no-msg-phrase. head-initial := binary-headed-phrase & [ HEAD-DTR #head, NON-HEAD-DTR #non-head, ARGS < #head, #non-head > ]. basic-head-final := basic-binary-headed-phrase & [ HEAD-DTR #head, NON-HEAD-DTR #non-head, ARGS < #non-head, #head > ]. head-final := basic-head-final & binary-headed-phrase. ; C-CONT is the semantic contribution of the phrase itself. The hook ; of the phrase is identified with the hook of C-CONT (which is possibly ; but not necessarily identified with the hook of one of the daughters. ; The rels of the phrase result from appending the rels of C-CONT and the ; rels of the daughters. ; Head-compositional phrases identify the syntactic head daughter as the ; semantic head. head-compositional := headed-phrase & [ C-CONT.HOOK #hook, HEAD-DTR.SYNSEM.LOCAL.CONT.HOOK #hook ]. ; Clauses have message types as values, non-clauses have the value no-msg. ; Constrain the HEAD value of clause to verb or whatever type is ; appropriate. Clauses have empty QUE values. ; Later versions of the Matrix might have clause v. non-clause as ; an independent dimension from headed v. non-headed phrase, as in ; Ginzburg & Sag 2000. The phrase types are meant to cross-classify ; with the clause types to give e.g., decl-head-subj from decl-clause ; and head-subj-phrase. ; ERB 2004-08-26 Remove [MC na], which is probably specific ; to some analysis for English. ; ERB 2005-05-11 I'm not sure what use non-clause is in the current ; system, and the constraint MSG no-msg is a little suspicious. ; It seems to only be used for head-spec phrases right now, though, ; so leave it for now. ; ERB 2007-01-21 I'm not sure there's really any use for non-clause ; in the message-free universe. ;non-clause := head-nexus-phrase & ; [ SYNSEM.LOCAL [ CONT.MSG no-msg ] ]. ;clause := phrasal & ; [ SYNSEM [ LOCAL.CAT.VAL.COMPS olist, ; NON-LOCAL.QUE 0-dlist ] ]. ; ERB 2007-01-21 COMPS olist is no longer a fair constraint on ; clauses, under current analysis. clause := phrasal & [ SYNSEM.NON-LOCAL.QUE 0-dlist ]. ; The following subtypes of clause will need more constraints, ; as appropriate: ; Relative clauses are propositions, but depending on the analysis ; of the construction, the message may actually come from the daughter. ; ERB 2007-01-21 Adding constraint that should specialize prop-or-ques ; to prop as value of SF. (See notes at interrogative-clause.) ; ERB 2007-01-22 ... but I'm not sure we can assume that relative-clauses ; are headed phrases. So, I'm going to comment out this type for now, ; pending the developmet of a relative clause library. ;relative-clause := clause & ; [ HEAD-DTR.SYNSEM.LOCAL.CONT.HOOK.INDEX.SF prop ]. ; This type does not constrain the length of the C-CONT..RELS ; in order to allow for clause types which insert two messages ; (e.g., interrogatives, which need to add both a question_m_rel ; and the embedded proposition_m_rel), or which some other ; constructional content in addition to the message. ; The MARG isn't related to anything in this type. There are ; two canonical possibilities: either the MARG qeqs the LTOP of ; the head daughter, or it is equal to the LBL of another message ; (again, the case of interrogatives, if there is one construction ; which introduces both messages). ; ERB 2005-05-04 Making all of these basic-head-only (non-branching ; constructions). Need to work on relative clauses at a later date. ; ERB 2007-01-21 No more messages. This type now enforces some ; constraints on the non-local features, but that's just about it. ; (And we haven't really worked on LDDs in the Matrix yet.) I'm not ; sure that there's really that much work for this type to do... ; Since we're not adding message relations anymore, I'm going to assume ; that the C-CONT.RELS and C-CONT.HCONS are empty. ; ERB 2007-01-21 Er, not head-only any more, though. basic-non-rel-clause := clause & head-compositional & [ SYNSEM.NON-LOCAL.REL 0-dlist, HEAD-DTR.SYNSEM.NON-LOCAL [ QUE 0-dlist, REL 0-dlist ], C-CONT [ RELS <! !>, HCONS <! !> ]]. ; For non-interrogative non-rel clauses, hook up ; MARG to head daughter's LTOP. Subtypes will need ; to constrain length of HCONS and RELS. ; ERB 2007-01-21 No more messages. ;non-rel-clause := basic-non-rel-clause & ; [ SYNSEM.LOCAL.CONT.MSG.MARG #marg, ; HEAD-DTR.SYNSEM.LOCAL.CONT.HOOK.LTOP #ltop, ; C-CONT.HCONS.LIST.FIRST qeq & [ HARG #marg, ; LARG #ltop ]]. ; ERB 2004-05-18 Make these inherit from non-rel-clause instead ; of just clause, so that something does the work of putting ; the message on the RELS list. ; ERB 2005-05-04 Trying out an analysis of clausal semantics where the ; message is always introduced by a non-branching construction. This ; goes against Ginzburg & Sag's (2000) strategy of cross-classifying ; phrase types with clause types, but it seems more practical for the ; Matrix, for two reasons: (i) In a free word order language, the ; `root' node in their strategy could be a head-subj, could be a ; head-comp, etc. and (ii) it's just easier to conceive of the ; crosslinguistic variation this way. Leave the length of C-CONT.RELS ; and C-CONT.HCONS unspecified for the moment on interrogatives. In ; some cases, it might be helpful to have the interrogatives put in ; both the prpstn and the ques messages. Likewise, don't require ; MSG no-msg on the head daugther of interrogatives. ; ERB 2007-01-21 Moving to a message-free universe. These guys ; now constrain the value of SF on the INDEX (event variable). ; How to keep them from spinning, though? For now, trying the following ; strategy: ; 1. All rules that satisfy the subject requirement add clausal semantics ; (either prop-or-ques or comm). ; 2. Complementizers (including matrix question/statement particles) can ; further constrain message value. ; 3. Head-filler phrases (for questions) can further constraint message value. ; 4. To force things to undergo question rules like the yesno rule from ; the ERG, take advanteg of [MC na] --- see ERG ; 5. Relative-clause rule constrains down from prop-or-ques to prop. ; 6. Since clausal semantics is tied to satisfaction of subject requirement ; and/or an appropriate MC value, assume that these will be enough and ; no further modification of the root condition is required. interrogative-clause := basic-non-rel-clause & [ SYNSEM.LOCAL.CONT.HOOK.INDEX.SF ques ]. declarative-clause := basic-non-rel-clause & [ SYNSEM.LOCAL.CONT.HOOK.INDEX.SF prop-or-ques ]. imperative-clause := basic-non-rel-clause & [ SYNSEM.LOCAL.CONT.HOOK.INDEX.SF comm ]. ; ERB 2004-08-26 The analysis of relative clauses in the ERG ; requires that the relative clause construction (a kind of ; "head" filler phrase) not actually be a subtype of ; headed-phrase. This is because the HEAD.MOD value of ; the mother and the would-be head daughter differ. ; Thus basic-filler-phrase does not inherit form headed-phrase. ; We provide a subtype, basic-head-filler-phrase, below, which does. basic-filler-phrase := binary-phrase & phrasal & [ SYNSEM [ LOCAL [ CAT [ VAL [ COMPS < >, SPR < > ], POSTHEAD + ] ], NON-LOCAL.SLASH 0-dlist ], ARGS < [ SYNSEM [ LOCAL #slash & local & [ CAT.VAL [ SUBJ olist, COMPS olist, SPR olist ], CTXT.ACTIVATED + ], NON-LOCAL.SLASH 0-dlist ] ], [ SYNSEM [ LOCAL.CAT [ VAL.COMPS olist ], NON-LOCAL [ SLASH 1-dlist & [ LIST [ FIRST #slash, REST < > & #last ], LAST #last ], QUE 0-dlist, REL 0-dlist ] ] ] > ]. basic-head-filler-phrase := basic-filler-phrase & headed-phrase. ; These phrase types should all inherit from head-final or head-initial, ; as appropriate, replacing binary-headed-phrase. ; Don't assume that all comps are realized before the subject ; in all languages. Remove COMPS olist from this one. In languages ; which do realize all COMPS before the SUBJ, the head-subj-phrase ; should allow [COMPS olist] on the head daughter but constrain ; the mother to be [COMPS < >]. ; ERB 2004-05-24 In anticipation of this type being cross-classified ; with decl-clause in at least some languages, it does not inherit ; from head-compositional, nor constrain the length of its C-CONT.RELS ; and C-CONT.HCONS lists. Subtypes of this type in specific grammars ; should inherit from either a clause-type or from head-compositional, ; and ensure that the length of these lists is specified appropriately. ; ERB 2004-12-14 For purposes of testing word order modules, assume ; for now that we're going to go with a non-branching rule analysis ; of message introduction. Make basic-head-subj phrase inherit from ; head-compositional and constraint C-CONT.RELS and C-CONT.HCONS like ; everyone else. ; ERB 2004-08-26 Remove [MC na] on head daughter; probably specific ; to some analysis for English. ; ERB 2005-08-12 Need [ LIGHT - ] on mother, so add SYNSEM phr-synsem. ; ERB 2007-01-21 Moving to message-free universe. Working with the ; hypothesis that head-subj phrases give clausal semantics --- either ; declarative (prop-or-ques) or imperative (comm). Can further constrain ; C-CONT to be RELS <! !>, now that we're not putting in messages. (Hey: ; that was already the case. Or not, now I don't see it?) basic-head-subj-phrase := head-valence-phrase & binary-headed-phrase & head-compositional & [ SYNSEM phr-synsem & [ LOCAL.CAT [ POSTHEAD +, VAL [ SUBJ < >, COMPS #comps, SPR #spr ] ] ], C-CONT [ RELS <! !>, HCONS <! !> ], HEAD-DTR.SYNSEM.LOCAL.CAT.VAL [ SUBJ < #synsem >, COMPS #comps, SPR #spr ], NON-HEAD-DTR.SYNSEM #synsem & canonical-synsem & [ LOCAL [ CAT [ VAL [ SUBJ olist, COMPS olist, SPR olist ] ] ], NON-LOCAL [ SLASH 0-dlist & [ LIST < > ], REL 0-dlist, QUE 0-dlist ] ]]. decl-head-subj-phrase := basic-head-subj-phrase & declarative-clause. imp-head-subj-phrase := basic-head-subj-phrase & imperative-clause. ; ERB 2004-08-26 Remove [MC na] on both daughters; probably specific ; to some analysis for English. ; ERB 2007-01-21 Removing non-clause, which doesn't seem to be doing ; any work any more. ; GCS 2009-02-19 changed identifying of COMPS of the mother with ; the COMPS of the non-head daughter. Instead identify the COMPS ; of the mother with the COMPS of the head-daughter basic-head-spec-phrase := head-valence-phrase & phrasal & binary-headed-phrase & [ INFLECTED +, SYNSEM [ LOCAL.CAT [ VAL [ SUBJ #subj, COMPS #comps, SPR #spr, SPEC #spec ], POSTHEAD #ph ], MODIFIED #modif ], HEAD-DTR [ INFLECTED +, SYNSEM [ LOCAL [ CAT [ HEAD #head, VAL [ SUBJ #subj, COMPS olist & #comps, SPR < #synsem & canonical-synsem . #spr >, SPEC #spec ], POSTHEAD #ph ], CONT.HOOK #hdhook ], MODIFIED #hmodif ] ], NON-HEAD-DTR.SYNSEM #synsem & [ LOCAL [ CAT [ VAL [ SPEC < [ LOCAL [ CAT [ HEAD #head, VAL.COMPS #comps ], CONT.HOOK #hdhook ], MODIFIED #hmodif ] > ] ], CONT.HOOK #hook ], MODIFIED #modif ], C-CONT [ HOOK #hook, RELS <! !>, HCONS <! !> ] ]. ; Value of LIGHT comes from head-daughter's specification in HC-LIGHT. ; ERB (2005-08-10) Change value of SYNSEM from canonical-synsem to ; phr-synsem-min, so that LKEYS is not an appropriate feature. ; ERB (2005-08-12) We need to copy of HC-LIGHT as well, for cases ; where there are multiple complements. ; ASF (2008-11-03) for the current v2 analysis, we need head-comp-phrase ; that does not pass up the MC feature..token id between mother and head ; daughter removed basic-head-comp-phrase := head-valence-phrase & head-compositional & binary-headed-phrase & [ SYNSEM phr-synsem-min & [ LOCAL.CAT [ VAL [ SUBJ #subj, SPR #spr ], POSTHEAD #ph, HC-LIGHT #light ], LIGHT #light ], HEAD-DTR.SYNSEM [ LOCAL.CAT [ VAL [ SUBJ #subj, SPR #spr ], HC-LIGHT #light, POSTHEAD #ph ]], NON-HEAD-DTR.SYNSEM canonical-synsem, C-CONT [ RELS <! !>, HCONS <! !> ] ]. ; ERB 2004-12-14 This is what used to be called basic-head-comp-phrase. basic-head-1st-comp-phrase := basic-head-comp-phrase & [ SYNSEM.LOCAL.CAT.VAL.COMPS #comps, HEAD-DTR.SYNSEM.LOCAL.CAT.VAL.COMPS < #synsem . #comps >, NON-HEAD-DTR.SYNSEM #synsem ]. ; ERB 2004-12-14 First pass at a rule that realizes complements ; out of order. basic-head-2nd-comp-phrase := basic-head-comp-phrase & [ SYNSEM.LOCAL.CAT.VAL.COMPS < #firstcomp . #othercomps >, HEAD-DTR.SYNSEM.LOCAL.CAT.VAL.COMPS [ FIRST #firstcomp, REST < #synsem . #othercomps > ], NON-HEAD-DTR.SYNSEM #synsem ]. ; Skip an optional complement as long as there is still another obligatory ; complement on the list. Two subtypes allow for one or two optional ; complements before an obligatory one. ; ERB 2004-05-10 Moving towards discharing all optional complements, ; so we no longer require that there are other expressed arguments ; before suppressing something with unexpressed. ; Still requiring [ HEAD-DTR..INDEX event ] as we might not ; want to go around discharging all optional complements of nouns. ; We'll probably want to make this a language-specific choice, eventually. ; Need to decide what to do about LIGHT here. ; The feature DEF-OPT allows the head to specify whether the optional ; complement is interpreted as definite (+), indefinite (-), or ; either (underspecified). basic-head-opt-comp-phrase copies this ; information into the index of the unexpressed argument. basic-head-opt-comp-phrase := head-valence-phrase & head-only & head-compositional & [ INFLECTED #infl, SYNSEM canonical-synsem & [ LOCAL.CAT [ VAL [ SUBJ #subj, COMPS #comps, SPR #spr, SPEC #spec ], MC #mc, POSTHEAD #ph ], MODIFIED #mod ], HEAD-DTR [ INFLECTED #infl & +, SYNSEM [ LOCAL [ CAT [ VAL [ SUBJ #subj, COMPS < unexpressed & [ OPT +, OPT-CS #def, LOCAL.CONT.HOOK.INDEX.COG-ST #def ] . #comps >, SPR #spr, SPEC #spec ], MC #mc, POSTHEAD #ph ], CONT.HOOK.INDEX event ], MODIFIED #mod ] ], C-CONT [ RELS <! !>, HCONS <! !> ] ]. ; ERB 2004-05-10 For languages that allow "pro-drop" of subjects. ; (Languages that also allow "pro-drop" of other arguments will ; use this rule in addition to the head-opt-comp-phrase.) Hypothesizing ; that null instantiation of subjects is always definite null instantiation. ; This rule is constrained to apply after all complements are discharged. ; ERB 2004-06-08 In anticipation of this type being cross-classified ; with decl-clause in at least some languages, it does not inherit ; from head-compositional, nor constrain the length of its C-CONT.RELS ; and C-CONT.HCONS lists. Subtypes of this type in specific grammars ; should inherit from either a clause-type or from head-compositional, ; and ensure that the length of these lists is specified appropriately. ; ERB 2007-01-21 Removing messages in favor of the feature SF. On ; this first pass, trying to insert SF information whenever subject ; requirements are discharged. Hmmm, again this was already RELS <! !> ; and HCONS <! !> in C-CONT. ; ERB 2007-05-16 Moving MC identification from basic-head-opt-subj-phrase ; down to decl-head-opt-subj-phrase, since we might *not* want it for ; imperatives. basic-head-opt-subj-phrase := head-valence-phrase & head-only & [ 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-reg & [ OPT +, LOCAL.CONT.HOOK.INDEX.COG-ST in-foc ] >, COMPS #comps & < >, SPR #spr, SPEC #spec ], POSTHEAD #ph ], CONT.HOOK.INDEX event ], MODIFIED #mod ] ] ]. ; ERB 2007-01-21 Subtypes for declaratives and imperatives decl-head-opt-subj-phrase := basic-head-opt-subj-phrase & declarative-clause & [ SYNSEM.LOCAL.CAT.MC #mc, HEAD-DTR.SYNSEM.LOCAL.CAT.MC #mc ]. imp-head-opt-subj-phrase := basic-head-opt-subj-phrase & imperative-clause. ; ASF 2008-11-18 Introducing a "basic-marker-comp-phrase", which basically ; behaves just like a head-comp-phrase, except that the phrase's head is not ; token-identical to that of the HEAD-DTR. We found this solution necessary to ; implement non-harmonic word order of auxiliaries that take a verb (not vp) as ; complement. The general idea of behaviour as head-comp, but without sharing ; all head-features could be useful for other phenomena, hence our decision to ; put it in the matrix. ; ASF 2008-11-18 The name MARKER-DTR is based on theoretical HPSG's HEAD-MARKER ; structure, but note that the marker-comp construction does not correspond to ; PS-84's head-marker structure (since the complement is not a head) marker-phrase := binary-phrase & [ SYNSEM.LOCAL [ AGR #agr, COORD -, COORD-REL #crel, CONT.HOOK #hook ], C-CONT.HOOK #hook, MARKER-DTR.SYNSEM.LOCAL local & [ AGR #agr, COORD -, COORD-REL #crel, CONT.HOOK #hook ] ]. basic-binary-marker-phrase := marker-phrase & [ NON-MARKER-DTR sign & [ SYNSEM.LOCAL.COORD - ] ]. basic-marker-comp-phrase := basic-binary-marker-phrase & [ SYNSEM phr-synsem-min & [ LOCAL.CAT [ MC #mc, VAL [ SUBJ #subj, SPR #spr, COMPS #comps ], POSTHEAD #ph, HC-LIGHT #light ], NON-LOCAL [ SLASH #slash, REL #rel, QUE #que ], LIGHT #light ], MARKER-DTR.SYNSEM [ LOCAL.CAT [ MC #mc, VAL [ SUBJ #subj, SPR #spr, COMPS < #synsem . #comps > ], HC-LIGHT #light, POSTHEAD #ph ], NON-LOCAL [ SLASH #slash, REL #rel, QUE #que ] ], NON-MARKER-DTR.SYNSEM canonical-synsem & #synsem & [ LOCAL.COORD - ], C-CONT [ RELS <! !>, HCONS <! !> ] ]. marker-initial-phrase := basic-binary-marker-phrase & [ MARKER-DTR #marker, NON-MARKER-DTR #non-marker, ARGS < #marker, #non-marker > ]. marker-final-phrase := basic-binary-marker-phrase & [ MARKER-DTR #marker, NON-MARKER-DTR #non-marker, ARGS < #non-marker, #marker > ]. ; ERB 2004-12-14 Type for optional specifier (determiner) phrases. ; Build NPs out of N's. The specification [OPT +] on the head ; daughter's SPR value is meant to allow this rule to apply to ; some nouns and not others. Nouns which require an overt specifier ; should lexically say [ OPT - ]. Nouns which optionally occur ; with a specifier can leave the OPT value of that argument unmarked. ; Nouns which only appear without a specifier need a SPR value which ; is incompatible with any of the available overt determiners. This ; could conceivably be regulated on the basis of semantics. basic-bare-np-phrase := head-only & [ SYNSEM.LOCAL.CAT.VAL [ SPR < >, SUBJ < >, COMPS < >, SPEC < > ], HEAD-DTR.SYNSEM.LOCAL [ CAT.VAL [ SPR < [ LOCAL.CAT.HEAD det, OPT + ] >, SUBJ < >, COMPS < > ], CONT.HOOK [ INDEX #index, LTOP #larg ] ], C-CONT [ RELS <! quant-relation & [ LBL #ltop, ARG0 #index, RSTR #harg ] !>, HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, HOOK [ INDEX #index, LTOP #ltop ] ] ]. ; Unary rules for extraction basic-extracted-arg-phrase := head-valence-phrase & head-only & [ SYNSEM.LIGHT - ]. basic-extracted-comp-phrase := basic-extracted-arg-phrase & head-compositional & [ SYNSEM canonical-synsem & [ LOCAL.CAT [ VAL [ SUBJ #subj, SPR #spr, COMPS #comps ], MC #mc ] ], HEAD-DTR [ SYNSEM [ LOCAL.CAT [ VAL [ SUBJ #subj, SPR #spr, COMPS < gap & [ NON-LOCAL.SLASH #slash ] . #comps > ], MC #mc ], NON-LOCAL.SLASH #slash ] ], C-CONT [ RELS <! !>, HCONS <! !> ] ]. ; ERB 2004-08-26 Remove [MC -] on mother; probably specific ; to analysis of subject extraction for English. basic-extracted-subj-phrase := basic-extracted-arg-phrase & [ SYNSEM.LOCAL.CAT.VAL [ SUBJ < >, SPR < >, COMPS < > ], HEAD-DTR.SYNSEM [ LOCAL.CAT [ VAL [ SUBJ < gap & [ LOCAL #local & local & [ CONT.HOOK.INDEX ref-ind ] ] >, COMPS olist ], MC na ], NON-LOCAL.SLASH.LIST < #local > ] ]. ; ERB 2004-05-05 Allow modifiers to attach to things with ; non-empty comps lists. The head-mod-phrase will pass up ; the COMPS requirement, whatever it was. head-mod-phrase := head-nexus-phrase & [ SYNSEM [ LOCAL.CAT.VAL [ SUBJ #subj, SPR #spr, COMPS #comps ], MODIFIED hasmod ], HEAD-DTR.SYNSEM [ LOCAL.CAT.VAL [ SUBJ #subj, SPR #spr, COMPS #comps ], NON-LOCAL [ REL 0-dlist ] ] ]. basic-extracted-adj-phrase := head-mod-phrase & head-only & phrasal. extracted-adj-phrase := basic-extracted-adj-phrase & [ SYNSEM [ LOCAL.CAT [ POSTHEAD #ph, MC #mc ], NON-LOCAL.SLASH 1-dlist & <! [ CAT [ POSTHEAD +, HEAD [ MOD < [ LOCAL intersective-mod & [ CAT [ HEAD #head, VAL #val, POSTHEAD #ph, MC #mc ], CONT.HOOK #hook, CTXT #ctxt ] ] > ], VAL [ SUBJ olist, COMPS olist, SPR olist ] ] ] !> ], HEAD-DTR.SYNSEM canonical-synsem & [ LOCAL local & [ CAT [ HEAD #head, VAL #val & [ SUBJ < synsem-min & [ NON-LOCAL.SLASH 0-dlist ] > ], POSTHEAD #ph, MC #mc ], CONT.HOOK #hook, CTXT #ctxt ], NON-LOCAL.SLASH 0-dlist, MODIFIED notmod ], C-CONT [ HOOK #hook, HCONS <! !> ] ]. ; ERB 2004-05-10 Bug fix: non-head daughter's MOD..LIGHT value should ; be matched to head-daughters LIGHT value. ; ASF (2008-11-03) for the v2 analysis, the MC feature cannot be shared between ; mother and non-head-daughter, token-identity removed 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 #hdhook ], NON-LOCAL #nonloc & [ SLASH [ LIST #middle, LAST #last ] ], LIGHT #light, 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 #hdhook ], NON-LOCAL #nonloc, LIGHT #light, MODIFIED #modif ] > ], VAL [ COMPS olist, SPR olist ] ], NON-LOCAL [ SLASH [ LIST #first, LAST #middle ], QUE 0-dlist & [ LIST null ] ] ], C-CONT.RELS <! !> ]. head-mod-phrase-simple := basic-head-mod-phrase-simple & [ HEAD-DTR.SYNSEM.LOCAL.CONT.HOOK.LTOP #htop, NON-HEAD-DTR.SYNSEM.LOCAL.CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.LTOP #htop ] >]. adj-head-phrase := basic-head-mod-phrase-simple & head-final & [ SYNSEM [ LOCAL.CAT.POSTHEAD #ph, MODIFIED lmod & [ PERIPH #periph ], LIGHT #light ], HEAD-DTR.SYNSEM [ LOCAL.CAT.POSTHEAD #ph, LIGHT #light ], NON-HEAD-DTR.SYNSEM [ LOCAL.CAT [ VAL.COMPS < > ], NON-LOCAL [ SLASH 0-dlist, REL 0-dlist ], MODIFIED.PERIPH #periph ] ]. head-adj-phrase := basic-head-mod-phrase-simple & head-initial & phrasal & [ SYNSEM [ LOCAL.CAT.POSTHEAD +, MODIFIED rmod ], HEAD-DTR.SYNSEM.MODIFIED notmod-or-rmod, NON-HEAD-DTR.SYNSEM [ LOCAL.CAT.POSTHEAD +, NON-LOCAL.QUE 0-dlist ] ]. ; We split head-adj-phrase and adj-head-phrase into two each, ; one for intersective modifiers and one for scopal modifiers, in order to ; get desired results for recursive modification as in "apparently difficult ; problem" (cf. Kasper '98). This split is also used in generation, where ; we delay construction of intersective modification, but not scopal. scopal-mod-phrase := head-mod-phrase-simple & [ NON-HEAD-DTR.SYNSEM.LOCAL [ CAT.HEAD.MOD < [ LOCAL scopal-mod ] >, CONT.HOOK #hook ], C-CONT [ HOOK #hook, HCONS <! !> ] ]. ; ERB 2004-05-18 I'm guessing that MSG no-msg on the head ; daughter here is going to turn out too restrictive for other ; languages. ; ERB 2007-01-21 The option to say MSG no-msg is no longer available. ; But, it's probably less necessary, since we'll have fewer non-branching ; rules? isect-mod-phrase := head-mod-phrase-simple & head-compositional & [ HEAD-DTR.SYNSEM.LOCAL.CONT [ HOOK.LTOP #hand ], NON-HEAD-DTR.SYNSEM.LOCAL [ CAT.HEAD.MOD < [ LOCAL intersective-mod ] >, CONT.HOOK.LTOP #hand ], C-CONT.HCONS <! !> ]. adj-head-scop-phrase := adj-head-phrase & scopal-mod-phrase & [ NON-HEAD-DTR.SYNSEM.LOCAL.CAT.POSTHEAD - ]. head-adj-scop-phrase := head-adj-phrase & scopal-mod-phrase & [ NON-HEAD-DTR.SYNSEM.NON-LOCAL.REL 0-dlist ]. adj-head-int-phrase := adj-head-phrase & isect-mod-phrase & [ NON-HEAD-DTR.SYNSEM.LOCAL.CAT [ POSTHEAD - ] ]. head-adj-int-phrase := head-adj-phrase & isect-mod-phrase. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; Lexical types ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Lexical entries will be cross-classified along many dimensions, ; including: ; ; -- Whether or not they introduce non-empty non-local feature values ; -- Amalgamation of non-local features ; -- Whether or not they are fully inflected as listed ; in the lexicon. ; -- Part of speech (and associated semantic generalizations) ; -- Subcategorization ; -- Values for the HOOK features ; ; On the first three dimensions, the vast majority of words will ; actually follow the general pattern. In order to facilitate the ; definition of types (in particular grammars) for those cases that ; don't, the constraints are stated on separate types. Additional ; types can be created as required by inheriting from all of the types ; that are still relevant. This is clearly an area to investigate ; the use of defaults, as we learn more about best practice concerning ; their use. ; ; Note that we don't treat these dimensions as entirely independent ; of each other, but rather hope to strike a balance between flexibility ; and redundancy. ; ; We are currently avoiding any development within the Matrix of the ; subhierarchy under head (see notes at the definition of type head ; above), believing that the exact geometry of that hierarchy to be ; somewhat language dependent. Thus, even the types for the part of ; speech dimension will not specify head values, and will need to be ; specialized in particular grammars to do so. Furthermore, the ; subcategorization types will specify only the number of syntactic ; arguments and their linking to the semantic relations. ; Update: 2004-08-26 We have devised a means of adding in a subhierarchy ; under head without prejudging the disjunctive types needed. Therefore, ; the part of speech types will now specify HEAD values. Nonetheless, ; the HEAD values of arguments are left underspecified, as that does ; vary across languages. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; HOOK feature values ; LKEYS.KEYREL is a short-cut to the relation that is going to ; contribute the LTOP and INDEX for the word, such that linking ; types and lexical entries don't have to refer to a specific position ; on the RELS list. norm-ltop-lex-item := lex-item & [ SYNSEM [ LOCAL.CONT [ HOOK [ LTOP #ltop ], RELS.LIST.FIRST #keyrel ], LKEYS.KEYREL #keyrel & [ LBL #ltop ] ] ]. norm-hook-lex-item := norm-ltop-lex-item & [ SYNSEM [ LOCAL.CONT.HOOK.INDEX #index, LKEYS.KEYREL.ARG0 #index ] ]. ; ERB 2007-02-26 For modifiers. Elements that have a double life ; as attributive and predicative become tricky. Attributive adjectives ; and PPs should be raise-index-mod-lex-item, while predicative ; ones should be norm-hook-lex-item. But how to relate the two? ; Also, reconsider whether I want to do this for intersective as ; well as scopal modifiers, or just the scopal guys. raise-index-mod-lex-item := norm-ltop-lex-item [ SYNSEM.LOCAL [ CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.INDEX #index ] >, CONT.HOOK.INDEX #index ] ]. ; Furthermore, most lexical items contribute only one relation, and ; have empty HCONS values. single-rel-lex-item := lex-item & [ SYNSEM.LOCAL.CONT.RELS <! relation !> ]. no-hcons-lex-item := lex-item & [ SYNSEM.LOCAL.CONT.HCONS <! !> ]. ; ERB 2005-05-11 Normal lex items don't introduce messages. ; Since I'm trying out an analysis where the no-msg-phrases ; copy of MSG values, need to bottom out in MSG no-msg ; on most lex items. ; ERB 2007-01-21 No more messages. ;no-msg-lex-item := lex-item & ; [ SYNSEM.LOCAL.CONT.MSG no-msg ]. ; ERB 2007-01-22 Removing no-hcons-lex-item here, since now ; there are many words which introduce hcons (in the absence of ; messages). HCONS should now (in most cases) be constrained ; by the linking types. norm-sem-lex-item := norm-hook-lex-item & single-rel-lex-item. hcons-lex-item := norm-hook-lex-item & single-rel-lex-item. ; ERB 2005-08-07 For lexical items like case-marking adpositions ; and auxiliaries which only contribute tense/aspect information. ; These all take HOOK from their first complements. raise-sem-lex-item := no-hcons-lex-item & [ SYNSEM.LOCAL [ CONT [ RELS <! !>, HOOK #hook ], CAT.VAL.COMPS < [ LOCAL.CONT.HOOK #hook ] , ... > ]]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; inflected v. uninflected uninflected-lexeme := lex-item & [ INFLECTED - ]. fully-inflected-lexeme := lex-item & [ INFLECTED + ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Non-local features: Values and amalgamation ; Not all of the non-local features will necessarily be useful in ; all languages. SLASH is for `topicalization' style long distance ; dependencies. REL and QUE are used in the analysis of pied piping ; in relative clauses and questions respectively, and also to signal ; the presence of a question element in in-situ questions so that ; clausal constructions with question semantics can require the presence ; of a question word. ; basic_zero_arg lexical items have empty ARG-ST lists. They may ; introduce a non-empty value for one of the non-local features. basic-zero-arg := lex-item & [ ARG-ST < > ]. zero-arg-nonslash := lex-item & [ SYNSEM.NON-LOCAL.SLASH 0-dlist ]. zero-arg-nonrel : = lex-item & [ SYNSEM.NON-LOCAL.REL 0-dlist ]. zero-arg-nonque : = lex-item & [ SYNSEM.NON-LOCAL.QUE 0-dlist ]. ; Non-argument taking items which introduce no non-local values. norm-zero-arg := zero-arg-nonslash & zero-arg-nonrel & zero-arg-nonque. ; Items introducing a rel value. zero-arg-rel := zero-arg-nonslash & zero-arg-nonque. ; Items introducing a que value. ; ERB 2004-05-24 Bug fix: This was inheriting from zero-arg-nonque ; instead of zero-arg-nonrel. zero-arg-que := zero-arg-nonslash & zero-arg-nonrel. ; Items introducing a slash value, e.g., resumptive pronouns in French. zero-arg-slash := zero-arg-nonrel & zero-arg-nonque. ; These non-zero argument types only amalgamate the non-local ; feature values of their complements. They do not introduce any ; non-local values of their own, nor do they bind off any non-local ; feature values. This assumes that the bottom of most long-distance ; dependencies is handles by a rule that constrains an argument (either ; on the ARG-ST list or a valence list) to be a synsem of type gap. ; Elements like English tough adjectives which bind off a slash value ; will need a new type that doesn't amalgamate that slash value. ; Elements which both introduce REL or QUE values and take one or ; more arguments will require appropriate new types as well, which ; amalgamate everything but add a value in addition. basic-one-arg := lex-item & [ ARG-ST < [ NON-LOCAL [ SLASH #slash, REL #rel, QUE #que ] ] >, SYNSEM.NON-LOCAL [ SLASH #slash, REL #rel, QUE #que ] ]. basic-two-arg := lex-item & [ ARG-ST < [ NON-LOCAL [ SLASH [ LIST #smiddle, LAST #slast ], REL [ LIST #rmiddle, LAST #rlast ], QUE [ LIST #qmiddle, LAST #qlast ] ] ], [ NON-LOCAL [ SLASH [ LIST #sfirst, LAST #smiddle ], REL [ LIST #rfirst, LAST #rmiddle ], QUE [ LIST #qfirst, LAST #qmiddle ] ] ] >, SYNSEM.NON-LOCAL [ SLASH [ LIST #sfirst, LAST #slast ], REL [ LIST #rfirst, LAST #rlast ], QUE [ LIST #qfirst, LAST #qlast ] ] ]. basic-three-arg := lex-item & [ ARG-ST < [ NON-LOCAL [ SLASH [ LIST #smiddle2, LAST #slast ], REL [ LIST #rmiddle2, LAST #rlast ], QUE [ LIST #qmiddle2, LAST #qlast ] ] ], [ NON-LOCAL [ SLASH [ LIST #sfirst, LAST #smiddle1 ], REL [ LIST #rfirst, LAST #rmiddle1 ], QUE [ LIST #qfirst, LAST #qmiddle1 ] ] ], [ NON-LOCAL [ SLASH [ LIST #smiddle1, LAST #smiddle2 ], REL [ LIST #rmiddle1, LAST #rmiddle2 ], QUE [ LIST #qmiddle1, LAST #qmiddle2 ] ] ] >, SYNSEM.NON-LOCAL [ SLASH [ LIST #sfirst, LAST #slast ], REL [ LIST #rfirst, LAST #rlast ], QUE [ LIST #qfirst, LAST #qlast ] ] ]. ; ERB 2007-01-22 In the message-free universe, many more qeqs are ; introduced by lexical items (basically any head that selects a clausal ; complement). To facilitate this, I'm going to move the no-hcons ; distinction to the linking types part of the hierarchy (and out of ; the pos part of the hierarchy). In this connection, it's useful ; to have subtypes of basic-n-arg which inherit from no-hcons-lex-item. basic-one-arg-no-hcons := basic-one-arg & no-hcons-lex-item. basic-two-arg-no-hcons := basic-two-arg & no-hcons-lex-item. basic-three-arg-no-hcons := basic-three-arg & no-hcons-lex-item. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subcategorization/linking ; These types specify the number of syntactic arguments, a relation ; type, and the relationship between the syntactic arguments and the ; relation type. They inherit from the amalgamation types above, ; since we believe that the need for cross-classification across these ; two dimensions is minimal. That is, words which do something other ; than simply amalgamate the non-local feature values of their ; arguments probably have quirky subcategorization frames as well. ; It is expected that further types will need to be defined in ; every particular grammar, but these types should cover the vast ; majority of open-class lexical items, and assist with some closed-class ; items as well. ; As explained above, we are leaving the HEAD values of the syntactic ; arguments underspecified as there are cross-linguistic differences ; in the part of speech of arguments in otherwise similar ; subcategorization types: English transitive verbs select two NPs. ; Japanese transitives select two PPs, as the case particles are ; treated as postpositions. ; We will, however, specify the semantic type of arguments, since it ; is relevant to the semantic constraints associated with each lexical ; item. Clausal-argument taking elements identify the LTOP of their ; complement with an ARGn position, rather than the INDEX. (Even ; though handles are involved here, we do identification rather than a ; relationship mediated by HCONS because the messages already leave ; enough room for quantifiers to scope at the top of the embedded ; clause, and scope ambiguities between quantifiers and messages would ; be meaningless.) Subordinating conjunctions will have even more ; to say semantically. ; We are also leaving underspecified the mapping from ARG-ST to ; valence features. The phrase structure rules assume one particular ; inventory of valence features (SPR, SUBJ, COMPS), but the exact ; deployment of those features might be language-specific (e.g., ; in syntactically ergative languages). NB: The phrase structure ; rules differentiate SPR and SUBJ in that SPR is treated as the ; semantic head. ; By hypothesis, the order of the syntactic arguments on the ARG-ST ; list corresponds to the order of the semantric arguments ARGn, with ; the caveat that not all syntactic arguments are also semantic ; arguments, as in constructions involving expletives or raising. The ; ARGn features do not correspond to theta roles but rather should ; have their interpretation specified in the Sem-I, where the ; interpretations of each ARGn will be relative to (classes of) ; predicates. Nonetheless, we expect the order of elements on the ; ARG-ST list follow a thematic role or grammatical function hierarchy ; in underived lexical items. This order may be perturbed by lexical ; rules. In addition, there are degrees of freedom allowed by the ; mapping from ARG-ST to the valence features and the possibility of ; scrambling by realizing elements of a valence list "out of order". ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; For verbs, adjectives and nouns that don't require specifiers ; Kim is tired, Kim sleeps, Kim is in the park, Kim is a student. ; Kim ga nemui, Kim ga neru. ; Kim est fatigue, Kim dors, Kim est a la maison, Kim est etudiant. ; (Kim is a student requires an analysis of predicative NPs.) intransitive-lex-item := basic-one-arg-no-hcons & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind ] >, SYNSEM.LKEYS.KEYREL.ARG1 #ind ]. ; It rains. ; Il pleut. expl-arg-only-lex-item := basic-one-arg-no-hcons & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX expl-ind ] > ]. ; Kim eats lunch. Kim is fond of apples. ; Kim ga hiru gohan wo taberu. ; Kim mange le dejeuner. transitive-lex-item := basic-two-arg-no-hcons & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind1 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind2 ] >, SYNSEM.LKEYS.KEYREL [ ARG1 #ind1, ARG2 #ind2 ] ]. ; Kim gives Sandy a book. ; Kim ga Sandy ni hon wo ageru. ; Kim donne un livre a Sandy. ditransitive-lex-item := basic-three-arg-no-hcons & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind1 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind2 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind3 ] >, SYNSEM.LKEYS.KEYREL [ ARG1 #ind1, ARG2 #ind2, ARG3 #ind3 ] ]. ; That Kim sleeps is obvious. ; [NB: This is just one possible analysis of clausal subjects. ; in English, a non-branching NP -> CP rule is also plausible. ; We are interested in arguments from other languages supporting ; one analysis or the other.] ; ERB 2007-01-22 Inserting qeqs now that we no longer have messages ; intervening. clausal-arg-intrans-lex-item := basic-one-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.LTOP #larg ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #harg ] ] ]. ; That Kim sleeps surprises Sandy. ; ERB 2007-01-22 Inserting qeqs now that we no longer have messages ; intervening. clausal-first-arg-trans-lex-item := basic-two-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.LTOP #larg ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #harg, ARG2 #ind ] ] ]. ; Sandy believes that Kim sleeps. ; Sandy ga Kim ga neru to shinjita. ; Sandy croit que Kim dors. ; ERB 2007-01-22 Inserting qeqs now that we no longer have messages ; intervening. clausal-second-arg-trans-lex-item := basic-two-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind ], [ LOCAL.CONT.HOOK.LTOP #larg ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind, ARG2 #harg ] ] ]. ; Kim told Sandy that Pat slept. ; Kim ga Sandy ni Pat ga neta to itta. ; Kim a dit a Sandy que Pat dormait. ; ERB 2007-01-22 Inserting qeqs now that we no longer have messages ; intervening. clausal-third-arg-ditrans-lex-item := basic-three-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind1 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind2 ], [ LOCAL.CONT.HOOK.LTOP #larg ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind1, ARG2 #ind2, ARG3 #harg ] ] ]. ; It is obvious that Kim sleeps. ; Il est evident que Kim dors. ; (Many of these might be generated via a lexical rule from ; clausal-arg-intrans-lex-items, but some probably don't alternate). ; ERB 2007-01-22 Inserting qeqs now that we no longer have messages ; intervening. clausal-expl-arg-lex-item := basic-two-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX expl-ind ], [ LOCAL.CONT.HOOK.LTOP #larg ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #harg ] ] ]. ; Kim seems to sleep; Kim is sleeping. trans-first-arg-raising-lex-item := basic-two-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX #ind ], [ LOCAL.CONT.HOOK.XARG #ind ] > ]. ; Variant expecting a relation introduced by the raising ; predicate. Adding qeq between ARG1 and LTOP. Can't ; cross-classify with norm-sem-lex-item. ; These can't inherit from basic-verb-lex, since they ; introduce a non-empty HCONS value. Need to get ; event-relation from somewhere else. ; ERB (2007-02-20) They should be able to now that things ; are de-messaged, since basic-verb-lex no longer inherits ; from no-hcons-lex-item. trans-first-arg-raising-lex-item-1 := trans-first-arg-raising-lex-item & [ ARG-ST < [ ], [ LOCAL.CONT.HOOK.LTOP #larg ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL event-relation & [ ARG1 #harg ]]]. ; Variant for raising verbs/auxiliaries which don't ; introduce a predicate of their own. trans-first-arg-raising-lex-item-2 := trans-first-arg-raising-lex-item & raise-sem-lex-item. ; Kim tries to sleep. ; ERB 2007-01-22 Adding in qeq here. trans-first-arg-control-lex-item := basic-two-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind ], [ LOCAL.CONT.HOOK [ XARG #ind, LTOP #larg ] ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind, ARG2 #harg ] ] ]. ; Kim appeared to Sandy to leave, Kim seems to Sandy to have left. ; (Treat "Kim seems happy to Sandy" as derived in some way?) ; ERB 2007-01-22 Adding in qeq here. ditrans-first-arg-raising-lex-item := basic-three-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX #ind1 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind2 ], [ LOCAL.CONT.HOOK [ XARG #ind1, LTOP #larg ] ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind2, ARG2 #harg ] ] ]. ; Kim promised Sandy to leave. ; ERB 2007-01-22 Adding in qeq here. ditrans-first-arg-control-lex-item := basic-three-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind1 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind2 ], [ LOCAL.CONT.HOOK [ XARG #ind1, LTOP #larg ] ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind1, ARG2 #ind2, ARG3 #harg ] ] ]. ; Kim believed Sandy to have left. ; ERB 2007-01-22 Adding in qeq here. distrans-second-arg-raising-lex-item := basic-three-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind1 ], [ LOCAL.CONT.HOOK.INDEX #ind2 ], [ LOCAL.CONT.HOOK [ XARG #ind2, LTOP #larg ] ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind1, ARG2 #harg ] ] ]. ; Kim appealed to Sandy to leave. ; ERB 2007-01-22 Adding in qeq here. ditrans-second-arg-control-lex-item := basic-three-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind1 ], [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind2 ], [ LOCAL.CONT.HOOK [ XARG #ind2, LTOP #larg ] ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind1, ARG2 #ind2, ARG3 #harg ] ] ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; For nouns requiring specifiers, adjectives taking degree specifiers, etc. ; Keep specifiers on ARG-ST because amalgamation constraints are ; stated there. Also, in the eventual hope of implementing ; a binding theory, which seems to need to take account of possessor ; nouns in picture NPs (Runner et al 2004). ; a dog, Kim's dog ; The specifier does not play a semantic role in the 'dog' relation, ; so there is nothing more to say: these can just inherit from ; basic-one-arg and no-hcons-lex-item, and not link in that one ; argument. The head-spec rule identifies the head's HOOK with the ; SPEC..HOOK of the specifier, which gives the specifier access to the ; noun's index for linking purposes. ; a book about dogs ; very fond of apples spr-plus-one-arg-lex-item := basic-two-arg-no-hcons & [ ARG-ST < synsem, [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind ] >, SYNSEM.LKEYS.KEYREL.ARG1 #ind ]. ; the claim that Sandy slept. ; very happy that Sandy slept ; ERB 2007-01-22 Adding qeq in here. spr-plus-clausal-arg-lex-item := basic-two-arg & [ ARG-ST < synsem, [ LOCAL.CONT.HOOK.LTOP #larg ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL.ARG1 #harg ] ]. ; Whether or not we need more types here is going to largely depend ; on whether we treat deverbal nouns semantically as nominalizations, ; and how we handle the linking in that case. Leave this for later. ; Kim is very eager to sleep. ; How eager to sleep is Kim? ; ERB 2007-01-22 Adding qeq in here. spr-trans-first-arg-control-lex-item := basic-three-arg & [ ARG-ST < synsem, [ LOCAL.CONT.HOOK.INDEX ref-ind & #ind ], [ LOCAL.CONT.HOOK [ XARG #ind, LTOP #larg ] ] >, SYNSEM [ LOCAL.CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, LKEYS.KEYREL [ ARG1 #ind, ARG2 #harg ] ] ]. ; Possibly more types related to the above. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Modifiers ; Modifiers which can be used either attributively or predicatively ; identify their XARG with their MOD..IND, so that the modified element ; or the subject play the same role. Assume other constraints will block ; a modifier from picking up a subject (in the ERG, this is done by ; not giving them any SUBJ ever, since adjectives and PPs require ; the support of the copula to function as predicates; in a language ; which doesn't use the copula in these contexts, something else would ; need to be done. attrib-or-pred-lex-item := lex-item & [ SYNSEM.LOCAL [ CAT.HEAD.MOD.FIRST.LOCAL.CONT.HOOK.INDEX #ind, CONT.HOOK.XARG #ind ] ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Part of speech ; These types are meant to cross-classify with the above, but ; many closed-class items have linking constraints which are particular ; to the part of speech class, and so some linking constraints are ; included. ; Bringing in norm-sem-lex-item here where relevant, although this ; might be too stringent. ; ERB 2006-10-05 Temporarily constraining INDEX.MESG to be ; prop-or-ques. This will need to be revisited if we're going to ; allow commands, but look at what ERG does first. ; ERB 2007-01-21 Moving to constructionally introduced SF values. ; Removing that constraint on now defunct feature MESG. basic-verb-lex := norm-sem-lex-item & [ SYNSEM [ LOCAL.CAT.HEAD verb, LKEYS.KEYREL event-relation ]]. ; ERB 2004-08-26 Put in qeq, assuming that for all scopal modifiers ; the relevant argument position is ARG1, and there will be ; no further handle constraints. The latter especially may be ; too strong. ; Adpositions and adjectives (also adverbs, somewhere?) may ; have additional arguments, but the modified element is assumed ; to always be the ARG1. These types should be cross-classified ; with argument structure types appropriate to their combinatoric ; potential. scopal-mod-lex := lex-item & [ SYNSEM [ LOCAL [ CAT.HEAD.MOD < [ LOCAL scopal-mod & [ CONT.HOOK.LTOP #larg ]] >, CONT.HCONS <! qeq & [ HARG #harg, LARG #larg ] !> ], LKEYS.KEYREL.ARG1 #harg ]]. intersective-mod-lex := no-hcons-lex-item & [ SYNSEM [ LOCAL.CAT.HEAD.MOD < [ LOCAL intersective-mod & [ CONT.HOOK.INDEX #ind ]] >, LKEYS.KEYREL.ARG1 #ind ] ]. no-mod-lex := no-hcons-lex-item & [ SYNSEM.LOCAL.CAT.HEAD.MOD < > ]. basic-adjective-lex := single-rel-lex-item & [ SYNSEM [ LOCAL.CAT.HEAD adj, LKEYS.KEYREL event-relation ]]. ; ERB 2007-02-26 New type raise-index-mod-lex-item to get the ; INDEX value right on modifiers. Attributive adjectives should ; inherit from this one, predicatives from norm-hook-lex-item. ; Need to worry about the relationship between the two. basic-mod-adj-lex := basic-adjective-lex & raise-index-mod-lex-item. basic-scopal-mod-adj-lex := basic-mod-adj-lex & scopal-mod-lex. basic-int-mod-adj-lex := basic-mod-adj-lex & intersective-mod-lex. basic-nomod-adj-lex := basic-adjective-lex & no-mod-lex & norm-hook-lex-item. basic-adposition-lex := single-rel-lex-item & [ SYNSEM [ LOCAL.CAT.HEAD adp, LKEYS.KEYREL event-relation ]]. basic-mod-adp-lex := basic-adposition-lex & raise-index-mod-lex-item. basic-scopal-mod-adposition-lex := basic-mod-adp-lex & scopal-mod-lex. basic-int-mod-adposition-lex := basic-mod-adp-lex & intersective-mod-lex. basic-nomod-adposition-lex := basic-adposition-lex & no-mod-lex & norm-hook-lex-item. basic-adverb-lex := raise-index-mod-lex-item & single-rel-lex-item & [ SYNSEM [ LOCAL.CAT.HEAD adv, LKEYS.KEYREL event-relation ]]. basic-scopal-adverb-lex := basic-adverb-lex & scopal-mod-lex. basic-int-adverb-lex := basic-adverb-lex & intersective-mod-lex. ; Anticipate subtypes of basic-noun-lex for common nouns, ; proper nouns, and pronouns. All are treated as norm-sem-lex-item ; (i.e., only introducing a single relation, and no H-CONS). One ; might think otherwise based on canonical examples from familiar ; languages in which pronouns and proper nouns don't have determiners. ; However, even in languages like English, we find examples like ; "The Kim that I know is younger than the one that you know." ; So, rather than build the quantifier for proper nouns/pronouns ; into the lexical entry, use (potentially obligatory) non-branching ; rules to introduce the quantifier and discharge the SPR requirement. basic-noun-lex := norm-sem-lex-item & [ SYNSEM [ LOCAL.CAT.HEAD noun, LKEYS.KEYREL noun-relation ]]. ; Note the use of the feature SPEC in basic-determiner-lex. ; This is important semantically to allow the determiner to grab ; onto the INDEX and LTOP of the N' it combines with. Elsewhere ; in the lexical types we have avoided mentioning the valence features, ; believing the mapping from ARG-ST to valence features to be somewhat ; language-specific. In this case, however, it does not concern ; a mapping to ARG-ST. basic-determiner-lex := norm-hook-lex-item & [ SYNSEM [ LOCAL [ CAT [ HEAD det, VAL.SPEC.FIRST.LOCAL.CONT.HOOK [ INDEX #ind, LTOP #larg ]], CONT [ HCONS <! qeq & [ HARG #harg, LARG #larg ] !>, RELS <! relation !> ] ], LKEYS.KEYREL quant-relation & [ ARG0 #ind, RSTR #harg ] ] ]. ; Subordinating conjunctions take two clauses, one as an argument ; (i.e., element of ARG-ST) and one as modifiee. We allow quantifiers ; to scope between the messages of the clauses and the subord-relation ; in order to capture the ambiguity of: ; No one drinks coffee because it tastes good. ; We are interested in examples from languages where the analogous ; sentence is not analogously ambiguous. ; No hypothesis yet about the HEAD value of these cross-linguistically. ; ERB 2007-01-21 Quickly trying to bring this into the non-message ; universe. I'm not sure why we needed space bewteen the subord-relation ; and the messages, nor if the equivalent thing can't be modeled without ; messages. Isn't enough for the quantifiers to be able to out-scope ; the subord-relation? ; basic-subord-conjunction-lex := basic-one-arg & ; [ ARG-ST < [ LOCAL.CONT.HOOK.LTOP #ltop1 ] >, ; SYNSEM [ LOCAL [ CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.LTOP #ltop2 ] >, ; CONT [ HCONS <! qeq & ; [ HARG #harg, ; LARG #larg ] !>, ; RELS <! relation, ; message & ; [ LBL #msg, ; PRED proposition_m_rel, ; MARG #harg ] !>, ; HOOK [ LTOP #msg ] ] ], ; LKEYS.KEYREL subord-relation & ; [ LBL #larg, ; L-HNDL #ltop1, ; R-HNDL #ltop2 ] ] ]. basic-subord-conjunction-lex := basic-one-arg & [ ARG-ST < [ LOCAL.CONT.HOOK.LTOP #ltop1 ] >, SYNSEM [ LOCAL [ CAT.HEAD.MOD < [ LOCAL.CONT.HOOK.LTOP #ltop2 ] >, CONT [ HCONS <! !>, RELS <! relation !>, HOOK [ LTOP #ltop ] ] ], LKEYS.KEYREL subord-relation & [ LBL #ltop, L-HNDL #ltop1, R-HNDL #ltop2 ] ] ]. ; Coming soon: ; Lexical type for negative particles like English "not" ; Lexical type for WH elements ; Documentation listing the phenomena handled by these lexical types. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Coordination (added by sfd 08/02/2005) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Two relations used in coordination: ; ; implicit-coord-rel: used when there's no overt conjunction (or ; morpheme) providing the coordination relation. ; ; null-coord-rel: used when a conjunction contributes *no* relation. implicit-coord-rel := coordination-relation & [ PRED 'implicit_coord_rel ]. null-coord-rel := coordination-relation & [ PRED 'null_coord_rel ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Conjunction parts of speech conj-lex := basic-zero-arg & single-rel-lex-item & no-hcons-lex-item & [ CFORM string, SYNSEM [ LOCAL [ CAT [ HEAD conj & [ MOD null ], VAL [ SPR < >, COMPS < >, SUBJ < > ]], CONT [ HOOK [ LTOP #ltop, INDEX #index ], RELS.LIST.FIRST #keyrel ]], LKEYS.KEYREL #keyrel & coordination-relation & [ LBL #ltop, C-ARG #index ]]]. ; A nosem-conj-lex is a conjunction that contributes no relation. ; Used below in "omnisyndeton" coordination. nosem-conj-lex := basic-zero-arg & no-hcons-lex-item & [ SYNSEM [ LOCAL [ CAT [ HEAD conj & [ MOD null ], VAL [ SPR < >, COMPS < >, SUBJ < > ]], CONT.RELS <! !> ]]]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Coordination phrases and rules coord-phrase := binary-phrase & [ SYNSEM.LOCAL [ COORD-STRAT #cstrat, CAT [ HEAD.MOD #mod, VAL #val ]], LCOORD-DTR #ldtr & sign & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ]]], RCOORD-DTR #rdtr & sign & [ SYNSEM.LOCAL [ COORD-STRAT #cstrat, CAT [ HEAD.MOD #mod, VAL #val ]]], ARGS < #ldtr, #rdtr > ]. topormid-coord-phrase := coord-phrase & [ C-CONT.HOOK [ LTOP #lbl, INDEX #carg ], LCOORD-DTR.SYNSEM.LOCAL.CONT.HOOK.INDEX #lind, RCOORD-DTR.SYNSEM.LOCAL [ COORD-REL [ LBL #lbl, C-ARG #carg, L-INDEX #lind, R-INDEX #rind ], CONT.HOOK.INDEX #rind ]]. top-coord-rule := topormid-coord-phrase & [ SYNSEM.LOCAL.COORD - ]. mid-coord-rule := topormid-coord-phrase & [ SYNSEM.LOCAL [ COORD +, COORD-REL implicit-coord-rel ]]. bottom-coord-phrase := phrase & [ CONJ-DTR sign, NONCONJ-DTR sign ]. unary-bottom-coord-rule := bottom-coord-phrase & unary-phrase & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD +, COORD-REL #crel ], C-CONT [ HOOK [ INDEX #rind ], RELS <! #crel !>, HCONS <! !> ], NONCONJ-DTR sign & #ncdtr, ARGS < #ncdtr & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD -, CONT.HOOK [ INDEX #rind ]]] > ]. ;;; ERB 2007-05-16 Note for sfd: There is probably a single type ;;; you could inherit from here that combines what you need. infl-bottom-coord-rule := same-local-lex-rule & same-non-local-lex-rule & same-modified-lex-rule & same-light-lex-rule & inflecting-lex-rule & [ INFLECTED +, DTR.INFLECTED -, SYNSEM.LOCAL [ COORD +, COORD-REL #crel ], C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. binary-bottom-coord-rule := bottom-coord-phrase & binary-phrase & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD +, COORD-REL #crel, COORD-STRAT #cform ], C-CONT [ HOOK [ INDEX #rind ], RELS <! !>, HCONS <! !> ], CONJ-DTR conj-lex & [ CFORM #cform, SYNSEM.LKEYS.KEYREL #crel ], NONCONJ-DTR sign & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD -, CONT.HOOK [ INDEX #rind ]]]]. conj-first-bottom-coord-rule := binary-bottom-coord-rule & [ CONJ-DTR #cdtr, NONCONJ-DTR #ncdtr, ARGS < #cdtr, #ncdtr > ]. conj-last-bottom-coord-rule := binary-bottom-coord-rule & [ CONJ-DTR #cdtr, NONCONJ-DTR #ncdtr, ARGS < #ncdtr, #cdtr > ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; *syndeton rules: Rules that describe the different kinds of marking ; strategies used for coordination in various languages. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; monopoly*: Mandatory monosyndeton with optional polysyndeton. This ; is the familiar Indo-European pattern, in which at least one ; coordinator is mandatory ("A B and C") and more than one is possible ; ("A and B and C"). monopoly-top-coord-rule := top-coord-rule & [ LCOORD-DTR.SYNSEM.LOCAL.COORD -, RCOORD-DTR.SYNSEM.LOCAL.COORD + ]. monopoly-mid-coord-rule := mid-coord-rule & [ LCOORD-DTR.SYNSEM.LOCAL.COORD -, RCOORD-DTR.SYNSEM.LOCAL.COORD + ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; apoly: These rules handle two coordination strategies: ; ; Asyndeton, in which no coordinators appear: "A B C". ; ; Polysyndeton, in which an N-way coordination is marked with N-1 ; coordinators: ; "A and B and C", not "A B and C" ; ; For both of these, there is NO MID RULE. The difference between ; them is captured in the bottom rule: asyndeton will have a unary ; (and non-inflecting) bottom rule. apoly-top-coord-rule := top-coord-rule & [ LCOORD-DTR.SYNSEM.LOCAL.COORD -, RCOORD-DTR.SYNSEM.LOCAL.COORD + ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; omni: This handles a variety of polysyndeton, called here for ; clarity "omnisyndeton", in which for an N-way coordination, N ; coordinators are required: ; ; "and A and B and C" or "A and B and C and". ; ; This coordination strategy requires a significantly approach than ; the others. Rather than a single kind of bottom rule, there are two ; kinds. The first kind, still called "bottom", handles the single ; lowest (rightmost) coordinand. The other kind, called "left", ; handles all other coordinands (it's called "left" because it is ; always the left daughter of a top- or mid- rule). Because there are ; N coordinators for N coordinands in this strategy, one of the ; conjunctions must contribute *no* coordination relation, or else ; we'd have too many. The bottom rule is the exceptional one: it ; requires that its conjunction daughter be of type nosem-conj-lex. ; ; The mid- and top- rules are also slightly different from the other ; coordination strategies, in that they take the COORD-REL from the ; *left* daughter instead of the right. omni-binary-bottom-coord-rule := bottom-coord-phrase & binary-phrase & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD +, COORD-REL null-coord-rel ], C-CONT [ HOOK [ INDEX #rind ], RELS <! !>, HCONS <! !> ], CONJ-DTR nosem-conj-lex, NONCONJ-DTR sign & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD -, CONT.HOOK [ INDEX #rind ]]]]. omni-conj-first-bottom-coord-rule := omni-binary-bottom-coord-rule & [ CONJ-DTR #cdtr, NONCONJ-DTR #ncdtr, ARGS < #cdtr, #ncdtr > ]. omni-conj-last-bottom-coord-rule := omni-binary-bottom-coord-rule & [ CONJ-DTR #cdtr, NONCONJ-DTR #ncdtr, ARGS < #ncdtr, #cdtr > ]. omni-left-coord-rule := bottom-coord-phrase. omni-binary-left-coord-rule := omni-left-coord-rule & binary-phrase & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD -, COORD-REL #crel ], C-CONT [ HOOK [ INDEX #rind ], RELS <! !>, HCONS <! !> ], CONJ-DTR conj-lex & [ SYNSEM.LKEYS.KEYREL #crel ], NONCONJ-DTR sign & [ SYNSEM.LOCAL [ CAT [ HEAD.MOD #mod, VAL #val ], COORD -, CONT.HOOK [ INDEX #rind ]]]]. omni-conj-first-left-coord-rule := omni-binary-left-coord-rule & [ CONJ-DTR #cdtr, NONCONJ-DTR #ncdtr, ARGS < #cdtr, #ncdtr > ]. omni-conj-last-left-coord-rule := omni-binary-left-coord-rule & [ CONJ-DTR #cdtr, NONCONJ-DTR #ncdtr, ARGS < #ncdtr, #cdtr > ]. ;;; ERB 2007-05-16 Note for sfd: There is probably a single type ;;; you could inherit from here that combines what you need. infl-left-coord-rule := omni-left-coord-rule & same-modified-lex-rule & same-light-lex-rule & same-local-lex-rule & same-non-local-lex-rule & inflecting-lex-rule & [ INFLECTED +, DTR.INFLECTED -, SYNSEM.LOCAL [ COORD -, COORD-REL #crel ], C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. omni-coord-phrase := coord-phrase & [ C-CONT.HOOK [ LTOP #lbl, INDEX #carg ], LCOORD-DTR omni-left-coord-rule & [ SYNSEM.LOCAL [ COORD-REL [ LBL #lbl, C-ARG #carg, L-INDEX #lind, R-INDEX #rind ], CONT.HOOK.INDEX #lind ]], RCOORD-DTR.SYNSEM.LOCAL [ COORD +, CONT.HOOK.INDEX #rind ]]. omni-top-coord-rule := omni-coord-phrase & [ SYNSEM.LOCAL.COORD - ]. omni-mid-coord-rule := omni-coord-phrase & [ SYNSEM.LOCAL.COORD + ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; N Coordination rules n-coord-phrase := coord-phrase & [ SYNSEM.LOCAL.CAT.VAL.SPR < [ ] >, SYNSEM.LOCAL.CAT.HEAD noun, LCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD noun, RCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD noun ]. basic-n-top-coord-rule := n-coord-phrase & [ SYNSEM.LOCAL.CAT.VAL.SPR < [ ] >, C-CONT [ RELS <! !>, HCONS <! !> ]]. basic-n-mid-coord-rule := n-coord-phrase & [ SYNSEM.LOCAL.COORD-REL #crel, C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. n-bottom-coord-phrase := bottom-coord-phrase & [ SYNSEM.LOCAL.CAT [ HEAD noun, VAL.SPR < [ ] > ], NONCONJ-DTR.SYNSEM.LOCAL.CAT [ HEAD noun, VAL.SPR < [ ] > ]]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; NP Coordination rules np-coord-phrase := coord-phrase & [ SYNSEM.LOCAL.CAT.VAL.SPR < >, SYNSEM.LOCAL.CAT.HEAD noun, LCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD noun, RCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD noun ]. basic-np-top-coord-rule := np-coord-phrase & [ SYNSEM.LOCAL.CAT.VAL.SPR < >, C-CONT [ HOOK [ LTOP #ltop, INDEX #ind ], RELS <! [ PRED "exist_q_rel", ARG0 #ind, RSTR #ltop ] !>, HCONS <! !> ]]. basic-np-mid-coord-rule := np-coord-phrase & [ SYNSEM.LOCAL.COORD-REL #crel, C-CONT [ RELS <! [ ARG0 #carg, RSTR #lbl ], #crel !>, HCONS <! !> ], RCOORD-DTR.SYNSEM.LOCAL.COORD-REL [ LBL #lbl, C-ARG #carg ]]. np-bottom-coord-phrase := bottom-coord-phrase & [ SYNSEM.LOCAL.CAT [ HEAD noun, VAL.SPR < > ], NONCONJ-DTR.SYNSEM.LOCAL.CAT [ HEAD noun, VAL.SPR < > ]]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Event Coordination rules (for verbs and adjectives) event-coord-phrase := coord-phrase & [ SYNSEM.LOCAL.CONT.HOOK.INDEX [ E #tam ], LCOORD-DTR.SYNSEM.LOCAL.CONT.HOOK.LTOP #lhndl, RCOORD-DTR.SYNSEM.LOCAL [ COORD-REL [ L-HNDL #lhndl, R-HNDL #rhndl, R-INDEX.E #tam ], CONT.HOOK.LTOP #rhndl ]]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ADJ Coordination rules adj-coord-phrase := event-coord-phrase & [ SYNSEM.LOCAL.CAT [ POSTHEAD #ph, HEAD adj ], LCOORD-DTR.SYNSEM.LOCAL.CAT [ POSTHEAD #ph, HEAD adj ], RCOORD-DTR.SYNSEM.LOCAL.CAT [ POSTHEAD #ph, HEAD adj ]]. basic-adj-top-coord-rule := adj-coord-phrase & [ C-CONT [ RELS <! !>, HCONS <! !> ]]. basic-adj-mid-coord-rule := adj-coord-phrase & [ SYNSEM.LOCAL.COORD-REL #crel, C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. adj-bottom-coord-phrase := bottom-coord-phrase & [ SYNSEM.LOCAL.CAT.HEAD adj, NONCONJ-DTR.SYNSEM.LOCAL.CAT.HEAD adj ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ADV Coordination rules adv-coord-phrase := event-coord-phrase & [ SYNSEM.LOCAL.CAT [ POSTHEAD #ph, HEAD adv ], LCOORD-DTR.SYNSEM.LOCAL.CAT [ POSTHEAD #ph, HEAD adv ], RCOORD-DTR.SYNSEM.LOCAL.CAT [ POSTHEAD #ph, HEAD adv ]]. basic-adv-top-coord-rule := adv-coord-phrase & [ C-CONT [ RELS <! !>, HCONS <! !> ]]. basic-adv-mid-coord-rule := adv-coord-phrase & [ SYNSEM.LOCAL.COORD-REL #crel, C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. adv-bottom-coord-phrase := bottom-coord-phrase & [ SYNSEM.LOCAL.CAT.HEAD adv, NONCONJ-DTR.SYNSEM.LOCAL.CAT.HEAD adv ]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; VP Coordination rules vp-coord-phrase := event-coord-phrase & [ SYNSEM.LOCAL.CAT.VAL.SUBJ < [ ] >, SYNSEM.LOCAL.CAT.HEAD verb, LCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD verb, RCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD verb ]. basic-vp-top-coord-rule := vp-coord-phrase & [ C-CONT [ RELS <! !>, HCONS <! !> ]]. basic-vp-mid-coord-rule := vp-coord-phrase & [ SYNSEM.LOCAL.COORD-REL #crel, C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. vp-bottom-coord-phrase := bottom-coord-phrase & [ SYNSEM.LOCAL.CAT [ HEAD verb, VAL.SUBJ < [ ] > ], NONCONJ-DTR.SYNSEM.LOCAL.CAT [ HEAD verb, VAL.SUBJ < [ ] > ]]. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; S Coordination rules s-coord-phrase := event-coord-phrase & [ SYNSEM.LOCAL.CAT.VAL.SUBJ < >, SYNSEM.LOCAL.CAT.HEAD verb, LCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD verb, RCOORD-DTR.SYNSEM.LOCAL.CAT.HEAD verb ]. basic-s-top-coord-rule := s-coord-phrase & [ C-CONT [ RELS <! !>, HCONS <! !> ]]. basic-s-mid-coord-rule := s-coord-phrase & [ SYNSEM.LOCAL.COORD-REL #crel, C-CONT [ RELS <! #crel !>, HCONS <! !> ]]. s-bottom-coord-phrase := bottom-coord-phrase & [ SYNSEM.LOCAL.CAT [ HEAD verb, VAL.SUBJ < > ], NONCONJ-DTR.SYNSEM.LOCAL.CAT [ HEAD verb, VAL.SUBJ < > ]].