fundamentals.tdl

;;; -*- Mode: tdl; Coding: utf-8; -*-
;;;
;;;  Copyright (c) 1994-2018
;;;    Dan Flickinger, Rob Malouf, Emily M. Bender
;;;    see LICENSE for conditions
;;;
;;;  fundamentals.tdl
;;;
;;;  Basic definitions of types for English grammar
;;;
;;;  Rob Malouf, 3-Nov-1994
;;;
;;;  $Id: fundamentals.tdl 7479 2010-02-21 23:11:30Z danf $


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Types for Sign, Word, Phrase, and Lex-Entry

sign_min := *avm* &
  [ SYNSEM synsem_min,
    KEY-ARG bool ].

;; GENRE used to control variations in grammaticality, e.g. for edited
;; vs informal text, but subsuming earlier boolean ROBUST feature so we
;; can accommodate some ill-formed input such as missing det for sg-noun.
;; IDIOM marks whether a sign contains an idiomatic element.
;; --SIND is re-entrant with HOOK.INDEX, to help modularize path specs,
;; and to delay expansion of subcategorizations until necessary.
;; DPF 2020-02-11 - To avoid dependence on sign type unif failure for phrases 
;; (such as avoiding N-N compound as input to punctuation rule), make 
;; [DERIVED luk] an attribute of sign, and make phrase be [DERIVED na].  Also
;; stamp na value on most lexical entries with orthography "/" to block prefix
;; punctuation, so as to force fw-sequence analysis for e.g. |"/Desktop/blue"|
;;
sign := sign_min &
  [ SYNSEM synsem &
           [ LOCAL [ CAT.HEAD.MINORS.MIN #min,
                     CONT.HOOK.INDEX #index ],
             --MIN #min,
             --SIND #index ],
    ORTH orthog,
    ARGS *list*,
    INFLECTD luk,
    GENRE genre,
    DIALECT dialect,
    IDIOM bool,
    DERIVED luk,
    RNAME basic_ctype,
    CONCEPTS *list* ].

;; DPF 2012-10-30 - Changed value of RNAME to ctype rather than string, to
;; support better interaction with tokenization

phrase_or_lexrule := sign &
  [ SYNSEM canonical_synsem &
	   [ LOCAL.CONT.HOOK #hook ],
    ORTH.FROM #from,
    C-CONT mrs_min & [ HOOK #hook ],
    ARGS.FIRST.ORTH.FROM #from ].

word_or_lexrule_min := sign_min.

;; DERIVED distinguishes basic from derived words, so the foreign-word-sequence
;; rules can avoid some spurious ambig.
;;
word_or_punct_or_bracketed_phrase := sign.

;; Needed to enable punctuation tokens like dashes (which normally attach
;; only to lexical items) to attach to bracketed phrases formed by the syntactic
;; rule combining hyphenated tokens such as |read- only|
;;
word_or_bracketed_phrase := word_or_punct_or_bracketed_phrase.

word_or_punct_phrase := word_or_punct_or_bracketed_phrase.

; ALTS allow lexical entries to block lexical rule application
;
word_or_lexrule := word_or_lexrule_min & word_or_bracketed_phrase &
		   non_unary-rule & word_or_punct_phrase &
  [ ALTS alts_min,
    TOKENS tokens,
    SYNSEM.LOCAL.CAT.--SLASHED.BOOL - ].

; Group 'word' together with punctuation rules to distinguish basic words from
; derived or inflected forms - used at least in the rule for italicized or
; foreign word sequences.

word_or_infl_or_punct_rule := word_or_lexrule.
word_or_punct_rule := word_or_infl_or_punct_rule.
word_or_nonpunct_rule := word_or_lexrule.
word_or_infl_rule := word_or_infl_or_punct_rule & word_or_nonpunct_rule.

basic_word := word_or_infl_rule & word_or_punct_rule &
  [ SYNSEM [ PHON.ONSET.--TL #tl,
	     LKEYS.KEYREL [ CFROM #from,
			    CTO #to ] ],
    ORTH [ CLASS #class, FROM #from, TO #to, FORM #form ],
    TOKENS [ +LIST #tl & < [ +CLASS #class, +FROM #from, +FORM #form ], ... >,
	     +LAST.+TO #to ] ].

word := basic_word &
  [ SYNSEM.PUNCT.PNCTPR ppair ].

orthog := *cons* &
[ FORM string,
  FROM string,
  TO string ].

orthography := orthog &
[ CLASS token_class ].

; 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.

; DPF 02-Sept-00 - Removed [ HC-LEX - ] because it blocks conjoined lexical
; somethings.
;; DPF 2020-05-13 - Moved identity of ONSET on mother and first dtr down to 
;; subtypes, since for the n-num measure-NP rule for |an $800 phone|, the ONSET
;; comes from the right dtr.
;; DPF 2022-08-18 - For now, limit to at most one gap.
;;
phrase := phrase_or_lexrule &
  [ SYNSEM [ LOCAL.ARG-S < >,
	     NONLOC.SLASH.LIST 0-1-list ],
    DERIVED na ].

;; Used to disambiguate bracketed phrases, whose daughter can either be a
;; non_unary_phrase or a lexical rule.
;;
non_unary-rule := phrase_or_lexrule.

; DPF (09-Jan-99) - Added boolean LEX feature to be used for determining the
; head-complement type of the projections of lexical heads - most produce 
; phrases, but see discussion of HC-LEX feature below.

synsem_min := *avm*.

synsem_min0 := synsem_min &
  [ LOCAL mod_local,
    NONLOC non-local_min ].

synsem_min1 := synsem_min0 &
  [ OPT bool,
    --MIN predsort,
    --SIND *top* ].

synsem_min2 := synsem_min1 &
  [ LEX luk,
    MODIFD xmod_min,
    PHON phon_min,
    PUNCT punctuation_min ].

lex_or_phrase := synsem_min2.

synsem := synsem_min2.

expressed_synsem := synsem.

; No gaps
canonical_or_unexpressed := synsem_min0.

canonical_synsem := expressed_synsem & canonical_or_unexpressed.

;; DPF 2015-07-07 - Added --BRDG to record whether a bridging rule has applied,
;; to enable blocking of iteration of bridging rules, for efficiency
;;
canonical_lex_or_phrase_synsem := canonical_synsem & lex_or_phrase &
 [ --BRDG luk ].
    
; Type which enables exclusion of phrases like n-n compounds which are built
; by rule but have similar distribution to lexical signs.
lex_or_nonlex_synsem := canonical_lex_or_phrase_synsem.

; To distinguish syntactically constructed constituents marked LEX + from
; simple lexical entries - used e.g. to avoid making nominal gerund NPs
; directly from lexical gerunds, to avoid spurious ambiguity for
; 'Singing is fun' given that there is already a verbal gerund 'singing'.

nonlex_or_lex_phr_synsem := canonical_lex_or_phrase_synsem.
nonlex_synsem := lex_or_nonlex_synsem & nonlex_or_lex_phr_synsem.

;; Used for passive lexical rule to exclude |*looked by Kim up|
phr_synsem := nonlex_synsem &
  [ LEX - ].

;; DPF 2017-08-20 - We need yet another level of abstraction here, to enable
;; derived attrib adjectives to constrain their synsem type to be incompatible
;; with abstr_lex_synsem, to ensure that prefix-adj rules apply first, while
;; still letting attr_adj rule constrain LKEYS.
;;
;; LKEYS provide shortcuts to relations in RELS or a lex-entry's complements
;;
abstr_lex_or_deriv_synsem := canonical_lex_or_phrase_synsem &
  [ LKEYS lexkeys ].

abstr_lex_synsem := abstr_lex_or_deriv_synsem.
    
basic_lex_synsem := abstr_lex_synsem & lex_or_nonlex_synsem.

lex_synsem := basic_lex_synsem &
  [ LEX + ].

; For signs that are constructed by syntactic rule but have similar
; (though not identical) distribution to lexical items - e.g. n_n_cmpnds.
lex_phr_synsem := abstr_lex_synsem & nonlex_or_lex_phr_synsem &
  [ LEX + ].

; For signs that have combined with a punctuation mark, and hence are no longer
; eligible to undergo most derivational rules, to avoid spurious ambiguity.
lex_punct_synsem := basic_lex_synsem.

; DPF 29-Nov-02 - Removed [INDEX non_expl] to allow "There was known to be a
; problem" where pred "was" requires complement to be SUBJ *olist*.
non_canonical := synsem.
expressed_non_canonical := non_canonical & expressed_synsem &
  [ NONLOC [ REL.LIST < >,
             QUE.LIST < > ] ].

gap := expressed_non_canonical &
  [ LOCAL #local,
    NONLOC.SLASH.LIST < #local > ].

unexpressed_min := canonical_or_unexpressed.
unexpressed := unexpressed_min & synsem_min2 &
  [ LOCAL.CAT.VAL.SPCMPS < >,
    NONLOC [ SLASH.LIST < >,
             REL.LIST < >,
             QUE.LIST < > ] ].

unexpressed_reg := unexpressed & non_canonical.

; DPF 28-Aug-99 - Removed OPT + from anti_synsem since it blocked 
; "you can have anything you want"
anti_synsem_min := unexpressed_min.
anti_synsem := anti_synsem_min & unexpressed.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CAT type

;; The feature MC has three possible values: +, -, and na.  Non-clauses are
;; always MC na, since they can't really be said to be root or non-root.
;; All clauses are MC bool, and if they have a restricted distribution then
;; they are MC + or MC -.

local_basic := local_min &
  [ CONJ conj_min ].

local := local_basic &
  [ CTXT ctxt_min,
    ARG-S *list* ].

; Distinguish arg gaps from modifier gaps, to constrain ATB extraction to args
arg-local := local.
mod-local := local.

;;  SLASH list-wrapper & [ LIST *locallist* ],
non-local := non-local_min &
  [ SLASH list-wrapper,
    QUE list-wrapper,
    REL list-wrapper ].

non-local_norel := non-local &
  [ REL.LIST < >,
    QUE.LIST < > ].

non-local_none := non-local_norel &
  [ SLASH.LIST < > ].

;; DPF 2020-05-09 - We need to distinguish between non-local_none for use in
;; lexical type definition, where due to lexical threading of NONLOC, we can't
;; stamp LIST < > on each 0-dlist, and the stronger subtype we want for 
;; constructions, where we really want an assertion of 0-dlist to entail 
;; LIST < >.
non-local_none_phr := non-local_none &
  [ SLASH.LIST < >,
    REL.LIST < >,
    QUE.LIST < > ].

;; For exceptions to lexical rules
;;
alts_min := *avm*.
alts := alts_min &
  [ PASSIVE bool,
    VPELLIP bool,
    ADVADD bool,
    ADVNGADD bool,
    NPPART bool,
    VADJ bool,
    NGER bool,
    SQPNCT bool,
    VPREF bool,
    DATIVE bool,
    ATTRJ bool,
    SAI bool,
    CSAI bool,
    TOUGH bool,
    JTOR bool,
    INVQ bool,
    CPFRAG bool,
    ENOUGH bool,
    DETPART bool,
    MWEWB bool,
    UNADJ bool ].
no_alts := alts_min.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Synsem values

; The feature AGR is introduced on LOCAL rather than on CAT (or on HEAD) since
; coordination schema unify the CAT value of the daughters with that of then
; mother, but need to be able to change AGR on the mother (to get plural 
; agreement on verb when subject is a coordinated NP with "and" vs. "or").  

cat_min := *avm*.

;; DPF (22-Oct-98) Added feature HC-LEX ("is head-complement type lexical?")
;; on CAT, to identify the type of synsem that results from combining the word 
;; with its complements.  We recognize at least the head-complement 
;; structures  "thirty-two" and "two o'clock" as still being lexical signs, not
;; phrasal ones, since they can appear as prenominal adjectives and in noun-
;; noun compound constructions, respectively.  The head-complement rule 
;; determines its SYNSEM type by unifying its LEX value with the HC-LEX of
;; its head dtr - this works because the HCOMP rule requires its SYNSEM value to
;; be of type canonical_synsem, and the subtypes of canonical_synsem are the
;; only types that introduce the feature LEX, namely lex_synsem and phr_synsem.

; DPF 2-Jun-02 - Similarly, words differ in whether the head-specifier
; construction they head is lexical or phrasal: det+noun is phrasal to avoid
; allowing e.g. "*my the sony laptop arrived" but deg+adj is still lexical to
; avoid "*the children very small arrived" (given other constraints for each
; of these two constructions).  So introduce HS-LEX value.
;;
cat_min1 := cat_min &
  [ HEAD head_min,
    VAL valence_min ].

; DPF 24-apr-08 - Added NEGPOL to distinguish negative polarity effects,
; especially to license declarative subj-aux inversion as in "Not until
; today did Kim see the point."
;; DPF 2020-04-30 - It seems that we need to allow a complement to constrain
;; the LEX value of the head-comp phrase, for example to block
;; |a tall enough to see building| while keeping |a tall enough building to see|
;; where |tall| in either NP picks up |enough|, staying underspecified for LEX,
;; but if the AP picks up the VP marked with NH-LEX -, it becomes LEX - and
;; hence disallowed as prenominal; while if instead the Nbar picks up the VP,
;; the prenominal AP remains compatible with LEX +.
;; DPF 2022-04-26 - After relaxing constraints on the copula's subject in order
;; to analyze "In the corner was standing a coatrack" with a raised PP subject,
;; we need additional machinery to still constrain ordinary copula constructions
;; with APs and PPs, which have an empty SUBJ value but appear with an NP for
;; the subject of the clause.  And we want to preserve using the same copula
;; with VPs and with APs and PPs, to analyze "They were singing and happy".
;; So to give the copula a consistent source of the constraints on subject
;; consistent with the copula's complement, we add a HEAD feature RSUBJHD which
;; will be identified with SUBJ..HEAD for verbs, and stipulated to be nominal
;; for adjectives and non-scopal prepositions.
;; DPF 2022-11-12 - Added --SLASHED to record whether a phrase contains a gap,
;; to help with packing, since the use of ET computation types for SLASH makes
;; it harder using subsumption to avoid packing a slashed and a non-slashed
;; constituent, given lexical threading for SLASH.  Also added boolean --SLPASS
;; to enable marking of tough-adjectives to block passing of --SLASHED, so
;; head-comp phrase "easy to please" gets [--SLASHED -] even though the non-hd
;; daughter is slashed.  It proved necessary to make sure --SLPASS is given a
;; specific value on every element of every COMPS list in lextypes.tdl, since
;; the computation of --SLASHED on the mother of the head-comp rule assigns the
;; value of --SLPASS from the complement in case neither head nor comp is
;; --SLASHED.
;;
cat := cat_min1 &
  [ MC luk,
    POSTHD bool,
    HC-LEX luk,
    HS-LEX luk,
    NH-LEX luk,
    NEGPOL luk,
    RSUBJHD head_min,
    --SLASHED bool-wrapper,
    --SLPASS bool ].

local_min1 := mod_local &
  [ CAT cat_min ].

local_min2 := mod_local &
  [ CONT mrs_min ].

local_min := local_min1 & local_min2 &
  [ AGR *top* ].

non-local_min := *avm*.

phon_min := *avm*.
phon := phon_min &
  [ ONSET onset ].

onset := *sort* &
[ --TL *list* ].
con_or_unk := onset.
voc_or_unk := onset.
con_or_voc := onset &
[ --TL native_token_list ].
con := con_or_unk & con_or_voc.
voc := voc_or_unk & con_or_voc.
; For unknown words
unk_onset := con_or_unk & voc_or_unk &
[ --TL generic_token_list ].

;; DPF 2020-04-25 - Added subtype no_onset used in specialized rule mnp-vp_jp_c
;; for |10% owned by IBM|, restricted to just meas-NPs with `%', which has
;; [ONSET onset], so will unify with no_onset, but other measure nouns won't.
;;
no_onset := onset.

phon_num := phon &
  [ DIGIT bool ].

basic_ctype := *sort*.
unary_ctype := basic_ctype.
ctype := basic_ctype & [ -CTYPE- string ].
anti_ctype := basic_ctype.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 
;;
;;  Head and valence
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

mod_local := *avm*.

; The MOD value specifies the type of phrase that a sign can modify, and the
; POSTHD value stipulates the relative position of the modifier with
; respect to the head.  (An earlier approach employing a generalization about
; a head being final in its phrase or not might still be considered as an
; alternate to this stipulative one.)
; The POSTHD feature should stay with MOD, since only relevant when MOD is
; non-empty.

; DPF 09-Jan-99 - Changed value of MOD to be of type synsem rather than type
; local, since some modifiers (like vocative NPs) only modify SLASH-empty
; phrases, which means they have to have access to the NONLOC feature of
; the phrase they modify.

head_min := *avm*.

; DPF 16-Aug-99 - Added INV to head type, since need to distinguish root
; from non-root phrases as output from parser, and since inverted S's now have
; MSG empty, we have to require all non-root fragments to be INV -.
; DPF 09-sept-07 - With the departure of messages, we can now push INV back
; down to verb_or_frag.
; TAM likewise can be pushed down to non-noun subtype.
; AUX has to be here as long as we want PPs to avoid attaching to aux-headed
; phrases, since they can also modify nouns.
;; DPF 2013-06-14 - Need to pull INV back up to `head' since the hd-cmp_2_c
;; rule restricts the head to be non-inverted if a verb, but we also want to
;; use this rule for other head types, as in |further than Browne from Abrams|
;; DPF 2020-03-25 - Re 09-sept-07: In extracted-adjunct type, TAM is constrained
;; for a head of type `mobile', whose subtypes include `noun'.  So pulling TAM
;; back up to `head'.
;;
head := head_min &
  [ MOD *list*,
    PRD bool,
    MINORS minors_basic,
    AUX luk,
    INV bool,
    TAM tam_min,
    CASE case ].

valence_min := *avm*.

valence := valence_min &
  [ SUBJ *list*,
    SPR *list*,
    COMPS *list* ].

;; DPF 2016-11-09 - Constrain SPCMPS to be 0-1-list, to avoid endless optcomp
;; spinning in the cases where the grammar neglects to constrain SPCMPS.
valence_sp := valence &
  [ SPEC *list*,
    SPCMPS 0-1-list ].

; KCMP is a pointer to a distinguished ('key') complement synsem, used in
; generalizations within the lexical type hierarchy, but not present in the
; syntax.
valence_lex := valence_sp &
  [ KCMP *avm* ].

;; DPF 2015-05-06 - KCMP2 is a second-complement specification, used in the
;; definition of day-of-month lexical types.
;;
valence2_lex := valence_lex &
  [ KCMP2 *avm* ].


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Head types

; POSS is akin to CASE, distinguishing possessive-marked NPs from ordinary NPs,
; a contrast needed for e.g. the adjective "own" which can only appear in
; phrases with a possessive NP specifier.  Also used in building partitive
; phrases such as in "Kim's is good."
;
poss-able := head_min &
  [ POSS bool ].

disc_adverbee := head.

subst_or_func := head.
non_frag := subst_or_func.
func := non_frag.

; For small clauses in gapping
n_p_v_adv_adj_comp := head.

n_or_p_or_v_or_adv := n_p_v_adv_adj_comp.
n_or_p_or_v_or_comp := n_p_v_adv_adj_comp.
n_or_p_or_v := n_or_p_or_v_or_adv & n_or_p_or_v_or_comp & subst.

p_or_adv_or_dadv := head.
adv_or_dadv := p_or_adv_or_dadv.

;; DPF 2022-05-28 - Let's try reducing the massive ambiguity in measure phrases
;; by adding a marker for modnp so we can block degsp-H analysis of
;; "[21 cents] [a share]"
n_or_a_or_p_or_adv := head &
  [ --MODNP bool ].
v_or_g_or_dadv := head.
p_adj_adv_or_comp := n_p_v_adv_adj_comp.
p_or_adv_or_comp := p_adj_adv_or_comp.
p_or_v_or_adv := n_or_p_or_v_or_adv. 

p_or_basic_adv := head.
p_or_adv := p_or_v_or_adv & p_or_adv_or_dadv & 
            n_or_p_or_adv & p_or_adv_or_comp & p_or_basic_adv.
adv_or_comp := p_or_adv_or_comp.
subst_or_adv_or_frag := head.
subst_or_adv := subst_or_adv_or_frag.

subst := non_frag & subst_or_adv.

v_or_g_or_p := v_or_g_or_a_or_p.

;; DPF 2022-05-16 - Pulled introduction of VFORM up from basic_verb_or_frag
;; so we can have lexical passives such as "muddled" that constrain VFORM pas
;; but can still be HEAD v_or_a.
;;
non_noun_or_frag := head &
  [ VFORM vform ].

non_noun_or_adv := non_noun_or_frag.

non_noun := subst & non_noun_or_adv.
v_or_a_or_p := non_noun.

; Used for reordering first and second complements
verbal_or_a_or_p := non_noun.
; Used by copula in "it is that Kim arrived" or "it is because Kim arrived"
verbal_or_p := verbal_or_a_or_p & vc_add & n_or_p_or_v_or_comp.
; To differentiate |our idea is [that] he should stay|
comp_or_p := verbal_or_p.

a_or_p_or_adv := n_or_a_or_p_or_adv.
a_or_adv_or_det := n_or_a_or_adv_or_det.
a_or_adv := a_or_adv_or_det & n_p_v_adv_adj_comp & a_or_p_or_adv.

n_or_p_or_frag := head.

bare_able := head &
 [ --BARE luk,
   --BARED bool ].

n_or_p_or_a := n_or_a_or_p_or_adv & bare_able.

n_or_p_or_adv := n_or_a_or_p_or_adv.

;v_or_n_or_g_or_a := subst.
;n_or_v_or_a := v_or_n_or_g_or_a.
n_or_v_or_a := subst.

n_or_p :=  n_or_p_or_v & n_or_p_or_frag & n_or_p_or_a & n_or_p_or_adv.
;n_or_a := n_or_v_or_a.

; DPF 3-apr-05 - Added poss-able to allow for locative inversion using sb-hd_mc_c.
a_or_p := v_or_a_or_p & n_or_p_or_a & poss-able & a_or_p_or_adv.
v_or_p := v_or_a_or_p & n_or_p_or_v & v_or_g_or_p & p_or_v_or_adv.
n_or_v := n_or_p_or_v & n_or_v_or_a.

; For heads that can take comparative degree specifiers
comp_spec_able := head.
; Exclude prepositions for target of most comp. deg. specifiers
n_or_a_or_adv_or_det := comp_spec_able.
n_or_adv := n_or_a_or_adv_or_det.
basic_nom_or_ttl := poss-able & head.
nom_or_ttl := basic_nom_or_ttl.
noun_or_ttl := nom_or_ttl.

; For constraint on head-spec rule.
; DPF 8-aug-07 - The hack feature --BARE is used to prevent underspecified
; mass-count nouns from undergoing the robust bare-pl-sg rule, since they
; can already undergo the ordinary bare-plural rule.
;
n_or_a_or_det := n_or_a_or_adv_or_det & bare_able.

;; det_or_adv allows supertype to include numerals and measure NPs, which
;; both take e.g. "over" as a degree specifier
det_or_adv := func & a_or_adv_or_det.
det_or_partn := non_frag.
adj_or_det := n_or_a_or_det.
det := det_or_adv & poss-able & adj_or_det & det_or_partn.

adverbee_or_modnp := head.
; Adverbs modify adverbees.
adverbee := adverbee_or_modnp.

v_or_g_or_a_or_p := subst.
;; DPF 2022-05-23 - Added CNTRCTD to distinguish contracted auxiliaries, so
;; rules can choose to avoid them, such as cl_adv_c to block spurious
;; "'s clothing proved adequate".  The feature needs to be this high in the
;; subst hierarchy since the v_mod rules can apply to a range of head types
;; but we still want to exclude contracted verb heads.
;;
v_or_g_or_a_or_n := subst &
  [ CNTRCTD bool ].

v_or_g_or_a := v_or_g_or_a_or_p & v_or_g_or_a_or_n.
;; DPF 2022-12-26 - Pushed verb_or_frag down to subtype verb, to avoid having
;; vocatives modify CPs: "we admire madness -- that we arise"
;v_or_g := v_or_g_or_a & v_or_g_or_p & verb_or_frag & v_or_g_or_dadv.
v_or_g := v_or_g_or_a & v_or_g_or_p & v_or_g_or_dadv.

nominal_or_verbal := subst.

nominal := nominal_or_verbal & poss-able.

verbal := v_or_g & nominal_or_verbal & adverbee & disc_adverbee &
	  verbal_or_conj-s.

; mobile things can be extracted in the complement-extraction rule, from which
; we exclude nominative-case NPs by not making all NPs mobile.

mobile := head.

; DPF 7-mar-05 - Make subtype of nominal_or_verbal so PPs can modify APs,
; in order to admit "towns not obvious on the map"
; DPF 12-feb-08 - Add a_or_adv to adj_or_intadj so we can coordinate
; integer adjectives as in "six or seven cats"
;; DPF 2017-09-23 - Let's pull the CARDINAL feature up to intsort, 
;; so we can mark normal adj as CARDINAL -, to prevent coord of 
;; |*big and three cats| while allowing |first and oldest cat|.  Will still 
;; also get |third and older cat| (okay) but also |?big and third cat|.
;; DPF 2017-10-19 - Changed parent type from n_or_v_or_a to v_or_a so we can
;; include integer adjs as in |we made him third|
;;
v_or_a := v_or_g_or_a & n_or_v_or_a & verbal_or_a_or_p.

adj_or_intadj := v_or_a & a_or_p & adverbee & nominal_or_verbal &
		 a_or_adv & intsort.

basic_adj := mobile & adj_or_intadj.
; For positive adjectives
adj := basic_adj & adj_or_det & p_adj_adv_or_comp &
  [ CARDINAL - ].

; prep_or_modnp := p_or_adv.
prep_or_modnp := p_or_adv & v_or_p.


; DPF 26-Jul-99 - Made prep not inherit from adverbee, since in general
; don't want adverbs modifying PPs.
; DPF 17-Dec-01 - But need to have at least some adverbs modifying PPs: 
; "The books currently in the store include ..."

basic_prep := a_or_p & n_or_p & prep_or_modnp & comp_or_p &
        adverbee.

prep := basic_prep & mobile & comp_spec_able.

prep_nonmob := basic_prep.

; For result of npadv_mod non-branching rule
; Need mobile for "where did i put it"

modnp := n_or_p & nominal & prep_or_modnp & mobile & a_or_adv &
         adverbee_or_modnp & det_or_adv.

;; DPF 2020-07-12 - At long last, add feature to explicitly control whether a
;; a noun can be a nonhead in a N-N compound.  We've been trying until now to
;; control this via other properties such as the (vaguely defined) NORM
;; feature, but that feature is also used in other constructions such as
;; vocatives, where no generalization emerges about nouns across those
;; constructions.  So let's go down the road of construction-specific features.
;; DPF 2022-04-23 - Add parent n_or_p so prd copula can appear with inverted
;; locative expressions such as "in the corner was standing an old coatrack"
;; DPF 2022-06-03 - Add feature to prevent some nouns from serving as titles,
;; e.g. to block title "hire" in  "[[Will Abrams] hire] Browne?"
;; DPF 2022-06-11 - Add feature --COUNTED to enable blocking of "fifty ten cats"
;; DPF 2023-01-07 - Add feature --VOC to enable blocking of vocative rule
;;
supnoun := nominal & n_or_v & n_or_a_or_det & n_or_p &
  [ --CPDNHD bool,
    --TITLE-CPD bool,
    --COUNTED bool,
    --VOCATIVE bool ].

noun_or_nomger_or_nadj := supnoun.

; for both nominal and verbal gerunds
noun_or_nomger := basic_nom_or_ttl & noun_or_nomger_or_nadj.
noun_or_gerund := supnoun.
; For nouns that can undergo conversion to adj, like "eared" or "blue"
;noun_adj := supnoun.
noun_adj := subst.

basic_noun := noun_or_nomger & n_or_adv & noun_or_gerund & noun_or_ttl &
	      v_or_g_or_a_or_n.

;; DPF 2017-10-05 - Non-partitive nouns, overlapping in effect with 
;; nonpart_nom_rel
non_partn := noun_or_nomger_or_nadj.

noun := basic_noun & non_partn.
noun_adjable := basic_noun & noun_adj & mobile & non_partn.

; DPF 10-Apr-02 - Added n_or_p since want to allow gerunds to undergo hdn_optcmp_c
; rule, to get e.g."way of saying that Kim arrives"
; DPF 19-may-09 - Now that we make verbal gerunds as phrases, try dropping
; v_or_g supertype, to avoid spurious ambiguity for e.g. "not hiring kim".
; May lead to larger clean-up of head types. FIX?
; gerund := noun_or_gerund & adverbee & v_or_g & n_or_p & disc_adverbee.
; DPF 23-jun-09 - Re 19-may-09: But gerunds still need to inherit verbal
; features VFORM, INV, TAM, so add super-type verb_or_frag.
;;
comp_or_gerund := head.
gerund := noun_or_gerund & adverbee & disc_adverbee & comp_or_gerund &
	  basic_verb_or_frag.
gerund_full := gerund & vc_add.

; For derived entries like the "eyed" of "wide-eyed"
n-ed := noun_adj & basic_nom_or_ttl & non_partn.

; For run-on sentences.
verb_or_conj_or_frag := head.
verb_or_conj-s := verb_or_conj_or_frag.
; For no-copula and run-on sentences
;; DPF 2022-05-16 - Pushed introduction of VFORM up to parent non_noun_or_frag,
;; so we can have lexical passives such as "muddled" that constrain VFORM pas
;; but can still be HEAD v_or_a.
basic_verb_or_frag := non_noun_or_frag & verb_or_conj_or_frag.

;; For target of ordinary "not"
verb_or_frag_or_comp := basic_verb_or_frag.

; Enable exclusion of spurious ambiguity for gerund "not hiring Kim"
verb_or_frag := verb_or_frag_or_comp.


#|
; Allow conjunction reduction and gapped sentences 
verb_or_cr := verb_or_frag.
verbal_or_cr := non_noun.
cr := verb_or_cr & verbal_or_cr & adverbee_or_modnp.
|#

; Added poss-able to allow s's as subjects of quoting verbs, as in
; 'Kim arrived said Sandy.'
;; DPF 2014-10-20 - Added comp_spec_able to allow |was more/most admired|
;;
verb := verbal & v_or_p & n_or_v & v_or_a & poss-able & mobile & 
	verb_or_conj-s & comp_spec_able & verbal_or_p & verb_or_frag.

addinfl := *avm* &
  [ ADDPN pn,
    ADDTAM tam_min ].

vc_add := subst &
  [ --ADDIN addinfl ].

; DPF 24-jul-05 - Removed nominal as supertype of comp since we use a rule to
; convert NP-subject-taking VPs into CP-taking ones, with distinct semantic
; linking.
;; 2012-12-19 - Added PRD - to prevent spurious coord of conjoined that-S 
;; with prdp (depictives), as in wsj20d:22064023.
;;
comp := verbal & poss-able & mobile & adv_or_comp & comp_or_gerund & comp_or_p &
	verb_or_frag_or_comp &
  [ MOD *anti_list*,
    PRD - ].

; For adverb fragments, including speech-relevant adverbs
adv_or_no_head := head.
basic_adv := det_or_adv & non_noun_or_adv & subst_or_adv & adv_or_no_head.

; 'not' and closed class of other adverbs that can be added to aux COMPS list
; via 'adv_addition' lexical rule.
basic_lexadv := basic_adv & disc_adverbee.
negadv := basic_lexadv & adverbee.
lexadv := basic_lexadv & a_or_adv & p_or_basic_adv.

reg_adv := basic_adv & disc_adverbee & p_or_adv & adv_or_comp &
           a_or_adv & n_or_adv & adv_or_dadv.
adv := reg_adv & mobile.
adv_nonmob := reg_adv.
deg_adv := basic_adv.
root-marker := v_or_g_or_dadv & adverbee & adv_or_dadv & non_frag.
wh_adv := func.
; For titles like "Mr" or "Professor", not to be confused with nouns
ttl := func & noun_or_ttl & n_or_a_or_p_or_adv.

detspec := func.

; Hack used in blocking unwanted affixes
no_head := non_frag & adv_or_no_head & bare_able.

; Used for binary bridging rule
bridge_head := head.

; Types for punctuation and string boundaries.
; **FIX**

punct_hd := head.

punct_pair_hd := func.
quote_punct_hd := punct_pair_hd.
dq_punct_hd := quote_punct_hd.
sq_punct_hd := quote_punct_hd.
lq_punct_hd := sq_punct_hd.
lp_punct_hd := punct_pair_hd.
rp_punct_hd := punct_pair_hd.

nomger := noun_or_nomger & nom_or_ttl & non_partn.
nomger_mob := nomger & mobile & [ CASE non_nom ].

; The following types are used to enable strict subcategorization (the usual 
; case)

;noun_mob := noun & mobile & [ CASE non_nom ].
noun_mob := noun & mobile.
noun_nonmob := noun.
basic_partn := basic_noun & det_or_partn.
partn := basic_partn.
partn_mobile := partn & mobile.
gerund_mob := gerund & mobile & [ CASE non_nom ].
; For 'long' of 'for too long'
grad_n := basic_partn & mobile & a_or_adv_or_det &
  [ CASE non_nom ].
interv_n := noun.

; For types that can undergo number-partitive:'five of them','ten feet of rope'
adj_partitive := non_frag.
intadj_or_superl := adj_partitive.
intadj_or_comp := adj_partitive & intsort.

compar_or_superl_adj := basic_adj.
superl_adj := compar_or_superl_adj & intadj_or_superl.
compar_adj := compar_or_superl_adj & intadj_or_comp.

; For measure-NPs
noun_meas := noun & adj_partitive.

; For tag questions, which can't be verbal in order to avoid being root S's.
tagaux := non_frag & verb_or_frag.

conj_or_frag := verb_or_conj_or_frag.

; For fragments of all kinds
; DPF 12-apr-08 - Try adding disc_adverbee, to allow "Yes, and Kim."
frag := subst_or_func & verb_or_frag & conj_or_frag & disc_adverbee & mobile &
	subst_or_adv_or_frag &
  [ MOD < > ].

; For run-on sentence conjunction (to avoid spurious modifier ambiguity)
;; conj-s := verbal & verb_or_conj-s.
verbal_or_conj-s := basic_verb_or_frag.
conj-s := verb_or_conj-s & verbal_or_conj-s & disc_adverbee.
;; DPF 2020-03-24 - Added type as per trunk.
conj-s_full := conj-s & vc_add.

; For 'foreign' words, typically marked as italicized
;; DPF 2019-11-23 - Change to inherit from subst_or_func rather than just head,
;; so punct clitics will attach.
fw := subst_or_func & [ MOD < > ].

; Speech filler words in word lattices26009
spfill := head & [ MOD < > ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Sorts for atomic values

strict_sort := *sort*.

; Person and number represented as atomic sorts, with gender a separate attrib
; relevant for 3sg, and where count/mass distinction only for 3sg neuter.

pn := *sort*.

; 5 cells
-1s := pn.
-2s := pn.
-3s := pn.
-1p := pn.
-2p := pn.
-3p := pn.

; 4 cells
-1 := -1s & -1p.
-2 := -2s & -2p.
-3 := -3s & -3p.

-12s := -1s & -2s.
-13s := -1s & -3s.
-23s := -2s & -3s.

-12p := -1p & -2p.
-13p := -1p & -3p.
-23p := -2p & -3p.

-1s-2p := -1s & -2p.
-1s-3p := -1s & -3p.
-2s-1p := -2s & -1p. 

-2s-3p := -2s & -3p.
-3s-1p := -3s & -1p.
-3s-2p := -3s & -2p.

;3 cells
sg := -12p & -13p & -23p. 
pl := -12s & -13s & -23s.

1+2s := -3s-2p & -23p & -3.
1+2p := -2s-3p & -23s & -3.
1+3s := -2s-3p & -23p & -2.
1+3p := -3s-2p & -23s & -2.

2+1s := -3s-1p & -13p & -3.
2+1p := -1s-3p & -13s & -3.
2+3s := -1s-3p & -13p & -1.
2+3p := -3s-1p & -13s & -1.

3+1s := -2s-1p & -12p & -2.
3+1p := -1s-2p & -12s & -2.
3+2s := -1s-2p & -12p & -1.
3+2p := -2s-1p & -12s & -1.

12s+3p := -3s-1p & -3s-2p & -12p.
13s+2p := -2s-1p & -2s-3p & -13p.
23s+1p := -1s-2p & -1s-3p & -23p.

1s+23p := -2s-1p & -3s-1p & -23s.
2s+13p := -1s-2p & -3s-2p & -13s.
3s+12p := -1s-3p & -2s-3p & -12s.

; 2 cells
1 := 1+2s & 1+2p & 1+3s & 1+3p. 
2 := 2+1s & 2+1p & 2+3s & 2+3p.
3 := 3+1s & 3+1p & 3+2s & 3+2p.

12s := 12s+3p & 1+2s & 2+1s & sg.
13s := 13s+2p & 1+3s & 3+1s & sg.
23s := 23s+1p & 2+3s & 3+2s & sg.
12p := 3s+12p & 1+2p & 2+1p & pl.
23p := 1s+23p & 2+3p & 3+2p & pl.
13p := 2s+13p & 1+3p & 3+1p & pl.

1s+2p := 1+2p & 2+1s & 13s+2p & 1s+23p.
1s+3p := 1+3p & 3+1s & 12s+3p & 1s+23p.
2s+1p := 2+1p & 1+2s & 2s+13p & 23s+1p.
2s+3p := 2+3p & 3+2s & 2s+13p & 12s+3p.
3s+1p := 3+1p & 1+3s & 3s+12p & 23s+1p.
3s+2p := 3+2p & 2+3s & 3s+12p & 13s+2p.

1s := 1 & 12s & 13s & 1s+2p & 1s+3p.
2s := 2 & 12s & 23s & 2s+1p & 2s+3p.
3s := 3 & 13s & 23s & 3s+1p & 3s+2p.
1p := 1 & 12p & 13p & 2s+1p & 3s+1p.
2p := 2 & 12p & 23p & 1s+2p & 3s+2p.
3p := 3 & 13p & 23p & 2s+3p & 1s+3p.

; For unspecified pernum, to constrain generator introducing e.g. 'am' when
; an argument position is unbound.

unsp_pernum := pn.

gender := *sort*.
real_gender := gender.
animate := real_gender.
masc := animate.
fem := animate.
neut := real_gender.
andro := animate.
andro1 := animate.

; The following two are used in tag questions to block mismatched expletive
; pronouns in main clause and tag, since we can't block on unified index
; values, since in general tag questions introduce a pronoun which must have
; a unique index bound by the quantifier it (now) introduces lexically.
no_gend_it := gender.
no_gend_there := gender.

png_min := *avm*.
png := png_min & 
  [ PN pn,
    GEN gender ].

;; DPF 2017-06-29 - In order to prevent plural possessive |'s| from attaching
;; to ordinary plural noun NPs |*the dogs's| while allowing it for irregular
;; plurals |the children's|, make two subtypes of png, one for regular inflected
;; nouns and the other for irregulars.  Then we provide two inflectional rules 
;; for plural nouns: the usual one for regular nouns that makes the AGR..PNG 
;; value be png-reg, and a second rule only for irregular nouns (triggered by 
;; the entries in `irregs.tab') that makes the AGR..PNG value be png-irreg.  
;; The plural possessive clitic "'s" requires its spr to be png-irreg, thus 
;; blocking |the dogs's| while allowing |the children's|.
;; DPF 2020-04-01 - Further subtype PNG to enable exclusion of underspecified
;; symbol-measure-NPs (|$200|) as nonhead in plural-compound rule: |$100 bill|
;;
norm-png := png.
png-reg := norm-png.
png-irreg := norm-png.
png-unsp := png.

; ERB declarative and interrogative seem to form a natural class
; in that 'know', 'guess', 'suspect' ... take either.  The type
; decl_int is meant to reflect this.  
; ERB (23-07-96) declarative and imperative also form a class 
; with respect to tag questions.  The type decl_imp is meant to
; reflect this.

cl_mode := *sort*.
no_cl_mode := cl_mode.
relative := cl_mode.
decl_int := cl_mode.
decl_imp := cl_mode.
declarative := decl_int & decl_imp.
interrogative := decl_int.
imperative := decl_imp.

prontype := *sort*.
real_pron := prontype.
notpro_or_refl := prontype.
notpro_or_non_refl := prontype.
non_refl := real_pron & notpro_or_non_refl.
std := non_refl.
recip := non_refl.
refl := real_pron & notpro_or_refl.
impers := non_refl.
demon := non_refl.
zero := non_refl.
notpro := notpro_or_refl & notpro_or_non_refl.

; Three-valued sort evoking Polish logician Jan Lukasiewicz
luk := *sort*.
; NA for Not Applicable.  
na_or_+ := luk.
na_or_- := luk.
bool := luk.
na := na_or_+ & na_or_-.


+ := bool & na_or_+.
- := bool & na_or_-.

; Three-valued sort for distinguishing unmodified signs from both left-modified
; and right-modified signs
; LPERIPH and RPERIPH indicate whether this modifier is left- or 
; right-peripheral in its phrase - e.g., "the IBM temporary employees" but 
; "*the IBM five employees", and similarly "chairs I buy that you like are
; expensive" but "*chairs that you like I buy are expensive"

xmod_min := *sort*.
xmod := xmod_min &
  [ LPERIPH luk,
    RPERIPH 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.

; One of a grammatically salient inventory of semantic sorts, such as
; 'animate' or 'time'

semsort := *sort*.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CONT types

semarg := *avm* &
  [ INSTLOC string,
    SORT *sort* ].

basic_non_expl := semarg.
non_conj_sement := semarg.
basic_non_event := semarg.
non_event := basic_non_expl & basic_non_event.
handle := non_event & non_conj_sement.
individual_min := semarg.

individual := individual_min &
 [ --TPC luk,
   PT prontype ].

; DIV (divisible) distinguishes singular count nouns from plural and mass 
; nouns, for determiners like "some", and for bare-plural NPs.
; IND (individuated) draws the relevant semantic distinction between 
; countable and non-countable entities, so DIV should be only a morphosyntactic
; distinction.

index := individual &
  [ PNG png_min,
    DIV bool,
    IND bool ].
    
; Moved SORT to individual, since need to allow constraint to affect events too
; Also moved PT up to individual, since we want to constrain the ARG1 of some
; adjectives to be PT zero, without insisting that this be a ref-ind that gets
; a quantifier.
full_index := index.

; 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.

non_expl := individual & basic_non_expl.

event_or_index := non_expl.

event_or_deg-ind := event_or_index.

basic_tense := *sort*.
tense := basic_tense.
untensed := basic_tense.
basic_aspect := *avm*.
aspect := basic_aspect &
  [ PRF luk,
    PROGR luk ].
no_aspect := aspect &
  [ PRF -,
    PROGR - ].

real_tense := tense.
nonpast := real_tense.
present := nonpast.
nonpresent := real_tense.
past := nonpresent.
future := nonpast.
no_tense := tense & untensed.
; For PPs that can never be complements of 'be'
nontense := untensed.

mood := *sort*.
ind_or_modal_subj := mood.
ind_or_subj := mood.
indicative := ind_or_modal_subj & ind_or_subj.
basic_subjunctive := mood.
modal_subj := ind_or_modal_subj & basic_subjunctive.
subjunctive := basic_subjunctive & ind_or_subj.

tam_min := *avm*.

tam := tam_min &
 [ TENSE basic_tense,
   ASPECT basic_aspect,
   MOOD mood ]. 

past_or_subj_tam := tam &
 [ TENSE nonpresent ].

subjnct_tam := past_or_subj_tam &
 [ MOOD subjunctive ].

indic_tam := tam &
 [ TENSE real_tense,
   MOOD ind_or_modal_subj ].

past_tam := past_or_subj_tam & indic_tam &
 [ TENSE past,
   ASPECT no_aspect ].

event := event_or_deg-ind & ind_or_event_or_conj &
  [ E tam_min,
    SF iforce ].

; Once used to distinguish discourse adverbs, for VIT purposes - now obsolete?
disc_frag := event_or_index.

; LNK links semantic relation to input string elements
; CFROM and CTO used for characterization

relation_min := *avm*.
relation := relation_min &
  [ PRED predsort,
    LBL handle,
    LNK *list*,
    CFROM *top*,
    CTO *top* ].

arg0_relation := relation &
  [ ARG0 event_or_index ].

event_relation := arg0_relation &
  [ ARG0 event ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MRS type
;
;   HOOK                   ; Label of rel with highest scope in sign
;   RELS  *diff-list*      ; List of elementary predications
;   HCONS *diff-list*      ; Scope constraints: list of scp_pr's
;   ICONS *diff-list*      : Constraints on pairs of individuals

; DPF 18-jul-04 - Avoid making value of LTOP handle, since want to allow for
; optional sentential complements, so need to have that argument position in
; the higher verb's relation be underspecified.  We give up some type-checking
; benefits here, but gain cleaner treatment of optionality.
; DPF 22-may-09 - The feature --SLTOP is introduced in response to our
; decision to conform more closely to the semantic algebra, in
; particular ensuring that heads identify their LBL with each of their
; complements unless they take that complement LBL as an argument (as
; with sentential complements). The challenge to composition arises in
; across-the-board extraction, as in "Him, we like and admire"
; (assuming for this example that we've dispensed with the
; pronoun_q_rel, so the LBL of the complement's pron_rel should be
; identified with its verbal head).  If we just unify the SLASH values
; of the conjoined VPs in the above example, we then wrongly get the
; same LBL for both _like_v_rel and _admire_v_rel.  The new solution:
; have the various SLASH-introduction constructions keep the LTOP of
; the SLASH value unbound, instead identifying the LTOP of the slashed
; argument (or adjunct) with this new attribute --SLTOP on the mother.
; This attribute will ordinarily then be passed up the tree with the
; help of enriched basic lexical types which identify their --SLTOP
; with that of their complements (the same as lexical threading for
; SLASH). In the filler-head construction the filler's LTOP is
; identified with this --SLTOP.  But in coordinate structures, the
; link is broken, so the coordinate phrase simply identifies the
; phrase's --SLTOP with the left conjunct (arbitrarily).  This results
; in a well-scoped structure, though there's surely a better solution
; somewhere.  [Note that we first tried making the coordinate structure
; identify its own LTOP with its --SLTOP, but this fails with multiple
; coordinate structures like "Don't toss paper and other garbage on
; streets and in the terrain."  since each of the two coordinate
; complements would each identify their --SLTOP with their own LTOP,
; and then the verb "toss" would in turn make its --SLTOP unify with
; both of these, wrongly resulting in the LTOP of the first complement
; identified with that of the second.]  For easy-adjectives with a slashed
; complement, the --SLTOP of the phrase "easy to admire" is idiosyncratcially
; not identified with that of the slashed complement, since the SLASH itself
; is not passed up the tree.
;; Relevant examples:
;; we want to slip into paris and into rome.
;; where should we be?
;; DPF 2018-03-14 - Following a more careful study of the semantic algebra,
;; it became clear that the --SLTOP hack was not really a solution to the
;; problem of the semantics of ATB extraction.  The core issue is that if
;; there are nonscopal arguments that share their LTOP with that of the
;; selecting head and that can be extracted from coordinate structures, we
;; get dubious semantics.  For example, if pronouns share their LBL with that
;; of the head, then in |Kim relies on and probably admires him|, `him' would
;; expect to share its label with both `rely on' and 'admire', wrongly dragging
;; `rely on' into the scope of `probably'.   Choosing to attach the label of
;; the pronoun to that of the coordinated VP does not appear motivated 
;; semantically, and will be difficult to achieve compositionally via 
;; unification, since the coordination constructions uniformly unify the SLASH
;; values of the dtrs and the mother.  How would input to the generator know
;; which label to assign to the pronoun `him' in this example:
;;   They seemed to continue to adore and probably even grew to admire him.
;; So the emerging hypothesis is to follow DRT's lead and identify the labels of
;; (unmodified pronouns with the global top (and perhaps also for ordinary 
;; proper names if we abandon proper_q_rel), with modified pronouns and
;; such as in |he who runs fastest will arrive before you who run slower|
;; or |Kims who like sushi| presumably introducing a quantifier.  
;; Further, we don't expect other nonscopal arguments to participate in ATB 
;; extraction:
;;   ? They slipped or sneaked into the room.
;;   ? Into which room did they slip or sneak?
;;   ? He put it and seemed to intend to put it badly.
;; For reference, these are the verb types that take non-scopal non-NP
;; complements, and we expect that none of these will participate in ATB
;; extraction:
;; v_pp*-pp*_le  lie to X about Y
;;	      agree with-about, apologize to-for, complain to-about
;; v_np-pp_le    name X after Y
;;	      combine with, credit to, delete from, do with, face with
;; v_p-pp_le     come across as X
;;	      let up on, lock in on, meet up with, shop around for
;; v_pp*_le      gossip about X, 
;;	      deviate from, flirt with, rave about, tower over
;; v_pp_dir_le   sneak into the room
;;	      barge, burst, head, inch, lumber, sidle, slip, 
;; v_pp_unacc_le drop onto the floor
;;	      curl into a ball, fit into a pocket, slam into the wall, swing up 
;; v_adv_le      did well
;;	      auger poorly, behaved badly, went well
;; v_np-adv_le   put it badly

hook_min := *top*.
hook := hook_min &
  [ LTOP handle,
    INDEX semarg,
    XARG semarg ].

mrs_min := *avm*.
mrs_min0 := mrs_min &
  [ HOOK hook_min ].

mrs_min1 := mrs_min0 &
  [ RELS *diff-list* ].
    
;; DPF 10-Oct-00 - Added ARG0 attribute for predicative phrases, as in
;; "Kim kept calm" where the INDEX of "calm" is "Kim"'s INDEX and the first
;; argument of _keep_rel, while "calm"'s ARG0 is second argument of _keep_rel.

mrs := mrs_min1 &
  [ HCONS *diff-list*,
    ICONS *diff-list* ].

; Constrains handle of scopable argument HARG relative to one or more 
; handles
scp_pr := *top* &
  [ HARG handle,
    LARG handle ].        

; Constrains scope to be equal subject to intervening quantifiers
;;;
;;; as of jul-04, the generator supports a mode where QEQs in its input MRSs
;;; are equated internal to the generator, which (although formally it results
;;; in an MRS that could not be scope-resolved) makes sure we get attachments
;;; of scopal elements right, even though in the final semantics compatibility
;;; test there is no testing of handle constraints.  instead, an MRS that comes
;;; off a generator output is subjected to QEQ equation internall too, so that
;;; plain mrs-equalp() is sufficient.  equating INSTLOC values inside of QEQs
;;; in the grammar makes sure we get the intended effect during generation, but
;;; still end up producing a well-formed MRS with scope underspecification.
;;;                                                            (14-jul-04; oe)
; Constrains scope to be equal subject to intervening quantifiers
qeq := scp_pr & [ HARG.INSTLOC #1, LARG.INSTLOC #1 ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ICONS

icons := *avm* &
  [ IARG1 individual,
    IARG2 individual ].

;; Information structure types, drawn from Sanghoun Song's dissertation
info-str := icons.
non-topic := info-str. 
non-focus := info-str.
focus := non-topic.
topic := non-focus.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CONJ type -
;
; CONJ values come in two types, cnil and real-conj (i.e., non-cnil).  Cnil
; and the atomic substypes of real-conj are the possible CONJ values of the
; left conjunct in a coordinate structure.  The right conjunct must always
; have a complex-conj CONJ value.  A complex CONJ value has three parts: the
; handles and indices of the sub-parts of the right conjunct, and the CHEAD
; info that gets passed from the right conjunct to the mother.  The CHEAD
; value has only one piece of information: the CONJ value of the
; left conjunct daughters.  For more info about how this works, see
; top_coord_rule in syntax.tdl.
; CLEX enables the conjunction to constrain the LEX property of the left
; conjunct.
;; DPF 2017-10-07 - NOCONJ marks whether the coordinated phrase is lacking a
;; conjunction, so we can avoid spurious analysis of |[dog, cat, horse] and cow|
;; DPF 2018-02-17 - Added L/RPERNUM to record the pernum of the left and
;; right conjuncts, which we need in order to analyze |a dog and cat are happy|,
;; with the number of each conjunct visible at the phrasal node |dog and cat|,
;; to block |*a dogs and cat| and |*a [cat and dogs] we love|
;; DPF 2022-05-28 - Since it appears that we no longer use CLEX for its original
;; purpose, removed the unused identity of RCONJ-DTR..CLEX and LCONJ-DTR..LEX
;; in basic_coord_phr.  Consider using CLEX to record when one of the conjuncts
;; is a phrase ([CLEX -]) and propagate that to the mother's CLEX, so at least
;; the N-N compound rule for plural nonhd can require that each of that nonhd's
;; conjuncts is LEX +, to block [[flower and [bush with leaves]] garden].  The
;; idea is that only phrasal dtrs will supply the [CLEX -] constraint, while
;; lexical dtrs say nothing, allowing conjunction of any combination of lex
;; and phr, but if a phrasal dtr is present, CLEX will be -, and thus will 
;; conflict as desired with the compound rule's requirement that the nonhd be
;; CLEX +.  At present, using combination of MODIFD and LEX from one or the
;; other of the conj-dtrs to exclude most unwanted compounds, but CHECK.
;; DPF 2023-01-23 - As with 2018-02-17's addition of L/RPERNUM, add L/RINDIV so
;; we can block mass-Nbar-coord when the right conjunct is itself a coord of
;; mass and count, as in "*rice, corn, and beans grows here".
;;
conj_min := *avm* &
  [  NOCONJ bool ].
basic-conj := conj_min &
  [ CHEAD cnil_or_atomconj,
    CLEX luk,
    LPERNUM pn,
    RPERNUM pn,
    LINDIV bool,
    RINDIV bool ].

conj := basic-conj.
cnil_or_phrconj := basic-conj.
cnil_or_lexconj := basic-conj & cnil_or_lex_or_atomconj.
cnil_or_numconj := conj_min.
cnil_or_lex_or_atomconj := conj_min.
cnil_or_atomconj := cnil_or_lex_or_atomconj.
both_or_cnil := cnil_or_atomconj.
either_or_neither_or_cnil := cnil_or_atomconj.
either_or_whether_or_cnil := cnil_or_atomconj.
either_or_cnil := either_or_neither_or_cnil & either_or_whether_or_cnil.
neither_or_cnil := either_or_neither_or_cnil.
whether_or_cnil := either_or_whether_or_cnil.
first_or_cnil := cnil_or_atomconj.
not_or_cnil := cnil_or_atomconj.
notonly_or_cnil := not_or_cnil.
cnil := cnil_or_atomconj &
  [ LCHEAD cnil_or_atomconj ].

cnil_full := cnil & cnil_or_numconj & cnil_or_phrconj & cnil_or_lexconj &
             both_or_cnil & either_or_cnil & notonly_or_cnil &
             neither_or_cnil & first_or_cnil & whether_or_cnil.

atomic-conj := cnil_or_atomconj.
both := both_or_cnil & atomic-conj.
either := either_or_cnil & atomic-conj.
neither := neither_or_cnil & atomic-conj.
whether := whether_or_cnil & atomic-conj.
first := first_or_cnil & atomic-conj.
notonly := notonly_or_cnil & atomic-conj.
not-conj := not_or_cnil & atomic-conj.
between := atomic-conj.
rather := atomic-conj.
from-conj := atomic-conj.

; CREL is a pointer to the coord_relation, needed for semantic composition.
; CPUNCT enables lexical conjunctions to block comma-marked left conjunct
; in simple two-part coordination: '*Abrams, and Browne arrived'.
; CPNG records agreement constraints which a conjunction can contribute,
; allowing 'and' to provide singular nbar-coordination, but plural NP
; coordination, for the contrast in "Their hardiness and zest for life is"
; but "*Abrams and Browne is"
;; DPF 2022-07-02 - Added CPRED to keep track of lexical conjunction inside
;; multi-part coordination, to differentiate "N, N and N" from "N, N or N"
;; particularly for coord_3 which equates the indices of the conjuncts, as in
;; "She is a scholar, gymnast, and singer." where we only want "and", not "or".

complex-conj := basic-conj &
  [ CREL *top*,
    CPUNCT pnctpair,
    CPNG png,
    CPRED predsort ].

phr-conj := complex-conj & cnil_or_phrconj &
  [ CHEAD cnil ].
lex-conj := complex-conj & cnil_or_lexconj.
num-conj := cnil_or_numconj & atomic-conj.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Contextual information

ctxt_min := *avm*.

ctxt := ctxt_min &
  [ ACTIVATED bool,
    PRESUP *diff-list* ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; LKEYS relations (shortcuts to keyrels of complements, only used in lexicon)
;  KEYREL relation          ; Pointer to main relation in RELS
;  ALTKEYREL relation       ; Pointer to an alternate relation in RELS
;  ALT2KEYREL relation      ; Pointer to a second alternate relation in RELS
;  --COMPKEY predsort       ; Pointer to the complement's MIN
;  --OCOMPKEY predsort      ; Pointer to the oblique complement's MIN
;  --+COMPKEY predsort      ; Pointer to obligatory complement's MIN
;  --+OCOMPKEY predsort      ; Pointer to obligatory oblique complement's MIN

minors_basic := *avm* &
  [ MIN predsort ].

minors := minors_basic &
  [ ALTMIN predsort ].

minors_full := minors &
  [ NORM predsort ].

;; DPF 2022-06-10 - Now that we no longer make all head-adj phrases 
;; MODIFD rmod (see basic_head_comp_or_marker_phrase:2022-06-09), introduce
;; feature --MODHD to allow certain scopal modifier phrases to supply value for
;; MODIFD on the mother of the head-mod phrase.
;;
minors_plus := minors_full &
  [ --MODHD xmod ].

lexkeys := *avm* &
  [ KEYREL relation ].

lexkeys_norm := lexkeys &
  [ KEYREL [ CFROM #from, CTO #to ],
    ALTKEYREL relation & [ CFROM #from, CTO #to ] ].

lexkeys_full := lexkeys_norm &
  [ KEYREL [ CFROM #from, CTO #to ],
    ALT2KEYREL relation & [ CFROM #from, CTO #to ],
    --COMPKEY predsort,
    --OCOMPKEY predsort,
    --+COMPKEY predsort,
    --+OCOMPKEY predsort,
    --IDFORM string ].

; To support chart dependency filtering for there-copula and expletive-it args
lexkeys+ := lexkeys_full &
  [ --+ARGIND index ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Affixation
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; DPF (14-Oct-98) --FINAL-ARG points to the final element in a word with 
;; spaces, since that element bears any inflection.
;; AAC - dropped --FINAL-ARG - default infl position is end of word
;; in user-fns. Find better soln when we do multi words properly
;; (and use defaults)

; Rule

rule := sign.

; LNAME and META used for labeling nodes in parse trees

tree_node_label := *top* &
  [ NODE sign ].

label := sign &
  [ LNAME string ].

;; see lkbpatches
meta := sign &
  [ META-PREFIX string,
    META-SUFFIX string ]. 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CASE and VFORM

case := *sort*.
real_case := case.
non_obliq := real_case.
nom_or_obliq := real_case.
nom := non_obliq & nom_or_obliq.
non_nom := real_case.
acc := non_nom & non_obliq.
obliq := non_nom & nom_or_obliq.
;; Used to prevent bare measure-NPs from appearing as normal NPs.
no_case := case.

vform := *sort*.
fin_or_non_fin := vform.
non_fin := fin_or_non_fin.
non_inf := vform.
non_prp := non_fin & non_inf.
non_bse := vform.
non_pas := non_fin.
non_fin_non_bse := non_fin & non_bse.
non_prespart := vform.
ger := non_prp.
pas_or_psp := non_fin_non_bse & non_inf.
pas_or_prp := vform.
pas := non_prp & pas_or_psp & pas_or_prp.
psp_or_psp_irreg := pas_or_psp & non_pas & non_prespart & fin_or_bse_or_part.
psp := psp_or_psp_irreg.
psp_irreg := psp_or_psp_irreg.
bse_or_inf := non_fin & non_prespart.
; fin_or_bse used to collapse morpholog. unmarked forms for bse and fin-non3sg.
fin_or_bse_or_imp := non_inf & fin_or_inf_or_imp_or_bse.
fin_or_bse_or_part := vform.
fin_or_bse_or_prp := fin_or_bse_or_part.
fin_or_bse := fin_or_bse_or_imp & fin_or_bse_or_prp & non_prespart.
bse_or_prp := non_fin & fin_or_bse_or_prp.
bse := fin_or_bse_or_imp.
; Base morphology verbs can be either base or imperative, but not if negated.
; See discussion of type neg_word.
bse_only := bse & fin_or_bse & bse_or_inf & bse_or_prp.
fin_or_inf_or_imp_or_bse := vform.
fin_or_inf_or_imp := fin_or_inf_or_imp_or_bse.
fin_or_imp := fin_or_inf_or_imp & fin_or_bse_or_imp.
imp_vform := bse & fin_or_imp.
fin_or_inf := non_bse & fin_or_inf_or_imp.
fin := fin_or_inf & fin_or_bse & fin_or_imp & fin_or_non_fin.
inf_or_prp := non_pas & non_fin_non_bse.
inf := inf_or_prp & bse_or_inf & fin_or_inf.
prp := inf_or_prp & non_inf & pas_or_prp & bse_or_prp.

inf_and := vform.
inf_but := vform.
inf_from := inf_or_prp.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  CONT values (MRS semantics)
;;
;; The basic semantic objects are all sub-types of semarg.  Right now, the only
;; type of semarg that has an internal structure is index, but that will
;; probably change.  For example, an event might have various times associated
;; with them or a handle may include a list of "subhandles" which are in its
;; scope.  Indices are classified in the familiar HPSG way.

expl-ind := index & basic_non_event & non_conj_sement.
full_expl-ind := expl-ind & full_index.
it-ind := full_expl-ind &
  [ PNG [ PN 3s,
          GEN no_gend_it ] ].
there-ind := expl-ind &
  [ PNG.GEN no_gend_there ].

non_expl_or_conj-ind := index.
non_expl_or_param := index.
ind_or_event_or_conj := non_expl_or_conj-ind & event_or_index.
basic_non_expl-ind := ind_or_event_or_conj & non_event & non_expl_or_param &
  [ PNG.GEN real_gender ].
non_expl-ind := basic_non_expl-ind &
  [ SORT basic-entity-or-event ].
overt_non_expl-ind := basic_non_expl-ind. 
ref-ind := non_expl-ind & overt_non_expl-ind.
deg-ind := non_expl-ind & event_or_deg-ind.
full_non_expl := full_index & non_expl-ind.
full_there-ind := there-ind & full_expl-ind.
full_ref-ind := ref-ind & full_non_expl.
full_deg-ind := deg-ind & full_non_expl.
; Added to block spurious ambiguity for conjoined proper names:
nonconj_indiv := non_conj_sement & ind_or_event_or_conj.
;; Added to block right-node-raising analysis of |all of the cats|
nonconj_overt-ind := overt_non_expl-ind & nonconj_indiv.
nonconj_ref-ind := full_ref-ind & nonconj_overt-ind.


; For the do-be construction |the first thing he did was shave himself|
do-index := overt_non_expl-ind &
  [ SORT do-event,
    IFORM vform ].
do-index_nonconj := do-index & nonconj_overt-ind.

conj-ind := ind_or_event_or_conj.
conj_event_or_deg-ind := event_or_deg-ind & conj-ind.
conj_event := conj_event_or_deg-ind & event.
; Used to distinguish non-conjoined sentences in order to prevent np_cp_wh_rule
; from applying to conjoined message-underspecified clauses.
non_conj_event := event & nonconj_indiv.

conj_non_expl-ind-or-event := conj-ind & non_expl_or_param.
conj_non_expl-ind := conj_non_expl-ind-or-event & non_expl-ind.
conj_full-ind := conj_non_expl-ind & full_non_expl.
conj_ref-ind := conj_non_expl-ind & ref-ind.
conj_full_ref-ind := conj_ref-ind & conj_full-ind & full_ref-ind.
conj_deg-ind := conj_event_or_deg-ind & conj_non_expl-ind & deg-ind.
conj_full_deg-ind := conj_deg-ind & conj_full-ind & full_deg-ind.

;; Could use this for the |Kim sang| => |*was sung by Kim| problem
unbound-ind := non_expl-ind.

; The basic semantic structure, a CONT, is just something with a handle.
; Conts are further classified into mrss (i.e., things with liszts) and
; relations (i.e., things that go on liszts).  Conts 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
; ARG1'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.

; ERB (03-10-96) 
; The intermediate types ques_prop_msg and prop_com_msg represent the
; natural classes needed for selection by know, announce, care, check,
; etc. and the analysis of THAT (see lextypes.tdl) and the 
; forthcoming analysis of tags on imperatives, respectively.

psoa := mrs_min0 &
  [ HOOK.INDEX event ].

psoa_basicmrs := psoa.

psoa_mrs := psoa_basicmrs & mrs.

; DPF 11-Feb-01 - For now, make all nom-objs have INDEX and E-INDEX the same, 
; to keep coordination working now that we want to treat coordination of 
; predicative phrases via their E-INDEX.  Probably will have to adjust this
; once we get more interesting temporal semantics for some nouns.
; DPF 29-Nov-02 - Can't have E-INDEX the same, since pre-nominal adjectives
; now unify their E-INDEX with that of the noun, and it's of type event.
; Recall that adjectives must do this unification in order to propagate the
; E-INDEX of the syntactic head, since the adjective is the semantic head.
; DPF 4-Dec-02 - For now, make all nouns not expose an external argument, so
; they won't appear as controlled complements.  Will perhaps want to treat
; indefinite NPs in copular constructions by relaxing this constraint for e.g.
; "Kim is a consultant"
; DPF 13-Nov-03 - Removed [ HOOK.XARG nothing ], since nom-obj is also the
; type assigned to determiners, and these need to be able to take degree
; specifiers, including comparative/equative ones like "as many X", where the
; degree-spec identifies its SPEC's XARG with one argument in the comparative
; relation - necessary because adjectives expose their modifiee noun's index
; as the adj's XARG (since the adj's INDEX is its event, for copula constr's).
; DPF 27-Nov-03 - Also, experimentally, make XARG of NPs be the handle of
; the nbar, which often seems to be needed, e.g. in it-clefts, where the
; rel clause wants to identify its message's handle with that of the nbar.

nom-obj := mrs.

; 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.

; Since some temporal nouns can be either arguments or VP modifiers, their 
; rel's ARG0 value (coindexed with INDEX of the containing MRS) must remain 
; unspecified for type.  Consider "Kim arrived Tuesday" vs. "Tuesday comes
; after Monday"; in the first, Tuesday must have an event ARG0, while in the
; second, it must have a ref-ind ARG0.

; ERB (24-10-96) Here is the series of relations that will be used for
; questions, etc.  Cf. Gizburg & Sag.

abstract_quant_relation := arg0_relation &
  [ PRED abstract_q_rel,
    ARG0 non_expl,
    RSTR handle,
    BODY handle ].

; Values in the feature QUE, used to distinguish ordinary WH-questions from 
; in-situ WH.
param := non_expl_or_param.

; Nominal sorts
nominal-sort := *sort*.
basic-entity-or-event := nominal-sort.
;; DPF 2018-03-23 - Added to enable constraints on SORT for by_means_of
norm-entity-or-event := basic-entity-or-event.
entity-or-qevent := basic-entity-or-event.
entity-or-nomevent := basic-entity-or-event.
nontime-or-qevent := entity-or-qevent.
entity-or-event := norm-entity-or-event & entity-or-nomevent.
entity := entity-or-event & nontime-or-qevent.
nonloc := entity.
human := nonloc.
nonhuman := nonloc.
;; DPF 2020-03-24 - Added type and subtype links as per trunk.
qevent-or-loc := nominal-sort.
location := norm-entity-or-event & entity-or-qevent & entity-or-nomevent &
	    qevent-or-loc.
time := location.

; DPF 14-nov-05 - Removed 'entity' supertype, since this means we get bad
; coordination as in "*We arrived here and the chair."
place := location.
;; For nominalized WH-questions
q-event := nontime-or-qevent & qevent-or-loc.
;nom-event := nontime-or-qevent & entity-or-nomevent.
nom-event := q-event & entity-or-nomevent.
; DPF 14-nov-09 - Can't make integers be of SORT number distinct from
; 'entity' (tempting, to block "Abrams one") because we also want
; "Kim is ten" which we currently treat as identity-copula with NP "ten"
; So removed basic_entity definition
;number := basic_entity.

;; For do-be construction
do-event := nominal-sort.


; modable_rel distinguishes those relations whose nominal lexical entries can 
; undergo a syntactic rule to produce a modifier phrase, as in "we'll meet
; next week" or "I'll do it my way".

; dir_state_modable_rel is the supertype of modable_rel and dir_or_state_rel
; used by verbs selecting for locative PPs including nominal adverbials which
; are converted from NPs to PPs via a syntactic rule which introduces the
; two-place locative relation.  This type is needed to support the shortcut of
; chart dependencies to filter out verb entries if the corresponding particle
; or preposition is not present, so we can still parse e.g. "Kim put it here".

; Nominal relations

instance_relation := arg0_relation &
  [ ARG0 individual_min ].

nom_relation := instance_relation &
  [ ARG0 ref-ind ].

; DPF 25-Sep-01 - Added [SORT entity] contrasted with [SORT time] to enable
; blocking of e.g. "the book that kim arrived" but allow "the day that Kim
; arrived"

reg_nom_relation := nom_relation &
  [ ARG0.SORT entity ].

reg_nom_wcarg_relation := reg_nom_relation & const_arg0_relation.

modable_nom_relation := nom_relation &
  [ ARG0.SORT entity ].

basic_diadic_nom_relation := instance_relation & arg01_relation.

diadic_nom_relation := basic_diadic_nom_relation &
  [ ARG1 basic_non_expl-ind ].

reg_diadic_nom_relation := diadic_nom_relation & nom_relation &
  [ ARG0.SORT entity ].

diadic_nom_carg_relation := basic_diadic_nom_relation & const_arg01_relation &
			    nom_relation.

triadic_nom_relation := diadic_nom_relation & basic_arg12_relation &
  [ ARG2 non_expl-ind ].

reg_triadic_nom_relation := reg_diadic_nom_relation & basic_arg12_relation &
  [ ARG2 non_expl-ind ].

basic_hcomp_nom_relation := basic_diadic_nom_relation & nom_relation &
  [ ARG1 handle ].

hcomp_nom_relation := basic_hcomp_nom_relation &
  [ ARG0.SORT entity ].

; Changed nominalize_rel and gerund_rel to subtype of non_temp_nom_rel rather 
; than reg_nom_rel to avoid semantically anomalous readings for e.g. "Kim is 
; sleeping".

nom_or_ger_relation := arg0_relation &
  [ ARG0.SORT nom-event ].

nominal_relation := basic_hcomp_nom_relation &
  [ PRED nominalization_rel ].

nominalize_relation := nominal_relation & nom_or_ger_relation.

gerund_relation := basic_diadic_nom_relation & nom_or_ger_relation &
  [ PRED nominalization_rel,
    ARG0 non_expl ].

temp_abstr_relation := nom_relation &
  [ ARG0.SORT time ].

const_arg0_relation := arg0_relation &
  [ CARG *top* ].

const_arg01_relation := const_arg0_relation & arg01_relation.

generic_named_nom_relation := nom_relation & const_arg0_relation.

named_nom_relation := generic_named_nom_relation &
  [ ARG0.SORT entity ].

generic_diadic_named_relation := generic_named_nom_relation & 
                                 const_arg01_relation &
                                 diadic_nom_relation.
generic_triadic_named_relation := generic_diadic_named_relation &
                                  triadic_nom_relation.
diadic_named_nom_relation := generic_diadic_named_relation &
                             reg_diadic_nom_relation.

; ARG1 is the minute_rel complement's ARG0, and ARG2 is the am_pm's ARG0.
numbered_hour_relation := const_arg0_relation &
  [ PRED numbered_hour_rel,
    ARG0 [ PNG png & [ PN 3s,
                       GEN neut ],
           SORT time ],
    CARG string ].

; Pronouns
; DPF 2-Jul-03 - Removed DIV - which was perhaps used earlier to block
; spurious application of bare-np rule.  Not desirable since antecedent could
; of course be mass or plural, and maybe want indices to be unifiable for
; anaphora resolution.

pron_relation := nom_relation &
  [ PRED pron_rel,
    ARG0 ref-ind & [ SORT entity ] ].

recip_pro_relation := nom_relation &
  [ PRED recip_pro_rel,
    ARG0 ref-ind & [ SORT entity ] ].

basic_adj_relation := arg0_relation.
adj_01_relation := basic_adj_relation & arg01_relation.
norm_adj_relation := basic_adj_relation & arg1_relation.
adj_relation := norm_adj_relation &
  [ ARG1 basic_non_expl ].

adj_arg1_relation := adj_relation.
adj_arg12_relation := adj_arg1_relation & arg12_relation.
adj_arg123_relation := adj_arg12_relation & arg123_relation.
it_adj_arg1_relation := adj_arg1_relation.
it_adj_arg12_relation := adj_arg12_relation & it_adj_arg1_relation.
it_adj_arg123_relation := adj_arg123_relation & it_adj_arg12_relation.

; For unknown word adjectives, which currently need a CARG
adj_wcarg_relation := norm_adj_relation & const_arg01_relation.

arg01_relation := arg0_relation &
  [ ARG1 semarg ].
arg01_only_relation := arg01_relation.
arg01_carg_relation := arg01_only_relation & const_arg01_relation.

adv_relation := arg01_relation &
  [ ARG0.E [ TENSE no_tense,
             ASPECT no_aspect ] ].
adv12_relation := adv_relation & arg2_relation.
adv_carg_relation := adv_relation & const_arg01_relation.

arg1_relation := arg01_relation & event_relation.

arg2_relation := relation &
  [ ARG2 semarg ].

arg3_relation := relation &
  [ ARG3 semarg ].

arg4_relation := relation &
  [ ARG4 semarg ].

basic_arg12_relation := arg01_relation & arg2_relation.
arg12_relation := basic_arg12_relation & arg1_relation.
arg123_relation := arg12_relation & arg3_relation.
arg1234_relation := arg123_relation & arg4_relation.

aux_arg1_relation := arg1_relation &
  [ PRED aux_arg1_rel ].

; Preposition relations

prep_relation := basic_arg12_relation &
  [ PRED prep_rel ].	    

prep_notense_relation := prep_relation &
  [ ARG0.E [ TENSE no_tense,
             ASPECT no_aspect ] ].

prep_123_relation := prep_relation & arg3_relation.

; Degree relations

degree_relation := arg01_relation &
  [ ARG0 individual_min ].

comparative_relation := degree_relation & basic_arg12_relation &
  [ ARG1 index ].

;; For "how" adjective, which quantifies over properties.

; For "how does Tuesdaay look" using second-order quantification (see notes for
; adj_wh_le in lextypes.tdl
; ARG1 is proposition, ARG2 is property

prpstn_to_prop_relation := arg12_relation &
  [ PRED prpstn_to_prop_rel,
    ARG1 handle,
    ARG2 non_expl-ind ].

comp_relation := prep_relation &
  [ ARG2 event_or_index,
    ARG0.E.TENSE no_tense ].
superl_relation := prep_relation &
  [ ARG2 event_or_index ].

subord_relation := arg12_relation &
  [ ARG1 handle,
    ARG2 handle ].

; Relation for unknown-word noun lexical typess
basic_arg12_carg_relation := basic_arg12_relation & const_arg01_relation.

; Relation for unknown-word verb lexical types, which currently need a ARG
arg12_carg_relation := arg12_relation & const_arg01_relation.

basic_conj_relation := basic_arg12_relation.

conj_relation := basic_conj_relation &
  [ PRED conj_rel,
    ARG0 conj-ind,
    ARG1 individual,
    ARG2 individual ].

; Abstract relations specified by more than one lexical entry

abstr_place_relation := nom_relation &
  [ ARG0.SORT place ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Number relations

; DPF 10-Feb-02 - Highly experimental addition of ARG0 attribute to get 
; segregation of numerical adjectives

integer_relation := arg01_relation &
  [ PRED integer_rel,
    ARG1 individual_min ].

const_relation := integer_relation & const_arg01_relation &
  [ PRED const_rel].

; plus, times
arg123_int_relation := integer_relation & arg123_relation &
  [ ARG2 handle,
    ARG3 handle ].

;; TYPES/SORTS
;; The CARDINAL feature determines whether its bearer is cardinal or not 
;; (i.e., is ordinal or cardinal).  Thus it is only appropriate for
;; numbers.  All numbers have a HEAD value of sort intsort, those
;; used adjectivally have heads of sort intadj (or one of its 
;; subsorts) or intdet (which has no subsorts).  Nominal uses are
;; not yet supported.
;;
;; Subcategorization, which is in terms of the maximum number of digits
;; allowed for the complement or specifier, is handled by the subsorts
;; of the digitn hierarchy.  Currently, only adjectives participate in
;; this hierarchy; there is only a single integer determiner ("one").
;; Nominal uses could be added by adding a type
;;          intnoun := intsort & digitn & noun.
;;
intsort := head & [ CARDINAL bool ].

digitn := head.

digit15 := digitn.
digit12 := digit15.
digit9 := digit12.
digit6 := digit9.
digit3 := digit6.
digit2 := digit3.
digit1 := digit2.

; The sorts    digitk    specify the number of digits of a lexeme 
; together with its largest complement and specifier.
; The sorts    digitk-    are used for subcategorization; they include
; values of k or fewer digits.
 
digit15- := digitn.
digit12- := digit15-.
digit9- := digit12-.
digit6- := digit9-.
digit3- := digit6-.
digit2- := digit3-.
digit1- := digit2-.

;; DPF 26-Apr-00 - Removed adj parent from intadj.
;; DPF 19-Sept-01 - Added supertype adj_or_intadj, for adj-intervals ("2 - 3")

intadj := adj_or_intadj & intadj_or_superl & intadj_or_comp.
intadjn := intadj & digitn.
intdet := intsort & det.

; intadj1- := intadj1.
; intadjk- means an integer adjective of at most k digits (when
;   combined with specifier and complement

intadj15- := intadj.
intadj15  := intadj15- & digit15.
intadj12- := intadj15-.
intadj12  := intadj12- & digit12.
intadj9- := intadj12-.
intadj9  := intadj9- & digit9.
intadj6- := intadj9-.
intadj6  := intadj6- & digit6.
intadj3- := intadj6-.
intadj3  := intadj3- & digit3.
intadj2- := intadj3-.
intadj2  := intadj2- & digit2.
intadj1  := intadj2- & digit1.

;; DPF 2012-09-12 - Changed MOD anti_synsem to synsem with HEAD no_head,
;; so fractions can undergo the adj-to-det rule, so we get |it rose 1/3 point|
;;
fractadj := intadj & [ MOD < synsem & [ LOCAL.CAT.HEAD no_head ] > ].

_here_a_1_rel := adj_rel.
_now_a_1_rel := adj_rel.
_there_a_1_rel := adj_rel.
_today_a_1_rel := adj_rel.
_tomorrow_a_1_rel := adj_rel & dofw_or_poss_q_rel.
_yesterday_a_1_rel := adj_rel & dofw_or_poss_q_rel.
_midmorning_a_1_rel := adj_rel.
_midafternoon_a_1_rel := adj_rel.
_tonight_a_1_rel := adj_rel & dofw_or_poss_q_rel.
_yesteryear_a_1_rel := adj_rel.
_east_a_1_rel := adj_rel.
_north_a_1_rel := adj_rel.
_south_a_1_rel := adj_rel.
_west_a_1_rel := adj_rel.
_right_a_1_rel := adj_rel.
_left_a_1_rel := adj_rel.
_outdoors_a_1_rel := adj_rel.
_indoors_a_1_rel := adj_rel.
_overseas_a_1_rel := adj_rel.
_online_a_1_rel := adj_rel.
_offline_a_1_rel := adj_rel.
_off+season_a_1_rel := adj_rel.
_overhead_a_1_rel := adj_rel.
_southeast_a_1_rel := adj_rel.
_southwest_a_1_rel := adj_rel.
_northeast_a_1_rel := adj_rel.
_northwest_a_1_rel := adj_rel.
_northward_a_1_rel := adj_rel.
_southward_a_1_rel := adj_rel.
_eastward_a_1_rel := adj_rel.
_westward_a_1_rel := adj_rel.
_northeastward_a_1_rel := adj_rel.
_southeastward_a_1_rel := adj_rel.
_northwestward_a_1_rel := adj_rel.
_southwestward_a_1_rel := adj_rel.
_upward_a_1_rel := adj_rel.
_downward_a_1_rel := adj_rel.
_uptown_a_1_rel := adj_rel.
_downtown_a_1_rel := adj_rel.
_midtown_a_1_rel := adj_rel.
_downhill_p_rel := dir_or_state_nontemp_rel.
_downhill_p_dir_rel := _downhill_p_rel & dir_rel.
_downhill_p_state_rel := _downhill_p_rel & state_loc_rel.
_heavenward_a_1_rel := adj_rel.
_however_a_1_rel := miscprep_rel.
_inward_a_1_rel := adj_rel.
_once+again_a_1_rel := miscprep_rel.
_outward_a_1_rel := adj_rel.
_inland_a_1_rel := adj_rel.
_late_p_rel := miscprep_rel.
_elsewhere_a_1_rel := adj_rel.
_forever_a_1_rel := adj_rel.
_long_a_1_rel := adj_rel.
_longer_a_1_rel := adj_rel.
_respective_a_1_rel := miscprep_rel.
_soon_p_rel := miscprep_rel.
_skyward_a_1_rel := adj_rel.
_thither_a_1_rel := adj_rel.
_underfoot_a_1_rel := adj_rel.
_underground_a_1_rel := adj_rel.
_underwater_a_1_rel := adj_rel.
_up+to+date_a_1_rel := miscprep_rel.
_worldwide_a_rel := miscprep_rel.
_yet_a_rel := miscprep_rel.
_yonder_a_1_rel := adj_rel.
_arrear_a_1_rel := adj_rel.
_one-by-one_a_1_rel := adj_rel.
;; DPF 2014-10-22 - These are maybe temporary until we find a better analysis
;; for |people age ten and older|.
_and_p_rel := miscprep_rel.
_or_p_rel := miscprep_rel.

much-many_a_rel := adj_rel & card_or_much_rel.
little-few_a_rel := adj_rel & card_or_much_rel.
few+if+any_a_rel := adj_rel & card_or_much_rel.

one+more_a_rel := much-many_a_rel.
one+less_a_rel := little-few_a_rel.

; For fragments
unknown_relation := arg0_relation &
  [ PRED unknown_rel,
    ARG0 event,
    ARG semarg ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Basic types

; DPF 10-Sep-03 Temporary redefinition of *sort* until we get rid of relations
; as values of MIN.

*sort* := *top*.

atom := 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-oblcons := 1-list & *oblcons*.
1-ocons := 1-list & *ocons*.

1-plus-list := *cons* &
  [ REST *cons* ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Basic types

; Used for characterization
initial-cfrom-val := atom.
initial-cto-val := atom.

string := initial-cfrom-val & initial-cto-val.

integer := atom.

; Lists

; ERB (13-12-97) This type is meant as a PRO -- i.e., what can show
; up in such things as the 'way' construction and embedded infinitival
; wh questions.  It should eventually receive some binding properties,
; but I don't know what to put there yet, and since we don't have
; a binding theory...

; ERB (14-12-97) I am adding the pron_rel to pro_ss, so that in the
; types like common_noun_vpcomp_synsem I don't have to put it in.  I
; can just take the KEYREL.

; ERB (14-12-97) No pron_rel for pro_ss.

; ERB (14-12-97) ... and pro_ss is accusative, to block (once I get
; infinitival relatives working) *A person left came in.

; ERB (14-12-97) This is moved here so as to be after acc, which is a 
; *sort* and thus can't handle being referenced before it is defined.

; ERB (19-01-98) PRO is obligatorially OPT -.  This keeps to_c_prop
; from serving as a modifier without first building a non_wh_rel,
; because hadj requires SUBJ *olist*.

; ERB (21-01-98) In order for PRO to be extractable, it can't be
; SLASH 0-dlist, and thus can't be a subtype of unexpressed.  With
; PRO underspecified for SLASH, something will always have to fill
; in that value.  In the case of subject non_wh_rels (e.g., 
; "Kim found a person to fix the sink") it is extracted, i.e., resolved
; to gappro by extrasubj.  In the cases where the PRO is the subject of
; a selected complement, the selector will impose SLASH 0-dlist on the
; PRO (this case includes equi constructions, embedded infinitival
; wh questions, and the complement of 'way' as in "Kim found a way
; to leave early").  In the case of the (as yet unimplemented) CP[to]
; subjects, the NP -> CP rule will probably do the work.  Alternatively,
; the selecting category could do it.  Finally, in the case of
; non-subject non_wh_rels (e.g., "Kim found a cheeseburger to devour"),
; the PRO must be SLASH 0-dlist because the non_wh_rel_rule limits
; the SLASH list to length one.
;
; On a related note, we want the distribution of gappro (i.e., of
; extracted PRO) to be quite constrained, and perhaps even limited
; to the subject non_wh_rels.  In general, we are relying on the
; restriction of SLASH to lists of length one stated in several places
; in the grammar, in addition to certain selecting categories' specifying
; an empty value for SLASH on the PROs in their complements' subjects
; to keep us from getting in trouble on this one.
;
; Finally, rather than make a subtype of pro_ss that says SLASH 0-dlist,
; I have opted to include that information on the type *prolist*.

; ERB (03-23-98) We need a way to identify indices introduced by a PRO
; that are "discourse bound".  We were using PT for this, but
; of course that doesn't work when the controller of the PRO is an overt
; pronoun.  So the new strategy is to make the INDEX a non_expl.
; This will unify with the indices introduced by (appropriate) controllers,
; and (hopefully) be identifiable if it is not controlled.

; DPF 27-May-99 - Removed OPT - constraint from pro_ss (see ERB (19-01-98) 
; above) since head_mod type now constrained via PRD rather than by requiring 
; SUBJ to be empty (cf note DPF 27-May-99 with n_adj_int_phrase in syntax.tdl).
; This change means the types for saturated subcats can again simply require 
; SUBJ to be *olist* rather than *null*, which e.g. allows verbal gerunds to 
; have optional but non-empty SUBJ value and still themselves appear as 
; subjects or complements without discharging that SUBJ value.
; DPF 15-Nov-03 - Added CONT.HOOK.INDEX ref-ind, which blocks spurious analysis
; of e.g. "to be" with expletive-subj elided be.  And linked it to --SIND
; for consistency.  
; DPF 06-dec-03 - But this fails to scope when there is no antecedent, as in
; "it takes a week to get there" (cf ok "It takes me a week to get there").
; So remove constraint of ref-ind.  Instead constrain NP-S rule's XARG.

pro_ss := expressed_non_canonical &
  [ LOCAL [ CAT.HEAD noun & [ CASE acc ],
            CONT.HOOK.INDEX #ind ],
    --SIND #ind ].

; ERB (19-01-98) We need a subtype of pro and gap so that to_c_prop
; can undergo subject extraction.  See the notes near non_wh_rel in
; syntax.tdl for the details of the analysis.
; I am positive that this will break something, but I could not
; guess what.

gappro := pro_ss & gap.
; Needed in infinitival vp_fin-frg_c rule to prevent spurious analyis with 
; subj gap.
nongappro := expressed_non_canonical &
  [ LOCAL [ CAT.HEAD noun,
            CONT.HOOK.INDEX #ind ],
    NONLOC.SLASH.LIST < >,
    --SIND #ind ].

*olist_or_prolist* := *list*.
*ocons_or_procons* := *olist_or_prolist* & *cons* &
  [ FIRST.NONLOC.SLASH.LIST < > ].
*olist* := *olist_or_prolist*.
*ocons* := *olist* & *ocons_or_procons* &
  [ FIRST unexpressed & [ OPT + ],
    REST  *olist* ].
*onull* := *olist* & *null*.

*obllist* := *list*.
; DPF 8-May-08 - Added constraint that element be HEAD subst to exclude
; "enough" deg complement added by lexical rule to adjectives
;; DPF 2022-12-14 - Further constrain HEAD to exclude adjectives, to avoid
;; "the twenty cats five".
*oblcons* := *obllist* & *cons* &
  [ FIRST canonical_or_unexpressed &
	  [ OPT -,
	    LOCAL.CAT.HEAD n_or_p_or_v_or_comp ],
    REST  *obllist* ].
*oblnull* := *obllist* & *null*.

*synlist* := *list*.
*syncons* := *synlist* & *cons* &
  [ FIRST synsem,
    REST  *synlist* ].
*syn_ocons* := *syncons* & *ocons*.
;; DPF 2020-04-18 - Tried replacing *oblnull* and *onull* with *anti_null* to 
;; allow NP coord where one of the NPs contains a v-mod phrase, as in 
;; |and a report by Kim that we arrived|. But, as suspected, this allows 
;; unwanted unifications, e.g. for mrk-nh_evnt_c which wants to exclude clausal
;;  complements, using SUBJ *synlist*, but filler-head phrases are 
;; SUBJ *anti_null*.  So instead make a supertype *anti_or_synnull* to use in 
;; NP-coord rule.
*synnull* := *synlist* & *oblnull* & *onull* & *anti_or_synnull*.

*phrlist* := *list*.
*phrcons* := *phrlist* & *cons* &
  [ FIRST phr_synsem & [ OPT + ],
    REST  *phrlist* ].
*phrnull* := *phrlist* & *onull* & *oblnull*.

*gaplist* := *list*.
*gapcons* := *gaplist* & *cons* &
  [ FIRST gap,
    REST  *null* ].
*gapnull* := *gaplist* & *null*.

*prolist* := *olist_or_prolist*.
*procons* := *prolist* & *ocons_or_procons* &
  [ FIRST pro_ss,
    REST *null* ].
*pronull* := *prolist* & *onull*.

;; Needed for NP-coordwhere one of the NPs contains a v-mod phrase, as in 
;; |and a report by Kim that we arrived|. 
*anti_or_synnull* := *list*.
*anti_list* := *anti_or_synnull*.
*anti_cons* := *anti_list* & *cons* &
  [ FIRST anti_synsem,
    REST *anti_list* ].
*anti_ocons* := *anti_cons* & *ocons*.
*anti_oblcons* := *anti_cons* & *oblcons*.
*anti_null* := *anti_list* & *onull* & *oblnull*.

;; *unexplist* is used for common nouns whose specifier is possibly obligatory,
;; but unexpressed, as in noun-noun compounds.  As usual, we use the same hack
;; as for *olist*, to get around the lack of recursive types in TDL.
;; Also used in head-spr rule in general, to seal off SPCMPS attribute for
;; an uninstantiated specifier of the non-hd dtr.

*unexplist* := *list*.

*unexpcons* := *unexplist* & *cons* &
  [ FIRST unexpressed,
    REST  *unexplist* ].

*unexpocons* := *unexpcons* & *ocons*.

;*unexpnull* := *unexplist* & *olist* & *null*.
*unexpnull* := *unexplist* & *onull*.

;; *substlist* is used in the adv_addition lexical rule, to prevent spurious
;; re-application of the rule to its own output by requiring the input to
;; be a (possibly empty) list of substantive synsems.
*substlist* := *list*.

*substcons* := *substlist* & *cons* &
  [ FIRST.LOCAL.CAT.HEAD subst,
    REST  *substlist* ].

; For there-copula
*substocons* := *substcons* & *ocons*.

;*substnull* := *substlist* & *olist* & *null*.
*substnull* := *substlist* & *onull* & *oblnull*.

; For constraint on COMPS.REST in passive rule, to block e.g.
; "*Kim was given by Abrams a book."
*obliquelist* := *list*.
*obliquecons* := *obliquelist* & *cons* &
  [ FIRST.LOCAL.CAT.HEAD non_noun,
    REST  *obliquelist* ].
*obliqueocons* := *obliquecons* & *ocons*.
*obliquenull* := *obliquelist* & *onull*.

;; DPF 2016-08-01 - For constraint in lexical rule making attrib adj from
;; verb participle, to avoid verbal-complement-taking verbs from undergoing
;; the rule, which would leave an unfilled handle-argument.
;; DPF 2017-06-15 - To avoid deverbal adjectives from verbs that treat the
;; PP as a scopal argument, restrict to only optional PPs.
;;
*norplist* := *list*.
*norpcons* := *norplist* & *cons* &
  [ FIRST.LOCAL.CAT.HEAD n_or_p,
    REST  *norplist* ].
*norpnull* := *norplist* & *onull*.

*norpoptlist* := *list*.
*norpocons* := *norpoptlist* & *ocons* &
  [ FIRST.LOCAL.CAT.HEAD n_or_p,
    REST  *norpoptlist* ].
*norponull* := *norpoptlist* & *onull*.

*indeplist* := *obliquelist*.
*indepcons* := *indeplist* & *obliquecons* &
  [ FIRST.LOCAL.CAT.HEAD.MINORS.MIN independent_rel,
    REST  *indeplist* ].
*indepocons* := *obliqueocons* & *indepcons*.
*indepnull* := *indeplist* & *obliquenull*.

;; DPF 2015-06-06 - Block normal passive rule from applying to V-Ptcl-NP as in
;; |*looked by Kim up|
;; DPF 2015-09-14 - Need both *satcons* and *satocons* because for some verbs
;; like |recommend| *satlist* needs to unify with *olist* and for others such
;; as |make-NP-ofPP| it must unify with a non-empty oblig list.
;;
*satlist* := *obliquelist*.
*satcons* := *satlist* & *obliquecons* &
  [ FIRST.LOCAL.CAT.VAL.COMPS *olist*,
    REST  *satlist* ].
*satocons* := *satcons* & *obliqueocons* &
  [ FIRST.LOCAL.CAT.VAL.COMPS *olist*,
    REST  *satlist* ].
*satnull* := *satlist* & *obliquenull*.

; Values of SLASH.LIST
;; DPF 2022-08-18 - For now, limit to at most one gap.
#|
*locallist* := *list*.
*localcons* := *locallist* & *cons* &
  [ FIRST mod_local,
    REST *locallist* ].
*localnull* := *locallist* & *null*.
|#
*locallist* := 0-1-list.
*localcons* := *locallist* & 1-list &
  [ FIRST mod_local,
    REST *locallist* ].
*localnull* := *locallist* & *null*.

*arglist* := *locallist*.
*argcons* := *arglist* & *localcons* &
  [ FIRST arg-local,
    REST *arglist* ].
*argnull* := *arglist* & *localnull*.

*modlist* := *locallist*.
;; DPF 2020-03-24 - CHECK: trunk does not have FIRST mod-local
;;
*modcons* := *modlist* & *localcons* &
  [ FIRST mod-local,
    REST *modlist* ].
*modnull* := *modlist* & *argnull*.

;; *paramlist* is used in the treatment of free relatives, to distinguish
;; the usual value of QUE from its use in free relatives, where QUE is instead
;; a list of referential indices.

*paramlist* := *list*.
*paramcons* := *paramlist* & 1-list &
  [ FIRST param,
    REST  *null* ].
*paramnull* := *paramlist* & *onull*.

*nogaplist* := *list*.
*nogapcons* := *nogaplist* & 1-list &
  [ FIRST synsem_min & [ NONLOC.SLASH.LIST < > ] ].
*nogapnull* := *nogaplist* & *null*.

*nogapantilist* := *nogaplist* & *anti_list*.
*nogapanticons* := *nogapcons* & *anti_cons*.
*nogapantinull* := *nogapnull* & *anti_null*.

*nogapsynlist* := *nogaplist* & *synlist*.
*nogapsyncons* := *nogapcons* & *nogapsynlist* & *syncons*.
*nogapsynnull* := *nogapnull* & *nogapsynlist*.

;; To enable excluding of focus movement in generation
*nonfocuslist* := *list*.
*nonfocuscons* := *nonfocuslist* & *cons* &
  [ FIRST non-focus,
    REST  *nonfocuslist* ].
*nonfocusnull* := *nonfocuslist* & *null*.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Computation types and wrapper types

with-computation := *top* &
  [ RESULT *top* ].

; supertype for diff-lists and append-lists
list-wrapper := *avm* &
  [ LIST *list* ].

*diff-list* := list-wrapper &
[ LIST *list*,
  LAST *list* ].

0-1-dlist := *diff-list* &
  [ LIST 0-1-list ].

; DPF 10-Oct-02 - Just a reminder that we cannot make the LIST value of 0-dlist
; be < >, much as we might like to, since we're doing lexical threading of
; SLASH (at least), and if we make all 0-dlists have LIST < >, then if the
; first of two complements is a proper name with SLASH 0-dlist, then the
; appended diff-list also has LIST <>, which prevents the second complement
; (or the subject) from being slashed, so we would even block "Who hired Kim".
; Instead, need to ensure manually that for each dtr in a construction, if the
; SLASH value of the nonhead dtr is not carried up via lexical threading by
; the head-dtr, or by the construction itself, then that dtr must be 
; constrained to be (seemingly redundantly) [ SLASH 0-dlist & [ LIST < > ] ].

0-dlist := 0-1-dlist &
  [ LIST #list,
    LAST #list ].

1-dlist := 0-1-dlist &
  [ LIST 1-list &
	 [ REST #rest & *null* ],
    LAST #rest ].


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Emerson-Turing types to enable append operation

; APPEND holds the lists to be appended
; LIST holds the result of the append operation
append-list := list-wrapper &
  [ LIST #list,
    APPEND list-of-list-wrappers-with-append & [ RESULT #list ] ].

list-of-list-wrappers-with-append := *list* & with-computation &
  [ RESULT *list* ].

; If there is at least one list to be appended,
; we need to create a copy (list-with-diff-list),
; which becomes the beginning of the new list (#start),
; and continues with the result of appending the rest (#middle).
cons-of-list-wrappers-with-append := *cons* & list-of-list-wrappers-with-append &
  [ FIRST.LIST list-with-diff-list & [ RESULT [ LIST #start,
                                                LAST #middle ] ],
    REST list-of-list-wrappers-with-append & [ RESULT #middle ],
    RESULT #start ].

; If there are no lists to be appended,
; the result is an empty list.
null-of-list-wrappers-with-append := *null* & list-of-list-wrappers-with-append &
  [ RESULT *null* ].

; Copy a closed list to create an open list, which can be appended
list-with-diff-list := *list* & with-computation &
  [ RESULT *diff-list* ].

; If there is at least one thing in the old list,
; create a pointer to the same element (#first),
; continue the rest of the new list with the rest of the old (#rest),
; and propagate the end of the list (#end).
cons-with-diff-list := *cons* & list-with-diff-list &
  [ FIRST #first,
    REST list-with-diff-list & [ RESULT [ LIST #rest,
                                          LAST #end ]],
    RESULT [ LIST [ FIRST #first,
                    REST #rest ],
             LAST #end ]].

; If there is nothing in the old list,
; the new list ends immediately.
null-with-diff-list := *null* & list-with-diff-list &
  [ RESULT [ LIST #end,
             LAST #end ]].

; For list-with-diff-list to be compatible with special subtypes of list,
; common subtypes must be defined, e.g.:
1-list-with-diff-list := 1-list & cons-with-diff-list.
1-plus-list-with-diff-list := 1-plus-list & cons-with-diff-list.
ocons-with-diff-list := *ocons* & cons-with-diff-list.
onull-with-diff-list := *onull* & null-with-diff-list.

localcons-with-diff-list := *localcons* & cons-with-diff-list.
localnull-with-diff-list := *localnull* & null-with-diff-list.

paramcons-with-diff-list := *paramcons* & cons-with-diff-list.
paramnull-with-diff-list := *paramnull* & null-with-diff-list.

argcons-with-diff-list := *argcons* & cons-with-diff-list.
argnull-with-diff-list := *argnull* & null-with-diff-list.

modcons-with-diff-list := *modcons* & cons-with-diff-list.
modnull-with-diff-list := *modnull* & null-with-diff-list.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; pred names

; for 'different from/than X'
than_or_from_rel := selected_prep_rel.

; for comparatives `than' or `as'
than_or_as_comp_rel := selected_prep_rel.

; For PP complements of (temporal) 'from X to/until/through Y'
abstr_until_sel_rel := selected_prep_rel.

_aback_p_sel_rel := selected_prep_rel.
_about_p_sel_rel := selected_prep_rel.
_across_p_sel_rel := selected_prep_rel.
_after_p_sel_rel := selected_prep_rel.
_against_p_sel_rel := selected_prep_rel.
_ahead_p_sel_rel := selected_prep_rel.
_along_p_sel_rel := selected_prep_rel.
_among_p_sel_rel := selected_prep_rel.
_apart_a_sel_rel := selected_adj_rel.
_around_p_sel_rel := selected_prep_rel.
_as_p_comp_rel := than_or_as_comp_rel.
_as_p_sel_rel := selected_prep_rel.
_as+to_p_sel_rel := selected_prep_rel.
_aside_p_sel_rel := selected_prep_rel.
_at_p_sel_rel := selected_prep_rel.
_away_p_sel_rel := selected_prep_rel.
_back_p_sel_rel := selected_prep_rel.
_behind_p_sel_rel := selected_prep_rel.
;; |We made believe we were pirates|
_believe_v_sel_rel := selected_prep_rel.
_between_p_sel_rel := selected_prep_rel.
_by_p_sel_rel := selected_prep_rel.
_by_p_cm_rel := selected_prep_rel.
;_clear_a_sel_rel := selected_adj_rel.
_do_a_sel_rel := selected_adj_rel.
_down_p_sel_rel := selected_prep_rel.
_even_a_sel_rel := selected_adj_rel.
for_p_sel_rel := selected_prep_rel.
_for_p_sel_rel := for_p_sel_rel.
_for_p_trgt_rel := for_p_sel_rel.
_forth_p_sel_rel := selected_prep_rel.
_forward_p_sel_rel := selected_prep_rel.
_from_p_sel_rel := than_or_from_rel.
_go_p_sel_rel := selected_prep_rel.
_home_a_sel_rel := selected_adj_rel.
_in_p_sel_rel := selected_prep_rel.
_into_p_sel_rel := selected_prep_rel.
_longer_a_sel_rel := selected_adj_rel.
of_p_sel_rel := selected_prep_rel.
_of_p_sel_rel := of_p_sel_rel.
_of_p_nbar_rel := of_p_sel_rel.
_of_p_comp_rel := selected_prep_rel.
_off_p_sel_rel := selected_prep_rel.
on_p_sel_rel := selected_prep_rel.
on_p_upon-sel_rel := selected_prep_rel.
_on_p_sel_rel := on_p_sel_rel & on_p_upon-sel_rel.
_onto_p_sel_rel := selected_prep_rel.
_onward_p_sel_rel := on_p_sel_rel.
_onwards_p_sel_rel := on_p_sel_rel.
_open_a_sel_rel := selected_adj_rel.
_out+of_p_sel_rel := selected_prep_rel.
_out_p_sel_rel := selected_prep_rel.
_over_p_sel_rel := selected_prep_rel.
_past_p_sel_rel := selected_prep_rel.
_round_p_sel_rel := selected_prep_rel.
_short_a_sel_rel := selected_adj_rel.
_still_a_sel_rel := selected_adj_rel.
_so_a_sel_rel := selected_adj_rel.
_thin_a_sel_rel := selected_adj_rel.
_through_p_sel_rel := selected_prep_rel.
_till_p_sel_rel := selected_prep_rel.
to_p_sel_rel := selected_prep_rel.
_to_p_nb-sel_rel := to_p_sel_rel.
_to_p_sel_rel := to_p_sel_rel.
;; For |see to it that S|
_to_p_expl-sel_rel := selected_prep_rel.
_together_p_sel_rel := selected_prep_rel.
_toward_p_sel_rel := selected_prep_rel.
_towards_p_sel_rel := selected_prep_rel.
_upside+down_p_sel_rel := selected_prep_rel.
_under_p_sel_rel := selected_prep_rel.
_until_p_sel_rel := selected_prep_rel.
_up+to_p_sel_rel := selected_prep_rel.
_up_p_sel_rel := selected_prep_rel.
_upon_p_sel_rel := on_p_upon-sel_rel.
_with_p_sel_rel := selected_prep_rel.
_without_p_sel_rel := selected_prep_rel.
_than_p_compar_rel := than_or_from_rel & than_or_as_comp_rel.
_yet_p_sel_rel := selected_prep_rel.

_a_p_per_rel := miscprep_rel.
_abaft_p_rel := dir_or_state_nontemp_rel.
_abaft_p_dir_rel := _abaft_p_rel & dir_rel.
_abaft_p_state_rel := _abaft_p_rel & state_loc_rel.
_abeam_p_rel := dir_or_state_nontemp_rel.
_abeam_p_dir_rel := _abeam_p_rel & dir_rel.
_abeam_p_state_rel := _abeam_p_rel & state_loc_rel.
_aboard_p_rel := dir_or_state_nontemp_rel.
_aboard_p_dir_rel := _aboard_p_rel & dir_rel.
_aboard_p_state_rel := _aboard_p_rel & state_loc_rel.
_about_p_rel := miscprep_rel.
_above_p_rel := dir_or_state_nontemp_rel.
_above_p_dir_rel := _above_p_rel & dir_rel.
_above_p_state_rel := _above_p_rel & state_loc_rel.
_aboveboard_p_rel := miscprep_rel.
_aboveground_p_rel := miscprep_rel.
_abroad_p_rel := miscprep_rel.
_absent_p_rel := miscprep_rel.
_according+to_p_rel := miscprep_rel.
_across_p_rel := prep_mod_rel.
_across_p_loc_rel := _across_p_rel & dir_or_state_nontemp_rel.
_across_p_dir_rel := _across_p_loc_rel & dir_rel.
_across_p_state_rel := _across_p_loc_rel & state_loc_rel.
;; DPF 2017-03-30 - The following may no longer be used.  FIX?
_across_p_temp_rel := _across_p_rel & temp_loc_sp_rel.
_ad_p_temp_rel := temp_loc_sp_rel.
_adjacent+to_p_rel := dir_or_state_nontemp_rel.
_adjacent+to_p_dir_rel := _adjacent+to_p_rel & dir_rel.
_adjacent+to_p_state_rel := _adjacent+to_p_rel & state_loc_rel.
_afar_p_rel := miscprep_rel.
_afield_p_rel := miscprep_rel.
_aft_p_rel := dir_or_state_nontemp_rel.
_aft_p_dir_rel := _aft_p_rel & dir_rel.
_aft_p_state_rel := _aft_p_rel & state_loc_rel.
_aft+of_p_rel := dir_or_state_nontemp_rel.
_aft+of_p_dir_rel := _aft+of_p_rel & dir_rel.
_aft+of_p_state_rel := _aft+of_p_rel & state_loc_rel.
_after_p_rel := temp_loc_rel.
_after_p_n-n_rel := miscprep_rel.
_afterward_p_rel := miscprep_rel.
_afterwards_p_rel := miscprep_rel.
_against_p_rel := dir_or_state_nontemp_rel.
_against_p_dir_rel := _against_p_rel & dir_rel.
_against_p_state_rel := _against_p_rel & state_loc_rel.
_ago_p_rel := state_loc_rel.
_again_a_rel := miscprep_rel.
_ahead_p_rel := miscprep_rel.
_ahead+of_p_rel := dir_or_state_nontemp_rel.
_ahead+of_p_dir_rel := _ahead+of_p_rel & dir_rel.
_ahead+of_p_state_rel := _ahead+of_p_rel & state_loc_rel.
_aka_p_rel := miscprep_rel.
_a+la_p_rel := miscprep_rel.
_albeit_x_rel := miscprep_rel.
_all+around_p_rel := miscprep_rel.
_all+over_p_rel := miscprep_rel.
_all+the+while_p_rel := miscprep_rel.
_alone_p_rel := miscprep_rel.
_along_p_rel := dir_or_state_nontemp_rel.
_along_p_dir_rel := _along_p_rel & dir_rel.
_along_p_state_rel := _along_p_rel & state_loc_rel.
_along+with_p_rel := miscprep_rel.
_alongside_p_rel := miscprep_rel.
_also_p_rel := miscprep_rel.
_although_p_rel := miscprep_rel.
_amid_p_rel := miscprep_rel.
_amidst_p_rel := miscprep_rel.
_among_p_rel := dir_or_state_nontemp_rel.
_among_p_dir_rel := _among_p_rel & dir_rel.
_among_p_state_rel := _among_p_rel & state_loc_rel.
_amongst_p_rel := dir_or_state_nontemp_rel.
_amongst_p_dir_rel := _amongst_p_rel & dir_rel.
_amongst_p_state_rel := _amongst_p_rel & state_loc_rel.
_anticlockwise_p_rel := dir_or_state_nontemp_rel.
_anticlockwise_p_dir_rel := _anticlockwise_p_rel & dir_rel.
_anticlockwise_p_state_rel := _anticlockwise_p_rel & state_loc_rel.
_apart_p_rel := dir_or_state_nontemp_rel.
_apart_p_dir_rel := _apart_p_rel & dir_rel.
_apart_p_state_rel := _apart_p_rel & state_loc_rel.
_apart+from_p_rel := miscprep_rel.
_apiece_p_rel := miscprep_rel.
_arm+in+arm_a_1_rel := miscprep_rel.
_around_p_rel := dir_or_state_nontemp_rel.
_around_p_dir_rel := _around_p_rel & dir_rel.
_around_p_state_rel := _around_p_rel & state_loc_rel.
_as_p_rel := miscprep_rel.
_as_p_nbar_rel := miscprep_rel.
_as+distinct+from_p_rel := miscprep_rel.
_as+far+as_p_rel := dir_or_state_nontemp_rel.
_as+far+as_p_dir_rel := _as+far+as_p_rel & dir_rel.
_as+far+as_p_state_rel := _as+far+as_p_rel & state_loc_rel.
_as+follows_p_rel := miscprep_rel.
_as+for_p_rel := miscprep_rel.
_as+if_p_rel := miscprep_rel.
_as+is_p_rel := miscprep_rel.
_as+of_p_rel := temp_loc_rel.
_as+opposed+to_p_rel := miscprep_rel.
_as+regards_p_rel := miscprep_rel.
_as+though_x_rel := miscprep_rel.
_as+to_p_rel := miscprep_rel.
;; DPF 2016-02-15 - This one is used for prep rather than conj |as well as|,
;; to let us get non-robust comma-marked |Kim, as well as Browne, ...|
_as+well+as_p_rel := miscprep_rel.
_ashore_p_rel := miscprep_rel.
_aside_p_rel := miscprep_rel.
_aside+from_p_rel := miscprep_rel.
_astray_p_rel := miscprep_rel.
_astride_p_rel := miscprep_rel.
_at+best_p_rel := miscprep_rel.
_at+large_p_rel := miscprep_rel.
_at+present_p_rel := miscprep_rel.
_at+random_p_rel := miscprep_rel.
_at+worst_p_rel := miscprep_rel.
_at_p_rel := prep_mod_rel.
_at_p_loc_rel := _at_p_rel & nontemp_loc_sp_rel.
_at_p_state_rel := _at_p_loc_rel & state_loc_rel.
_at_p_dir_rel := _at_p_loc_rel & dir_rel.
_at_p_temp_rel := _at_p_rel & temp_loc_sp_rel.
_athwart_p_rel := dir_or_state_nontemp_rel.
_athwart_p_dir_rel := _athwart_p_rel & dir_rel.
_athwart_p_state_rel := _athwart_p_rel & state_loc_rel.
_atop_p_rel := miscprep_rel.
_away_p_rel := dir_or_state_nontemp_rel.
_away_p_dir_rel := _away_p_rel & dir_rel.
_away_p_state_rel := _away_p_rel & state_loc_rel.
_awhile+ago_p_rel := miscprep_rel.
_back_p_rel := miscprep_rel.
_back+in_p_rel := dir_or_state_nontemp_rel.
_back+in_p_dir_rel := _back+in_p_rel & dir_rel.
_back+in_p_state_rel := _back+in_p_rel & state_loc_rel.
_back+to+front_p_rel := miscprep_rel.
_backward_p_rel := miscprep_rel.
_backwards_p_rel := miscprep_rel.
_bc_p_temp_rel := temp_loc_sp_rel.
_bce_p_temp_rel := temp_loc_sp_rel.
_because+of_p_rel := miscprep_rel.
_before_p_rel := dir_or_state_nontemp_rel.
_before_p_dir_rel := _before_p_rel & dir_rel.
_before_p_state_rel := _before_p_rel & state_loc_rel.
_beforehand_p_rel := miscprep_rel.
_below_p_rel := dir_or_state_nontemp_rel.
_below_p_dir_rel := _below_p_rel & dir_rel.
_below_p_state_rel := _below_p_rel & state_loc_rel.
_behind_p_rel := dir_or_state_nontemp_rel.
_behind_p_dir_rel := _behind_p_rel & dir_rel.
_behind_p_state_rel := _behind_p_rel & state_loc_rel.
_beneath_p_rel := dir_or_state_nontemp_rel.
_beneath_p_dir_rel := _beneath_p_rel & dir_rel.
_beneath_p_state_rel := _beneath_p_rel & state_loc_rel.
_beside_p_rel := dir_or_state_nontemp_rel.
_beside_p_dir_rel := _beside_p_rel & dir_rel.
_beside_p_state_rel := _beside_p_rel & state_loc_rel.
_besides_p_rel := miscprep_rel.
_between_p_rel := temp_loc_rel.
_betwixt_p_rel := temp_loc_rel.
_beyond_p_rel := dir_or_state_nontemp_rel.
_beyond_p_dir_rel := _beyond_p_rel & dir_rel.
_beyond_p_state_rel := _beyond_p_rel & state_loc_rel.
_broadside_p_rel := dir_or_state_nontemp_rel.
_but+for_p_rel := miscprep_rel.
_but_p_except_rel := miscprep_rel.
_by_p_rel := prep_mod_rel.
_by_p_loc_rel := _by_p_rel & dir_or_state_nontemp_rel.
_by_p_dir_rel := _by_p_loc_rel & dir_rel.
_by_p_state_rel := _by_p_loc_rel & state_loc_rel.
_by_p_temp_rel := _by_p_rel & temp_loc_rel.
_by_p_means_rel := miscprep_rel.
_by+means+of_p_rel := miscprep_rel.
_by+then_p_rel := miscprep_rel.
_by+way+of_p_rel := miscprep_rel.
_by+colon_p_rel := miscprep_rel.
_by_p_n-n_rel := miscprep_rel.
_ce_p_temp_rel := temp_loc_sp_rel.
_circa_p_rel := temp_loc_rel.
_close+to_p_rel := miscprep_rel.
_colon_p_namely_rel := loc_abstr_rel & nondir_or_adv_rel.
_concerning_p_rel := miscprep_rel.
_care+of_p_rel := miscprep_rel.
_clockwise_p_rel := dir_or_state_nontemp_rel.
_clockwise_p_dir_rel := _clockwise_p_rel & dir_rel.
_clockwise_p_state_rel := _clockwise_p_rel & state_loc_rel.
_close+by_p_rel := miscprep_rel.
_come_p_temp_rel := temp_loc_rel.
_counterclockwise_p_rel := dir_or_state_nontemp_rel.
_counterclockwise_p_dir_rel := _counterclockwise_p_rel & dir_rel.
_counterclockwise_p_state_rel := _counterclockwise_p_rel & state_loc_rel.
_counter+to_p_rel := miscprep_rel.
_countrywide_a_1_rel := miscprep_rel.
_crossways_p_rel := dir_or_state_nontemp_rel.
_crossways_p_dir_rel := _crossways_p_rel & dir_rel.
_crossways_p_state_rel := _crossways_p_rel & state_loc_rel.
_currently_p_rel := miscprep_rel.
_dashpnct_p_rel := miscprep_rel & abstr_until_rel.
_despite_p_rel := miscprep_rel.
_died_a_abb_rel := temp_loc_sp_rel.
_down_p_rel := dir_or_state_nontemp_rel.
_down_p_dir_rel := _down_p_rel & dir_rel.
_down_p_state_rel := _down_p_rel & state_loc_rel.
_downstairs_p_rel := miscprep_rel.
_downstream_p_rel := miscprep_rel.
_downstream+of_p_rel := dir_or_state_nontemp_rel.
_downstream+of_p_dir_rel := _downstream+of_p_rel & dir_rel.
_downstream+of_p_state_rel := _downstream+of_p_rel & state_loc_rel.
_down+under_p_rel := dir_or_state_nontemp_rel.
_down+under_p_dir_rel := _down+under_p_rel & dir_rel.
_down+under_p_state_rel := _down+under_p_rel & state_loc_rel.
_due+to_p_rel := miscprep_rel.
_during_p_rel := temp_loc_rel.
_e+g_p_rel := miscprep_rel.
_each_p_rel := miscprep_rel.
_en+route_p_rel := dir_or_state_nontemp_rel.
_en+route_p_dir_rel := _en+route_p_rel & dir_rel.
_en+route_p_state_rel := _en+route_p_rel & state_loc_rel.
_esp_p_rel := miscprep_rel.
_especially_p_rel := miscprep_rel.
_ever+before_p_rel := temp_loc_rel.
_ever+since_p_rel := temp_loc_rel.
_every+now+and+again_p_rel := miscprep_rel.
_every+now+and+then_p_rel := miscprep_rel.
_ex_p_rel := miscprep_rel.
_except+for_p_rel := miscprep_rel.
_except_p_rel := miscprep_rel.
_excepting_p_rel := miscprep_rel.
_eye+to+eye_p_rel := dir_or_state_nontemp_rel.
_eye+to+eye_p_dir_rel := _eye+to+eye_p_rel & dir_rel.
_eye+to+eye_p_state_rel := _eye+to+eye_p_rel & state_loc_rel.
_face+to+face_p_rel := dir_or_state_nontemp_rel.
_face+to+face_p_dir_rel := _face+to+face_p_rel & dir_rel.
_face+to+face_p_state_rel := _face+to+face_p_rel & state_loc_rel.
_facing_p_rel := dir_or_state_nontemp_rel.
_facing_p_dir_rel := _facing_p_rel & dir_rel.
_facing_p_state_rel := _facing_p_rel & state_loc_rel.
_farther+on_p_rel := miscprep_rel.
_for_p_rel := miscprep_rel.
_for_p_ncond-i_rel := miscprep_rel.
_for+example_p_rel := miscprep_rel.
_for+instance_p_rel := miscprep_rel.
_for+lack+of_p_rel := miscprep_rel.
_for+the+better_p_rel := miscprep_rel.
_fore_p_rel := dir_or_state_nontemp_rel.
_fore_p_dir_rel := _fore_p_rel & dir_rel.
_fore_p_state_rel := _fore_p_rel & state_loc_rel.
_formerly_p_rel := miscprep_rel.
_forth_p_rel := dir_or_state_nontemp_rel.
_forth_p_dir_rel := _forth_p_rel & dir_rel.
_forth_p_state_rel := _forth_p_rel & state_loc_rel.
_forward_p_rel := dir_or_state_nontemp_rel.
_forward_p_dir_rel := _forward_p_rel & dir_rel.
_forward_p_state_rel := _forward_p_rel & state_loc_rel.
_forward+of_p_rel := dir_or_state_nontemp_rel.
_forward+of_p_dir_rel := _forward+of_p_rel & dir_rel.
_forward+of_p_state_rel := _forward+of_p_rel & state_loc_rel.
_forwards_p_rel := miscprep_rel.
_fore+and+aft_p_rel := miscprep_rel.
_from_p_rel := dir_or_state_nontemp_rel.
_from_p_dir_rel := _from_p_rel & dir_rel.
_from_p_state_rel := _from_p_rel & state_loc_rel.
_from_p_place-in_rel := miscprep_rel.
_from_p_nbar_rel := dir_or_state_nontemp_rel.
_from_p_nb-dir_rel := _from_p_nbar_rel & dir_rel.
_from_p_nb-state_rel := _from_p_nbar_rel & state_loc_rel.
_from_p_to_rel := dir_rel & instance_rel.
_from_p_to-n_rel := dir_rel & instance_rel.
_from_p_time-on_rel := miscprep_rel.
_from_p_time_rel := temp_loc_sp_rel.
_front+to+back_p_rel := miscprep_rel.
_further_p_rel := dir_or_state_nontemp_rel.
_further_p_dir_rel := _further_p_rel & dir_rel.
_further_p_state_rel := _further_p_rel & state_loc_rel.
_further+on_p_rel := miscprep_rel.
_give+or+take_p_rel := miscprep_rel.
_given+that_p_rel := miscprep_rel.
_going+by_p_rel := miscprep_rel.
_gone+by_p_rel := miscprep_rel.
_hand+in+hand+with_p_rel := miscprep_rel.
_hence_p_rel := miscprep_rel.
_hereabouts_p_rel := miscprep_rel.
_herein_p_rel := dir_or_state_nontemp_rel.
_herein_p_dir_rel := _herein_p_rel & dir_rel.
_herein_p_state_rel := _herein_p_rel & state_loc_rel.
_higher_p_rel := dir_rel & instance_rel.
_hither_p_rel := dir_or_state_nontemp_rel.
_hither_p_dir_rel := _hither_p_rel & dir_rel.
_hither_p_state_rel := _hither_p_rel & state_loc_rel.
_hitherward_p_rel := miscprep_rel.
_home_p_rel := dir_or_state_nontemp_rel.
_home_p_dir_rel := _home_p_rel & dir_rel.
_home_p_state_rel := _home_p_rel & state_loc_rel.
_i+e_p_rel := miscprep_rel.
_if_x_rel := miscprep_rel.
_if+any_p_rel := miscprep_rel.
_in+addition+to_p_rel := miscprep_rel.
_in+and+of_p_rel := miscprep_rel.
_in+back+of_p_rel := dir_or_state_nontemp_rel.
_in+back+of_p_dir_rel := _in+back+of_p_rel & dir_rel.
_in+back+of_p_state_rel := _in+back+of_p_rel & state_loc_rel.
_in+behalf+of_p_rel := miscprep_rel.
_in+between_p_rel := dir_or_state_nontemp_rel.
_in+between_p_dir_rel := _in+between_p_rel & dir_rel.
_in+between_p_state_rel := _in+between_p_rel & state_loc_rel.
_in+case+of_p_rel := miscprep_rel.
_in+connection+with_p_rel := miscprep_rel.
_in+earnest_p_rel := miscprep_rel.
_in+front+of_p_rel := dir_or_state_nontemp_rel.
_in+front+of_p_dir_rel := _in+front+of_p_rel & dir_rel.
_in+front+of_p_state_rel := _in+front+of_p_rel & state_loc_rel.
_in+full_p_rel := miscprep_rel.
_in+general_a_1_rel := miscprep_rel.
_in-house_a_1_rel := miscprep_rel.
_in+lieu+of_p_rel := miscprep_rel.
_in+particular_p_rel := miscprep_rel.
_in+private_a_1_rel := miscprep_rel.
_in+situ_a_1_rel := miscprep_rel.
_in+so+doing_p_rel := miscprep_rel.
_in+the+know_a_1_rel := miscprep_rel.
_in+the+meanwhile_p_rel := miscprep_rel.
_in_p_rel := prep_mod_rel.
_in_p_loc_rel := _in_p_rel & nontemp_loc_sp_rel.
_in_p_dir_rel := _in_p_loc_rel & dir_rel.
_in_p_state_rel := _in_p_loc_rel & state_loc_rel.
_in_p_temp_rel := _in_p_rel & temp_loc_sp_rel.
_in+place+of_p_rel := miscprep_rel.
_in+regard+to_p_rel := miscprep_rel.
_in+relation+to_p_rel := miscprep_rel.
_in+spite+of_p_rel := miscprep_rel.
_instead+of_p_rel := miscprep_rel.
_in+the+course+of_p_rel := miscprep_rel.
_in+the+way+of_p_rel := miscprep_rel.
_in+view+of_p_rel := miscprep_rel.
_inboard+of_p_rel := dir_or_state_nontemp_rel.
_inboard+of_p_dir_rel := _inboard+of_p_rel & dir_rel.
_inboard+of_p_state_rel := _inboard+of_p_rel & state_loc_rel.
_including_p_rel := miscprep_rel.
_independently+of_p_rel := miscprep_rel.
_industrywide_p_rel := miscprep_rel.
_inside+of_p_rel := dir_or_state_nontemp_rel.
_inside+of_p_dir_rel := _inside+of_p_rel & dir_rel.
_inside+of_p_state_rel := _inside+of_p_rel & state_loc_rel.
_inside_p_rel := dir_or_state_nontemp_rel.
_inside_p_dir_rel := _inside_p_rel & dir_rel.
_inside_p_state_rel := _inside_p_rel & state_loc_rel.
_instead_p_rel := miscprep_rel.
_into_p_rel := dir_or_state_nontemp_rel.
_into_p_dir_rel := _into_p_rel & dir_rel.
_into_p_state_rel := _into_p_rel & state_loc_rel.
_in+toward_p_rel := miscprep_rel.
_in+wait_p_rel := miscprep_rel.
_irregardless+of_p_rel := miscprep_rel.
_islandwide_a_1_rel := miscprep_rel.
_just+like_p_rel := miscprep_rel.
_lately_a_rel := miscprep_rel.
_later_p_rel := miscprep_rel.
_later+on_p_rel := miscprep_rel.
_left+to+right_p_rel := miscprep_rel.
_less_p_rel := miscprep_rel.
_less+than_p_rel := miscprep_rel.
_let+alone_p_rel := miscprep_rel.
_like_p_rel := miscprep_rel.
_literally_p_rel := miscprep_rel.
_long+ago_p_rel := miscprep_rel.
_long+past_p_rel := miscprep_rel.
_maximum_p_rel := miscprep_rel.
_meantime_p_rel := miscprep_rel.
_meanwhile_p_rel := miscprep_rel.
_midfield_p_rel := state_loc_rel.
_minus_p_rel := miscprep_rel.
_mod_p_rel := miscprep_rel.
_modulo_p_rel := miscprep_rel.
_more+than_p_rel := miscprep_rel.
_namely_p_rel := miscprep_rel.
_nationwide_a_1_rel := miscprep_rel.
_near_p_rel := dir_or_state_nontemp_rel.
_near_p_dir_rel := _near_p_rel & dir_rel.
_near_p_state_rel := _near_p_rel & state_loc_rel.
_nearby_p_rel := miscprep_rel.
_nearest_p_rel := state_loc_rel.
_never+mind_p_rel := miscprep_rel.
_next+to_p_rel := dir_or_state_nontemp_rel.
_next+to_p_dir_rel := _next+to_p_rel & dir_rel.
_next+to_p_state_rel := _next+to_p_rel & state_loc_rel.
_next+door_p_rel := dir_or_state_nontemp_rel.
_next+door_p_dir_rel := _next+door_p_rel & dir_rel.
_next+door_p_state_rel := _next+door_p_rel & state_loc_rel.
_no+matter_p_rel := miscprep_rel.
_notwithstanding_p_rel := miscprep_rel.
_not+to+mention_p_rel := miscprep_rel.
_now_p_rel := miscprep_rel.
_nowadays_p_rel := miscprep_rel.
of_p_rel := miscprep_rel & compound_or_prep_rel.
_of_p_rel := of_p_rel.
_of+course_p_rel := miscprep_rel.
;; Used in hack lexical entry for dictionary definitions, needed since ordinary
;; possessive "of" blocks extraction of complement.
_of+or+relating+to_p_rel := miscprep_rel.
_off-course_p_rel := dir_or_state_nontemp_rel.
_off-course_p_dir_rel := _off-course_p_rel & dir_rel.
_off-course_p_state_rel := _off-course_p_rel & state_loc_rel.
_off+of_p_rel := miscprep_rel.
_off_p_rel := dir_or_state_nontemp_rel.
_off_p_dir_rel := _off_p_rel & dir_rel.
_off_p_state_rel := _off_p_rel & state_loc_rel.
_offshore_p_rel := miscprep_rel.
_offside_p_rel := dir_or_state_nontemp_rel.
_offside_p_dir_rel := _offside_p_rel & dir_rel.
_offside_p_state_rel := _offside_p_rel & state_loc_rel.
_on_p_rel := prep_mod_rel.
_on_p_loc_rel := _on_p_rel & nontemp_loc_sp_rel.
_on_p_dir_rel := _on_p_loc_rel & dir_rel.
_on_p_state_rel := _on_p_loc_rel & state_loc_rel.
_on_p_temp_rel := _on_p_rel & temp_loc_sp_rel.
_on+account+of_p_rel := miscprep_rel.
_on+behalf+of_p_rel := miscprep_rel.
_on+board_p_rel := miscprep_rel.
_on+foot_p_rel := miscprep_rel.
_on+the+basis+of_p_rel := miscprep_rel.
_on+the+part+of_p_rel := miscprep_rel.
_once_p_rel := temp_loc_rel.
_once_x_rel := miscprep_rel.
_only+if_p_rel := miscprep_rel.
_only+when_p_rel := miscprep_rel.
_onshore_p_rel := miscprep_rel.
_onside_p_rel := dir_or_state_nontemp_rel.
_onside_p_dir_rel := _onside_p_rel & dir_rel.
_onside_p_state_rel := _onside_p_rel & state_loc_rel.
_onsite_p_rel := miscprep_rel.
_onto_p_rel := dir_or_state_nontemp_rel.
_onto_p_dir_rel := _onto_p_rel & dir_rel.
_onto_p_state_rel := _onto_p_rel & state_loc_rel.
_onward_p_rel := dir_or_state_nontemp_rel.
_onward_p_dir_rel := _onward_p_rel & dir_rel.
_onward_p_state_rel := _onward_p_rel & state_loc_rel.
_onwards_p_rel := dir_or_state_nontemp_rel.
_onwards_p_dir_rel := _onwards_p_rel & dir_rel.
_onwards_p_state_rel := _onwards_p_rel & state_loc_rel.
_opposite_p_rel := dir_or_state_nontemp_rel.
_opposite_p_dir_rel := _opposite_p_rel & dir_rel.
_opposite_p_state_rel := _opposite_p_rel & state_loc_rel.
_other+than_p_rel := miscprep_rel.
_out_p_rel := dir_or_state_nontemp_rel.
_out_p_dir_rel := _out_p_rel & dir_rel.
_out_p_state_rel := _out_p_rel & state_loc_rel.
_out+of_p_rel := dir_or_state_nontemp_rel.
_out+of_p_dir_rel := _out+of_p_rel & dir_rel.
_out+of_p_state_rel := _out+of_p_rel & state_loc_rel.
_out+of+doors_p_rel := dir_or_state_nontemp_rel.
_out+of+doors_p_dir_rel := _out+of+doors_p_rel & dir_rel.
_out+of+doors_p_state_rel := _out+of+doors_p_rel & state_loc_rel.
_outboard+of_p_rel := dir_or_state_nontemp_rel.
_outboard+of_p_dir_rel := _outboard+of_p_rel & dir_rel.
_outboard+of_p_state_rel := _outboard+of_p_rel & state_loc_rel.
_outside_p_rel := dir_or_state_nontemp_rel.
_outside_p_dir_rel := _outside_p_rel & dir_rel.
_outside_p_state_rel := _outside_p_rel & state_loc_rel.
_outside+of_p_rel := dir_or_state_nontemp_rel.
_outside+of_p_dir_rel := _outside+of_p_rel & dir_rel.
_outside+of_p_state_rel := _outside+of_p_rel & state_loc_rel.
_over_p_rel := dir_or_state_nontemp_rel.
_over_p_dir_rel := _over_p_rel & dir_rel.
_over_p_state_rel := _over_p_rel & state_loc_rel.
_over_p_temp_rel := temp_loc_sp_rel.
_overall_p_rel := miscprep_rel.
_overboard_p_rel := miscprep_rel.
_overland_p_rel := miscprep_rel.
_overnight_a_1_rel := adj_rel.
_owing+to_p_rel := miscprep_rel.
_pace_p_latin_rel := miscprep_rel.
_past_p_rel := dir_or_state_nontemp_rel.
_past_p_dir_rel := _past_p_rel & dir_rel.
_past_p_state_rel := _past_p_rel & state_loc_rel.
_per_p_rel := miscprep_rel.
_per+centimeter_p_rel := miscprep_rel.
_per+se_p_rel := miscprep_rel.
_per+mol_p_rel := miscprep_rel.
_per+second_p_rel := miscprep_rel.
_plus_p_rel := miscprep_rel.
_previous+to_p_rel := temp_loc_rel.
_previously_p_rel := miscprep_rel.
_prior+to_p_rel := temp_loc_rel.
_pro+rata_p_rel := miscprep_rel.
_qua_p_rel := miscprep_rel.
_rather+than_p_rel := miscprep_rel.
_rearward_p_rel := dir_or_state_nontemp_rel.
_rearward_p_dir_rel := _rearward_p_rel & dir_rel.
_rearward_p_state_rel := _rearward_p_rel & state_loc_rel.
_regarding_p_rel := miscprep_rel.
_regardless+of_p_rel := miscprep_rel.
_rightarrow_p_rel := miscprep_rel.
_right+away_p_rel := miscprep_rel.
_right+to+left_p_rel := miscprep_rel.
_round_p_rel := dir_or_state_nontemp_rel.
_round_p_dir_rel := _round_p_rel & dir_rel.
_round_p_state_rel := _round_p_rel & state_loc_rel.
_save_p_rel := miscprep_rel.
_save+for_p_rel := miscprep_rel.
_shoulder+to+shoulder_p_rel := dir_or_state_nontemp_rel.
_shoulder+to+shoulder_p_dir_rel := _shoulder+to+shoulder_p_rel & dir_rel.
_shoulder+to+shoulder_p_state_rel := _shoulder+to+shoulder_p_rel & state_loc_rel.
_side+by+side_p_rel := miscprep_rel.
_sideways_p_rel := dir_or_state_nontemp_rel.
_sideways_p_dir_rel := _sideways_p_rel & dir_rel.
_sideways_p_state_rel := _sideways_p_rel & state_loc_rel.
_since_p_rel := temp_loc_rel.
_something+like_p_rel := miscprep_rel.
_star+h_p_rel := miscprep_rel.
_starboard_p_rel := miscprep_rel.
_such+as_p_rel := miscprep_rel.
_systemwide_a_rel := miscprep_rel.
_thanks+to_p_rel := miscprep_rel.
_than_p_ind_rel := miscprep_rel.
_that+is_p_rel := miscprep_rel.
_the+same_p_as_rel := miscprep_rel.
_the+world+over_p_rel := miscprep_rel.
_then_p_temp_rel := miscprep_rel.
_thereabouts_p_rel := miscprep_rel.
_thereafter_p_rel := miscprep_rel.
_therefrom_p_rel := miscprep_rel.
_thereof_p_rel := miscprep_rel.
_therein_p_rel := dir_or_state_nontemp_rel.
_therein_p_dir_rel := _therein_p_rel & dir_rel.
_therein_p_state_rel := _therein_p_rel & state_loc_rel.
_therewith_p_rel := miscprep_rel.
_thither_p_rel := dir_or_state_nontemp_rel.
_thither_p_dir_rel := _thither_p_rel & dir_rel.
_thither_p_state_rel := _thither_p_rel & state_loc_rel.
_thitherward_p_rel := miscprep_rel.
_though_x_rel := miscprep_rel.
_through_p_rel := dir_or_state_nontemp_rel.
_through_p_dir_rel := _through_p_rel & dir_rel & abstr_until_rel.
_through_p_state_rel := _through_p_rel & state_loc_rel. 
_throughout_p_rel := dir_or_state_nontemp_rel.
_throughout_p_dir_rel := _throughout_p_rel & dir_rel.
_throughout_p_state_rel := _throughout_p_rel & state_loc_rel.
_times_p_rel := miscprep_rel.
_to+boot_p_rel := miscprep_rel.
_to+date_p_rel := miscprep_rel.
_to+do+with_p_rel := miscprep_rel.
;; DPF 2014-05-18 - Removed abstr_until_rel to avoid analysis for
;; |from NP to nbar|
_to_p_nbar_rel := prep_mod_rel.
_to_p_rel := to_or_with_p_rel & abstr_until_rel.
_to_p_dir_rel := _to_p_rel & dir_rel.
_to_p_state_rel := _to_p_rel & state_loc_rel.
_together_p_rel := dir_or_state_nontemp_rel.
_together_p_dir_rel := _together_p_rel & dir_rel.
_together_p_state_rel := _together_p_rel & state_loc_rel.
_together+with_p_rel := miscprep_rel.
_too_a_also_rel := adv_rel.
_top+to+bottom_p_rel := miscprep_rel.
_toward_p_rel := dir_or_state_nontemp_rel.
_toward_p_dir_rel := _toward_p_rel & dir_rel.
_toward_p_state_rel := _toward_p_rel & state_loc_rel.
_towards_p_rel := dir_or_state_nontemp_rel.
_towards_p_dir_rel := _towards_p_rel & dir_rel.
_towards_p_state_rel := _towards_p_rel & state_loc_rel.
_under_p_rel := dir_or_state_nontemp_rel.
_under_p_dir_rel := _under_p_rel & dir_rel.
_under_p_state_rel := _under_p_rel & state_loc_rel.
_underneath_p_rel := dir_or_state_nontemp_rel.
_underneath_p_dir_rel := _underneath_p_rel & dir_rel.
_underneath_p_state_rel := _underneath_p_rel & state_loc_rel.
_unless_x_rel := miscprep_rel.
_unlike_p_rel := miscprep_rel.
_until_p_rel := miscprep_rel & abstr_until_rel.
;;_until+recently_p_rel := miscprep_rel.
_unto_p_rel := dir_or_state_nontemp_rel.
_unto_p_dir_rel := _unto_p_rel & dir_rel.
_unto_p_state_rel := _unto_p_rel & state_loc_rel.
_up_p_rel := dir_or_state_nontemp_rel.
_up_p_dir_rel := _up_p_rel & dir_rel.
_up_p_state_rel := _up_p_rel & state_loc_rel.
_uphill_p_rel := dir_or_state_nontemp_rel.
_uphill_p_dir_rel := _uphill_p_rel & dir_rel.
_uphill_p_state_rel := _uphill_p_rel & state_loc_rel.
_up+front_p_rel := miscprep_rel.
_up+to_p_rel := miscprep_rel.
_up+to+and+including_p_rel := miscprep_rel.
_up+until_p_rel := miscprep_rel.
_upon_p_rel := state_loc_rel.
_upstairs_p_rel := dir_or_state_nontemp_rel.
_upstairs_p_dir_rel := _upstairs_p_rel & dir_rel.
_upstairs_p_state_rel := _upstairs_p_rel & state_loc_rel.
_upstate_p_rel := dir_or_state_nontemp_rel.
_upstate_p_dir_rel := _upstate_p_rel & dir_rel.
_upstate_p_state_rel := _upstate_p_rel & state_loc_rel.
_upstream_p_rel := dir_or_state_nontemp_rel.
_upstream_p_dir_rel := _upstream_p_rel & dir_rel.
_upstream_p_state_rel := _upstream_p_rel & state_loc_rel.
_upstream+of_p_rel := dir_or_state_nontemp_rel.
_upstream+of_p_dir_rel := _upstream+of_p_rel & dir_rel.
_upstream+of_p_state_rel := _upstream+of_p_rel & state_loc_rel.
_versus_p_rel := miscprep_rel.
_via_p_rel := miscprep_rel.
_vis-a-vis_p_rel := miscprep_rel.
_viz_p_rel := miscprep_rel.
_whatever_p_rel := miscprep_rel.
_whatsoever_p_rel := miscprep_rel.
_what+with_p_rel := miscprep_rel.
_whether_p_rel := miscprep_rel.
_whither_p_rel := dir_or_state_nontemp_rel.
_whither_p_dir_rel := _whither_p_rel & dir_rel.
_whither_p_state_rel := _whither_p_rel & state_loc_rel.
_whence_p_rel := dir_or_state_nontemp_rel.
_whence_p_dir_rel := _whence_p_rel & dir_rel.
_whence_p_state_rel := _whence_p_rel & state_loc_rel.
_while_x_rel := miscprep_rel.
_whilst_x_rel := miscprep_rel.
_with_p_rel := to_or_with_p_rel & state_loc_rel.
_with+regard+to_p_rel := miscprep_rel.
_within_p_rel := dir_or_state_nontemp_rel.
_within_p_dir_rel := _within_p_rel & dir_rel.
_within_p_state_rel := _within_p_rel & state_loc_rel.
_without_p_rel := miscprep_rel.
_with+respect+to_p_rel := miscprep_rel.
_worth_p_rel := miscprep_rel.

_anymore_a_1_rel := neg_polar_rel.
_as+of+yet_a_1_rel := neg_polar_rel.
_at+all_a_1_rel := neg_polar_rel.
_ever_a_1_rel := neg_polar_rel.
_nomore_a_1_rel := neg_polar_rel.
_or+what_a_1_rel := neg_polar_rel.

_please_x_rel := adv_rel.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Determiner preds

_a+little_q_rel := explicit_noagr_nodef_q_rel.
_a+bit_q_rel := explicit_noagr_nodef_q_rel.
a_or_no_q_rel := def_udef_some_a_no_q_rel.
_a_q_rel := some_q_rel & udef_a_q_rel & indef_or_num_q_rel & a_or_no_q_rel &
	    explicit_noagr_nodef_q_rel & a_or_freerel_q_rel.
_such+a_q_rel := some_q_rel.
_what+a_q_rel := some_q_rel.
_many+a_q_rel := some_q_rel.
_another_q_rel := some_q_rel.
_an+additional_q_rel := some_q_rel.
_a+further_q_rel := some_q_rel.
_any_q_rel := any_q_rel.
both_all_udef_q_rel := nodef_q_rel.
both_all_q_rel := both_all_udef_q_rel & universal_q_rel.
_both_q_rel := basic_def_explicit_q_rel & both_all_q_rel.
_each_q_rel := explicit_noagr_nodef_q_rel & universal_q_rel.
_either_q_rel := explicit_quant_agr_q_rel & universal_q_rel.
_enough_q_rel := explicit_quant_agr_q_rel.
_every_q_rel := every_q_rel.
_each+and+every_q_rel := every_q_rel.
; Temporary hack for "Kim sings twice a week"
_twice+a_q_rel := every_q_rel.
_half_q_rel := explicit_quant_agr_q_rel.
_less_q_rel := explicit_noagr_nodef_q_rel.
_little+or+no_q_rel := explicit_noagr_nodef_q_rel.
_more_q_than_rel := explicit_quant_agr_q_rel.
_most_q_rel := explicit_quant_agr_q_rel.
_most+every_q_rel := every_q_rel.
_neither_q_rel := explicit_noagr_nodef_q_rel.
_no_q_rel := no_q_rel.
_some_q_rel := some_q_rel & indef_or_num_q_rel.
_some_q_indiv_rel := some_q_rel.
_such_q_rel := explicit_q_rel & non_pronoun_q_rel.
_that_q_dem_rel := demon_far_q_rel.
_the+most_q_rel := explicit_quant_agr_q_rel.
_the+least_q_rel := explicit_quant_agr_q_rel.
_these_q_dem_rel := demon_near_q_rel.
_this_q_dem_rel := demon_near_q_rel.
_those_q_dem_rel := demon_far_q_rel.
_thrice_q_rel := def_explicit_q_rel.
_times4_q_rel := explicit_quant_agr_q_rel.
_times5_q_rel := explicit_quant_agr_q_rel.
_twice_q_rel := def_explicit_q_rel.
_umpteen_q_rel := explicit_noagr_nodef_q_rel.
_which_q_rel := which_q_rel.
_any+more_q_rel := explicit_quant_agr_q_rel.
_no+more_q_rel := explicit_quant_agr_q_rel.
_some+more_q_rel := explicit_quant_agr_q_rel.
_less+than+a_q_rel := some_q_rel.
_part_q_rel := explicit_noagr_nodef_q_rel.
_a+third_q_rel := explicit_quant_agr_q_rel.
_a+fourth_q_rel := explicit_quant_agr_q_rel.
_certain_q_rel := explicit_quant_agr_q_rel.
_a+total_q_rel := explicit_quant_agr_q_rel.
_an+average_q_rel := explicit_quant_agr_q_rel.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; sentence-force preds

iforce := predsort.
basic-comm := iforce.
prop-or-ques := iforce.
prop-or-pol-ques-or-comm := iforce.
prop-or-comm := prop-or-pol-ques-or-comm.
prop-or-pol-ques := prop-or-ques & prop-or-pol-ques-or-comm.
prop-or-like := prop-or-comm.
basic-prop := prop-or-pol-ques & prop-or-like.
punct-prop-comm := iforce.
prop-comm := prop-or-comm & punct-prop-comm.
prop-like := prop-or-like & prop-comm.
prop := basic-prop & prop-like.
comm := basic-comm & prop-comm.

ques := prop-or-ques.
basic-wh-ques := ques.
basic-pol-ques := ques & prop-or-pol-ques.

punct-ques := ques.
pol-ques := basic-pol-ques & punct-ques.
wh-ques := basic-wh-ques & punct-ques.

; Subtype to distinguish complementizer "like" from "that", to block
; '*Kim believes like Sandy left' and '*it looks that Sandy left"
like-iforce := prop-like.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; pred sorts

predsort := *sort*.

non_number_rel := predsort.
norm_non_num_rel := non_number_rel.
quantity_or_norm_or_no_rel := predsort.
quantity_or_norm_rel := quantity_or_norm_or_no_rel.
norm_or_no_rel := quantity_or_norm_or_no_rel.
norm_rel := norm_non_num_rel & norm_or_no_rel & quantity_or_norm_rel.
event_or_degree_or_no_rel := predsort.
non_conj_rel := predsort.
norm_non_conj_rel := non_conj_rel & norm_rel.
event_or_degree_rel := norm_non_conj_rel & event_or_degree_or_no_rel.
nonpro_or_event_rel := predsort.
event_rel := event_or_degree_rel & nonpro_or_event_rel.
; Needed to divide two types of head-specifier phrases
compos_spec_rel := predsort.

; Subtypes of this relation are the types for particle semantics in
; verb-particle constructions like _together_rel in "get together"
; DPF 15-Apr-01 - Removed ASPECT no_aspect, since want to let "of" be progr*
; to block e.g. "as of NP"
;; DPF 2012-12-21 - Change selected_adj_rel to block unif with e.g. unknown 
;; adjs, as in e.g. wsj18a:21802013 - take(apart)/longer
;;
selected_rel := event_rel.
selected_adj_rel := selected_rel & prep_rel.
selected_adv_rel := selected_rel & basic_adv_rel.
selected_prep_rel := selected_rel & prep_rel.

independent_rel := predsort.
non_ellipt_rel := predsort.
non_event_rel := norm_non_conj_rel & non_ellipt_rel.
aux_or_ellipt_rel := event_rel.
aux_event_rel := aux_or_ellipt_rel & non_ellipt_rel & nonpass_or_aux_rel.
;; DPF 2016-07-03 - For targets of post-VP scopal modifiers, to avoid spurious
;; analysis for |Kim was drunk| while allowing |Kim could drunk|.
noncop_event_rel := event_rel.
aux_arg1_rel := aux_event_rel & v_event_rel & noncop_event_rel.
nonaux_event_rel := non_ellipt_rel.
norm_non_ellipt_rel := non_ellipt_rel & norm_rel.

;; DPF 2019-09-15 - FIX: this is currently not effective, because 
;; basic_free_relative_q_rel inherits from explicit_noagr_nodef_q_rel, which
;; inherits (eventually) from non_freerel_rel.
;; DPF 2020-08-11 - Re 2019-09-15: Fixed by slight reorg of type hierarchy
;; for free relative quantifiers.
;
non_freerel_rel := independent_rel.
no_rel := non_freerel_rel & non_conj_rel & event_or_degree_or_no_rel &
          nonaux_event_rel & quantity_or_no_rel & norm_or_no_rel &
	  non_pronoun_q_or_no_rel.

; Hack to prevent 'this/that' from being modified by non-wh rel clauses
; which it would do if this were instead a subtype of norm_rel.
;; DPF 2017-02-23 - Added parent quantity_rel so we can get these as right
;; dtrs in appositives, as in |the suggestion, that of the advisor|.  But
;; this would mean we can no longer use NORM contrast in appositive rule
;; (appos_np_phr) to block |Kim that|, so go back to parent norm_non_num_rel
;; here, and live with |Kim that| for now.
;; DPF 2020-08-26 - Added parent quantity_or_norm_rel so we can get NP fragments
;; such as "that which impresses her"
;; DPF 2022-06-10 - Re 2020-08-26: But this allows spurious appositive 
;; "that Kim", so change to quantity_or_norm_or_no_rel, which still satisfies
;; NP fragment rule but not appos.
;;
;deictic_sg_rel := norm_non_num_rel & quantity_or_norm_rel.
deictic_sg_rel := norm_non_num_rel & quantity_or_norm_or_no_rel.

never_unify_rel := predsort.

; For appositives
appos-able_rel := predsort.
indef_or_udef_or_meas_rel := appos-able_rel.
indef_or_udef_or_freerel_rel := appos-able_rel.
indef_or_udef_rel := indef_or_udef_or_meas_rel & indef_or_udef_or_freerel_rel.
;; DPF 2022-06-16 - Changed parent from predsort to impl_or_expl_or_prop_q_rel
;; since this type constrains the hd-dtr in appos_phr_prop_nopair, which needs 
;; to be compatible with the more generic constraint.
;def_or_meas_or_num_rel := impl_or_expl_or_prop_q_rel.
indef_or_def_or_meas_or_num_rel := impl_or_expl_or_prop_q_rel.
;indef_or_def_or_meas_rel := predsort.
def_or_meas_rel := predsort.
udef_or_def_or_meas_rel := def_or_meas_rel.
def_or_meas_noproper_rel := udef_or_def_or_meas_rel & 
			    indef_or_def_or_meas_or_num_rel.

; For specifiers of `ago'
;; DPF 2012-12-21 - Made inndef_or_num_q_rel also a subtype of 
;; indef_or_def_or_meas_rel to admit |some guy, Kim Browne, arose|.  
;; Corresponding change to a_q_rel.
;; DPF 2015-12-17 - Added indef_or_udef_rel so we can get appositives such as
;; |Kim and Browne, two consultants, ...
;;
indef_or_num_q_rel := indef_or_def_or_meas_or_num_rel & indef_or_udef_rel.

norm_dim_rel := norm_non_conj_rel.
basic_event_dim_rel := norm_dim_rel & event_rel.
non_event_dim_rel := non_event_rel & norm_dim_rel.
quant_or_deg_rel := non_event_dim_rel.
i_or_e_quant_or_deg_rel := quant_or_deg_rel.
abstract_q_rel := quant_or_deg_rel.
quant_rel := abstract_q_rel.
;; Exclude "no", as in |*nearly no cats|
exist_or_univ_q_rel := quant_rel.
universal_q_rel := exist_or_univ_q_rel.
non_freerel_q_or_meas_rel := non_freerel_rel.
non_freerel_q_rel := non_freerel_q_or_meas_rel & quant_rel.
non_pronoun_q_or_no_rel := predsort.
non_pronoun_q_rel := quant_rel & non_pronoun_q_or_no_rel.
nodef_q_rel := non_pronoun_q_rel.
; Used to exclude proper-NP subj in clause with post-VP relative clause modifier
impl_or_expl_or_pron_q_rel := quant_rel.
impl_or_expl_or_prop_q_rel := abstract_q_rel.

;; DPF 2020-08-11 - Removed non_freerel_q_rel as parent, since
;; basic_free_relative_q_rel is a subtype.  Instead, push down to other subtypes
;impl_or_expl_q_rel := non_freerel_q_rel & i_or_e_quant_or_deg_rel &
;		      impl_or_expl_or_pron_q_rel & impl_or_expl_or_prop_q_rel.
; Used in bare plurals
impl_or_expl_q_rel := i_or_e_quant_or_deg_rel & impl_or_expl_or_pron_q_rel & 
		      impl_or_expl_or_prop_q_rel.

impl_or_proper_q_rel := nodef_q_rel & impl_or_expl_or_prop_q_rel.
; Used for superlative adjs
impl_or_the_q_rel := quant_rel.
; Used in appositive rule
implicit_q_rel := impl_or_proper_q_rel & def_or_udef_q_rel & 
		  impl_or_the_q_rel & indef_or_num_q_rel.

; Used for heads of appositive phrases
explicit_or_proper_q_rel := impl_or_expl_or_prop_q_rel.
explicit_q_rel := impl_or_expl_q_rel & explicit_or_proper_q_rel &
		  non_freerel_q_rel.
; Determiners with these relations show agreement with of_PP in partitives
explicit_quant_agr_q_rel := explicit_nodef_q_rel.
; These don't
explicit_quant_or_udef_noagr_q_rel := impl_or_expl_q_rel & non_freerel_q_rel.
explicit_quant_noagr_q_rel := explicit_q_rel & 
                              explicit_quant_or_udef_noagr_q_rel.
explicit_noagr_nodef_q_rel := explicit_quant_noagr_q_rel & nodef_q_rel.
explicit_nodef_q_rel := explicit_q_rel & nodef_q_rel.

;; 2012-09-12 - For targets of degree specifiers like |over|, as in
;; |over fifty cars| and |over ten feet tall|.  Distinct from num_or_meas_rel,
;; which is a subtype of nom_rel, and a supertype of the one for named numbers
;; (not for cardinals converted to determiners).
meas_or_numq_rel := predsort.

;; For '(exactly) three chairs'
;; Note that this type is introduced only by the num_det rule, and it is
;; intentionally distinct from number_q_rel used elsewhere
;; DPF 2022-05-17 - Add parent existential_q_rel so we get "one last cat"
;; where superlative "last" demands an existential quantifier for its noun.
;; CHECK for side effects.
;; DPF 2022-06-16 - Added parent indef_or_def_or_meas_or_num_rel so we can get 
;; appos "two cats Fluffy and Rex".  Note that number_q_rel, used for named 
;; numbers, is also a subtype of def_or_meas_or_num_rel, rightly or wrongly.  
;; CHECK.
;;
num_or_demon_q_rel := explicit_nodef_q_rel.
num_q_rel := num_or_demon_q_rel & indef_or_num_q_rel & existential_q_rel &
	     both_all_udef_q_rel & meas_or_numq_rel.

; DPF 19-Oct-02 - This is to allow not only ordinary bare plurals, but also
; "afternoons" which must be the one that takes an optional PP-of and
; usually requires a definite determiner (unless it's a bare plural)

def_udef_some_a_no_q_rel := quant_rel.

; Used for underspecification in translation
;def_udef_some_a_q_rel := def_udef_some_a_no_q_rel.
existential_q_rel := def_udef_some_a_no_q_rel & exist_or_univ_q_rel.
def_udef_a_q_rel := existential_q_rel.
;; DPF 2022-12-30 - Added udef_or_number_q_rel for np_adv-mnp_c.
udef_or_number_q_rel := quant_rel.
udef_a_q_rel := def_udef_a_q_rel & udef_or_number_q_rel.

abstr_def_or_udef_q_rel := non_pronoun_q_rel.
def_or_udef_or_demon_q_rel := existential_q_rel.
def_or_udef_q_rel := abstr_def_or_udef_q_rel & impl_or_expl_q_rel &
		     def_or_udef_or_demon_q_rel & non_freerel_q_rel.
def_or_proper_q_rel := abstr_def_or_udef_q_rel & def_or_meas_rel &
		       existential_q_rel.
;; DPF 2020-05-20 - Used to constrain title-compound rule, allowing both
;; |author Jones| and |post-1989 Berlin|
udef_or_proper_q_rel := existential_q_rel.
udef_q_rel := implicit_q_rel & explicit_quant_or_udef_noagr_q_rel &
              both_all_udef_q_rel & udef_a_q_rel & udef_or_proper_q_rel &
	      def_poss_or_barepl_or_prop_q_rel & udef_or_def_or_meas_rel.
some-any_q_rel := explicit_quant_agr_q_rel & existential_q_rel &
		  indef_or_udef_rel & indef_or_def_or_meas_or_num_rel.
some_q_rel := some-any_q_rel.
any_q_rel := some-any_q_rel.
every_q_rel := explicit_nodef_q_rel & universal_q_rel.
no_q_rel := explicit_nodef_q_rel & indef_or_udef_rel & a_or_no_q_rel.

;; DPF 2012-04-09 - Moved def_or_meas_noproper_rel parent down to 
;; basic_def_explicit_q_rel in order to block |cats Browne| apposition.
;; DPF 2022-06-20 - Replaced retired parent def_or_demon_q_rel with
;; indef_or_def_or_meas_or_num_rel.
;;
def_q_rel := def_or_udef_q_rel & def_udef_a_q_rel &  
	     indef_or_def_or_meas_or_num_rel.

;; DPF 2015-09-17 - Added parent type indef_or_udef_rel, used in one of the
;; rules for appositives, so we can also allow partitives as second dtrs, as
;; in |Kim, one of the players|.
;
def_implicit_q_rel := def_q_rel & implicit_q_rel & both_all_udef_q_rel.
basic_def_explicit_q_rel := def_q_rel & explicit_quant_noagr_q_rel &
                            def_or_proper_q_rel & appos-able_rel &
			    def_or_meas_noproper_rel.
;; Used for vocatives: |my friend| but not |the cat|, and also for bare plurals
;; |People, be quiet!|
def_poss_or_barepl_or_prop_q_rel := quant_rel.
def_explicit_q_rel := basic_def_explicit_q_rel.
def_poss_q_rel := def_explicit_q_rel & def_poss_or_barepl_or_prop_q_rel.
; Used only in MINORS.MIN
nondef_explicit_q_rel := explicit_q_rel & indef_or_udef_rel &
			 nodef_q_rel.
; Used for n_det-mnth_dlr, to allow use of compositional head-spec rule, to allow
; "the January 11 meeting"
; DPF 31-jan-09 - But cannot use compos.head-spec rule for "January 11" since
; this wrongly makes the LBL of "11" the LTOP of the NP, so it would get bound
; both by the restrictor of the quantifier and as the LBL of the verb.
; DPF 27-jun-10 - Re 31-jan-09: but we want "January 11" to be a possible
; non-hd dtr in NP-N compound rule, where it has to be INFLECTD -, so it has
; to be admited with the compos head-spec rule.  Hence we make day-of-month
; lex-entry leave its LTOP unbound, and prevent it from being modified, so
; the only thing it combines with is its specifier, the month det.
;; DPF 2019-10-11 - Only used for definite dates such as "February the", and
;; for better paraphrase equivalence, better to use _the_q_rel instead.
;; DPF 2020-03-28 - But using _the_q_rel blocks |the September 11 event|,
;; where the NP-N compound constraints the NP's ALTMIN.  So restore.
;;
defdate_q_rel := impl_or_proper_q_rel & basic_def_explicit_q_rel.

; Used by NP-N-cmpnd rule:
meas_np_or_proper_q_rel := explicit_or_proper_q_rel & nodef_q_rel.
; Used for lexical NPs including proper names
; It is distinct from i_or_e_quant_or_deg_rel to prevent relative clauses
; from attaching to proper names with no specifier.
meas_or_num_or_proper_q_rel := def_or_meas_rel.
num_or_proper_q_rel := non_freerel_q_rel & def_or_proper_q_rel & nodef_q_rel &
                       explicit_or_proper_q_rel & appos-able_rel &
		       meas_or_num_or_proper_q_rel.
proper_q_rel := num_or_proper_q_rel & impl_or_proper_q_rel &
		def_poss_or_barepl_or_prop_q_rel & udef_or_proper_q_rel.
;number_q_rel := num_or_proper_q_rel & impl_or_proper_q_rel &
;		indef_or_def_or_meas_or_num_rel.
;; DPF 2022-06-16 - Removed parent indef_or_def_or_meas_or_num_rel, to avoid
;; spurious appos for "two [cats Kim and Browne]"
number_q_rel := num_or_proper_q_rel & impl_or_proper_q_rel & 
		udef_or_number_q_rel.

; For determiners that can appear e.g. with 'same' (also excluding 'both')
;; DPF 2022-06-20 - Retired this type, since now use more general one for "same"
;; We don't want pronoun_q_rel as a subtype of indef_or_def_or_meas_or_num_rel.
;; to avoid apposition "who Browne".
;;def_or_demon_q_rel := def_or_udef_or_demon_q_rel & 
;;		      indef_or_def_or_meas_or_num_rel.
pronoun_q_rel := non_freerel_q_rel & impl_or_expl_or_pron_q_rel.

;; DPF 2017-10-08 - Too much ambiguity results in apposition from including 
;; def_or_meas_noproper_rel as parent type, since we get |cats that arise| with 
;; an appos NP |cats that|, and even |cats, that arise|.  We do want to accept
;; |one door, that for pets, stayed open|, but we'll need a separate rule that
;; requires a comma-marked phrase.
;; DPF 2022-05-25 - Added basic_def_explicit_q_rel (replacing 
;; def_or_proper_q_rel & def_or_demon_q_rel & appos-able_rel) so we can get 
;; "that last cookie", matching requirement of superlative adj.
;;
demonstrative_q_rel := num_or_demon_q_rel & basic_def_explicit_q_rel.
demon_near_q_rel := demonstrative_q_rel.
demon_far_q_rel := demonstrative_q_rel.
;basic_free_relative_q_rel := explicit_noagr_nodef_q_rel & existential_q_rel.
basic_free_relative_q_rel := impl_or_expl_q_rel & nodef_q_rel & 
			     indef_or_udef_or_freerel_rel &
			     existential_q_rel.
free_relative_q_rel := basic_free_relative_q_rel.
;; DPF 2017-12-23 - Added supertype to allow either indefinite NPs or free
;; relatives sentence-initially: |whatever he said, we should disappear|
;a_or_freerel_q_rel := explicit_noagr_nodef_q_rel.
a_or_freerel_q_rel := impl_or_expl_q_rel.
free_relative_ever_q_rel := basic_free_relative_q_rel & a_or_freerel_q_rel.
mofy_or_the_q_rel := norm_rel.
;; DPF 2015-06-11 - Change parent type from basic_def_explicit_q_rel to
;; def_explicit_q_rel so we can generate from the result of deleting poss_rel
;; when paraphrasing (e.g. from |his cats| => |the cats|.
_the_q_rel := def_explicit_q_rel & impl_or_the_q_rel &
	      dofw_or_poss_or_def_q_rel & mofy_or_the_q_rel.

which_q_rel := explicit_quant_agr_q_rel.
_all_q_rel := explicit_quant_agr_q_rel & both_all_q_rel.
_not+all_q_rel := explicit_quant_agr_q_rel & both_all_q_rel.
idiom_q_i_rel := implicit_q_rel.
_x_q_rel := basic_def_explicit_q_rel.

dir_state_modable_rel := predsort.
modable_rel := basic_nom_rel & dir_state_modable_rel.
; nontemp_rel used to distinguish temporal nominal phrases from all others
nontemp_or_conj_rel := norm_rel.
nontemp_rel := nontemp_or_conj_rel.
instance_rel := independent_rel.
basic_nom_or_mnp_rel := compos_spec_rel.
basic_nom_rel := non_event_rel & instance_rel & basic_nom_or_mnp_rel.
nom_or_mnp_rel := basic_nom_or_mnp_rel.
nom_rel := basic_nom_rel & nom_or_mnp_rel.
nonpro_or_refl_or_num_rel := predsort.
nonpro_or_num_rel := nonpro_or_refl_or_num_rel.
basic_nonpro_rel := nom_rel & nonpro_or_num_rel.
; Exclude relative pronouns and deictics, which can not take possessive 's.
nonpro_rel := basic_nonpro_rel & nonpro_or_event_rel.
comp_or_meas_rel := nom_nondim_rel.
abstr_meas_nom_rel := comp_or_meas_rel & num_or_meas_rel .
nonpart_nom_rel := nom_rel.
nom_nondim_rel := nom_rel.
time_or_non_temp_rel := nom_nondim_rel.
non_temp_nom_rel := time_or_non_temp_rel & nontemp_rel.
basic_basic_non_temp_nonpro_rel := non_temp_nom_rel & basic_nonpro_rel.
basic_non_temp_nonpro_rel := basic_basic_non_temp_nonpro_rel & nonpart_nom_rel.
non_temp_nonpro_rel := basic_non_temp_nonpro_rel & nonpro_rel.
reg_nom_rel := non_temp_nonpro_rel & reg_or_temp_nom_rel.
modable_nom_rel := non_temp_nonpro_rel & modable_rel.
unspec_diadic_nom_rel := nonpro_rel & nom_nbar_rel.
reg_diadic_nom_rel := unspec_diadic_nom_rel & reg_nom_rel.
basic_diadic_modable_nom_rel := unspec_diadic_nom_rel & modable_rel.
diadic_modable_nom_rel := basic_diadic_modable_nom_rel & modable_nom_rel.
basic_hcomp_nom_rel := non_temp_nonpro_rel & gen_nom_nbar_rel.
hcomp_nom_rel := basic_hcomp_nom_rel & reg_nom_rel.
hcomp_modable_nom_rel := basic_hcomp_nom_rel & modable_rel.
nbar_or_nger_rel := nom_rel.
nbar_or_dofm_rel := nom_rel.
;;;;;reg_or_temp_nom_or_gerund_rel.
nominalize_rel := basic_hcomp_nom_rel & nbar_or_nger_rel.
gerund_rel := non_temp_nonpro_rel.
; For SEM-I
nominalization_rel := nom_rel.
; Ordinary nbars or numerals
nbar_or_num_rel := nom_rel.
;; Non-proper nominals, including pronouns
non_proper_rel := nom_rel.
; nom_rels for nouns that can undergo nbar-coordination (avoiding proper names)
gen_nom_nbar_rel := nbar_or_num_rel & non_proper_rel.
; nom_rels for nouns that can appear in noun_noun compounds (excluding e.g. 
; number-nouns)
nom_nbar_rel := gen_nom_nbar_rel & nbar_or_nger_rel & nbar_or_dofm_rel.
norm_nom_or_place_rel := nom_rel.
;; Used for robust-sg-NP rule - exclude named days: |Friday|
non_temp_or_nonday_nbar_rel := nom_rel.
non_temp_nbar_rel := non_temp_nonpro_rel & nom_nbar_rel & 
		     non_temp_or_nonday_nbar_rel.
;; For "in due time" but not "*in due Kim"
norm_nom_or_time_rel := nom_rel.
norm_nom_rel := reg_nom_rel & non_temp_nbar_rel & norm_nom_or_place_rel &
		norm_nom_or_time_rel.
reg_or_temp_nom_rel := nonpart_nom_rel.
temp_abstr_or_conj_rel := predsort.
temp_abstr_rel := nonpro_rel & temp_abstr_or_conj_rel & norm_nom_or_time_rel.
temp_nondim_rel := temp_abstr_rel & gen_nom_nbar_rel & reg_or_temp_nom_rel.
; Used in NP-N-cmpnd rule, to include measure-NP phrases.
named_or_meas_rel := norm_rel.
;; Allows post-titles like |Inc.| to modify either |Bally| or |Bally's|
named_or_part_nom_rel := predsort.
; Used in munging rules to make reversible the implicit quantifier
abstr_named_rel := named_or_part_nom_rel & norm_rel.
gen_named_rel := abstr_named_rel.
named_np_or_num_rel := gen_named_rel & named_or_meas_rel & nonpro_rel.
abstr_named_np_rel := named_np_or_num_rel & numseq_or_named_rel.
norm_named_np_rel := abstr_named_np_rel & reg_nom_rel & norm_nom_or_place_rel.
;; DPF 2022-12-14 - Distinguish named letters from regular names, for itemizing
;; as in "c - stir the mixture"
named_np_rel := norm_named_np_rel.
named_letter_rel := norm_named_np_rel.
		
;; To enable us to avoid fractions as members of number sequences, to avoid
;; spurious analysis of |11 2/3|.
;; DPF 2017-96-27 - Changed parent from nom_rel to non_temp_nom_rel, so we can
;; admit |at 1 3/4| where this `at' wants a non-temporal NP.
;;
named_num_or_fract_rel := non_temp_nom_rel & numseq_or_named_rel.

named_num_or_seq_rel := nom_rel.
num_or_meas_rel := nom_rel & nonpro_or_num_rel.
; DPF 03-may-04 ; Changed non_temp_nonpro_rel to nom_nocmpnd_rel, to prevent
; these from appearing in N-N-compounds
named_num_rel := named_np_or_num_rel & nom_nocmpnd_rel & 
		 named_num_or_seq_rel & norm_nom_or_place_rel & 
		 num_or_meas_rel & named_num_or_fract_rel.

numseq_or_named_rel := predsort.
;; DPF 14-10-13 - Removed nonpro_or_num_rel since now from named_np_or_num_rel
num_seq_nom_rel := named_num_or_seq_rel & non_temp_nom_rel & 
		   named_np_or_num_rel & nonpart_nom_rel  & numseq_or_named_rel.
;named_card_rel := named_num_rel & card_rel.
named_times_rel := named_num_rel & times_rel.
named_plus_rel := named_num_rel & plus_rel.



integer_or_color_rel := compos_spec_rel & independent_mod_rel &
			event_arg_dim_rel & noncop_event_rel.
;; DPF 2015-09-17 - Changed parent adj_rel to norm_adj_rel, in order to get
;; conjunction with attrib adjectives, as in |green and happy cat|
color_rel := integer_or_color_rel & norm_adj_rel.
elliptical_n_rel := diadic_nom_rel.
; Relation used in decomposed lexical semantics, e.g. for 'when'
temp_rel := abstr_named_rel & modable_rel & temp_abstr_rel.
day_rel := temp_nondim_rel & day_or_time_rel & non_month_rel.
diadic_day_rel := day_rel & unspec_diadic_nom_rel & modable_rel.
named_day_rel := diadic_day_rel & abstr_named_np_rel.
; Needs to inherit from both since we get "on the first day" but "in my day".
;; Also inherits from non_temp_or_nonday_nbar_rel, which excludes named days.
;;
unnamed_day_rel := diadic_day_rel & non_day_or_deg_rel & abstr_meas_nom_rel &
		   non_temp_or_nonday_nbar_rel.

; DPF 10-Oct-02 - Need to allow measure-NPs to be complements of temporal "in",
; as in "I'll be finished in two chapters".
non_day_or_deg_rel := norm_rel.
non_day_rel := temp_nondim_rel & non_day_or_deg_rel & abstr_meas_nom_rel.
;; day_of_month_rel
; DPF 03-may-04 - Replaced diadic_day_rel with day_rel,modable_rel to prevent
; these from being nom_nbar_rel, so they won't appear in compounds, among
; other unwanted places
; DPF 04-mar-06 - Added dofm_or_mofy_rel to capture the possible modifiees
; of n_year_le.
;; DPF 2012-09-13 - Added supertype for dofm_or_mofy_rel and hour_or_time_rel,
;; to enable a single lexical entry for temporal "at".
day_or_month_or_time_rel := predsort.
dofm_or_mofy_rel := temp_nondim_rel & day_or_month_or_time_rel.
dofm_or_interval_rel := temp_nondim_rel & named_or_meas_rel.
dofm_rel := day_rel & modable_rel & gen_named_rel & nbar_or_dofm_rel &
            dofm_or_mofy_rel & dofm_or_interval_rel.

;; These subtypes enable us to distinguish the grammaticality of
;; |the tenth to twelfth of October| and |*the ten to twelve of October|
;; alongside |October tenth to twelfth| and |October ten to twelve|.
;;
dofm_card_rel := dofm_rel.
dofm_ord_rel := dofm_rel.

;; Need supertype of dofw_rel and poss_rel and non-'the' quantifiers
;; for the specifier of the small class of words like "morning" as in "my 
;; mornings" or "Tuesday mornings"

dofw_or_poss_or_def_q_rel := norm_rel.

;; Also need supertype that includes measure NPs, since degree specifiers
;; like "over" combine either with numeral determiners or with measure NPs

dofw_or_poss_or_meas_rel := norm_rel.
dofw_or_poss_q_rel := dofw_or_poss_or_def_q_rel & dofw_or_poss_or_meas_rel.
;; day_of_week_rel
dofw_rel := named_day_rel & dofw_or_poss_q_rel.
holiday_rel := named_day_rel & hour_or_time_rel.
;; DPF 2012-12-17 - Added parent abstr_meas_nom-rel to get 
;; |we arrived two nights a week|
;;
day_part_rel := diadic_day_rel & abstr_meas_nom_rel.
;; DPF 2020-10-07 - For "on" of "on Tuesday", "*on January", but also
;; "based on time and effort" and "based on the hours worked"
non_month_rel := norm_rel.
; dim_rel: 'almost three o'clock'
; DPF 2-Apr-02 - Added type for hour_rel and _time_rel, to get both "at three"
; and 'at that time" while distinguishing "kim fell three times" from "*Kim
; fell three o'clock".  Also include seasons, since 'at' uses this sort.
day_or_time_rel := day_or_month_or_time_rel.
hour_or_time_rel := day_or_time_rel & non_month_rel.
;; DPF 2018-03-26 - Removed nom_nbar_rel parent, since we don't want N-N cmpnd
;; (along with NP-N cmpnd) for |twelve o'clock meal|
;;hour_rel := temp_abstr_rel & hour_or_time_rel & nom_nbar_rel.
hour_rel := temp_abstr_rel & hour_or_time_rel.
_breakfast_n_time_rel := hour_rel.
_dinner_n_time_rel := hour_rel.
_lunch_n_time_rel := hour_rel.
_supper_n_time_rel := hour_rel.
_tea_n_time_rel := hour_rel.
_night_n_time_rel := hour_rel.

;; DPF 2013-06-07 - Making this not modable prevents parsing e.g.
;; |They appear every minute/moment|.  So let's put it back, and remind 
;; ourselves of why it was changed to non-modable.
minute_n_rel := hour_rel & non_day_diadic_modable_rel.
_minute_n_1_rel := minute_n_rel.
;_minute_n_1_rel := hour_rel & non_day_diadic_rel.

; a quarter till three  ("till" is head - cf "come at a quarter till.")
hour_prep_rel := hour_rel.
gen_hour_rel := hour_rel.
; prep_rels that can modify hour times as in "ten minutes after five"
minute_prep_rel := miscprep_rel.

basic_numbered_hour_rel := hour_rel & abstr_named_rel & named_or_meas_rel.
numbered_hour_rel := basic_numbered_hour_rel.
numbered_hour_unk_rel := basic_numbered_hour_rel & generic_unk_rel.

; DPF 31-Jul-99 - Changed minute_or_ampm_rel to be non-temp, since it cannot
; appear after temporal prepositions (ignoring the elliptical "I'll see you 
; in ten"), and we also need to block "from ten to eleven o'clock" with
; "ten" as minute.
minute_or_ampm_rel := nom_nondim_rel.

;modable_hour_rel := non_day_diadic_modable_rel.
;modable_hour_or_time_rel := modable_hour_rel & hour_or_time_rel.

am_pm_rel := minute_or_ampm_rel.
bc_ad_rel := nom_nondim_rel & abstr_named_np_rel.

ctime_rel := numbered_hour_rel.

; 'the morning', not 'some morning': 'in the morning' but 'on some morning'
;; DPF 2011-12-13 - But |on the morning of the big party|
def_day_part_rel := non_day_diadic_modable_rel.
_afternoon_n_def_rel := def_day_part_rel.
_evening_n_def_rel := def_day_part_rel.
_morning_n_def_rel := def_day_part_rel.
_night_n_def_rel := def_day_part_rel.
_weekend_n_def_rel := def_day_part_rel.

non_day_diadic_rel := non_day_rel & unspec_diadic_nom_rel.
non_day_modable_rel := non_day_rel & modable_rel & nom_nbar_rel.

non_day_diadic_modable_rel := non_day_diadic_rel & modable_rel.
non_day_time_rel := non_day_diadic_rel & modable_rel & hour_or_time_rel &
		    time_or_non_temp_rel.
; "while"
;non_day_nonmodable_rel := non_day_rel & meas_nom_rel.
;; Only for mass noun `time':
time_nomod_rel := non_day_diadic_rel & hour_or_time_rel.

; mealtimes - disallow relative clause modification
mealtime_rel := hour_or_time_rel.

;; named_month_rel as in "January is fine"
;; DPF 13-Mar-02 - Changed parent non_day_diadic_modable_rel to 
;; non_day_diadic_rel since we were overgenerating: "*Kim arrived June" in 
;; order to admit "Kim arrived last June".  Have to do something else to
;; allow the latter.
;; DPF 04-sep-09 - Changed back, since we want "last June", and can block
;; just "June" as NPadv via MODIFD value

mofy_rel := non_day_diadic_modable_rel & abstr_named_np_rel & 
	    dofm_or_mofy_rel & mofy_or_the_q_rel.

; basic_yofc_rel := non_day_rel & abstr_named_np_rel & named_or_meas_rel.
basic_yofc_rel := non_day_rel & abstr_named_np_rel.
yofc_rel := basic_yofc_rel.
yofc_unk_rel := basic_yofc_rel & generic_unk_rel.

season_rel := non_day_modable_rel & gen_named_rel & non_month_rel.
season_nomod_rel := day_rel & gen_named_rel & hour_or_time_rel.

era_rel := non_day_modable_rel & gen_named_rel & non_month_rel.

;age_rel := non_day_nonmodable_rel.
age_rel := non_day_rel.
; For predicates that are not subtypes of abstr_named_rel (like mofy_rel is)
non_day_diadic_nonprop_rel := non_day_diadic_modable_rel.
year_n_rel := non_day_diadic_nonprop_rel & non_month_rel.

_morning_n_1_rel := day_part_rel.
_afternoon_n_1_rel := day_part_rel.
_evening_n_1_rel := day_part_rel.
_night_n_1_rel := day_part_rel.
_weekend_n_1_rel := day_part_rel.
_noon_n_1_rel := day_part_rel.
	   
_week_n_1_rel := non_day_diadic_nonprop_rel & non_month_rel.
_month_n_1_rel := non_day_diadic_nonprop_rel.
_quarter_n_temp_rel := non_day_diadic_nonprop_rel.
nonday_n_rel := non_day_diadic_nonprop_rel & non_temp_or_nonday_nbar_rel.

duration_rel := temp_rel.

named_rel := named_np_rel.
; For guessed (unknown) proper names
named_unk_rel := named_np_rel & generic_unk_rel.
named_city_rel := named_np_rel.
named_abb_rel := named_np_rel.
named_n_rel := gen_named_rel & reg_nom_rel.
year_range_rel := named_np_rel.

gen_numval_rel := non_temp_nonpro_rel & nom_nbar_rel.

; For classifier nouns like "piece" or "pair"
quantum_n_of_rel := reg_nom_rel.
_pair_n_of-i_rel := quantum_n_of_rel.
_piece_n_of_rel := quantum_n_of_rel.
_bit_n_of_rel := quantum_n_of_rel.

; For X to Y constructions

basic_interval_rel := unspec_diadic_nom_rel & abstr_named_rel.
; named_num_or_seq_rel for |items 1 - 3|
interval_rel := basic_interval_rel & named_num_or_seq_rel.

; For "to" of "May 23 to 25"
;; DPF 2017-12-09 - Added dofm_or_interval_rel to this type, to allow
;; |the May 2 - 3 workshop|
;;
interval_modable_rel := basic_interval_rel & modable_nom_rel &
			dofm_or_interval_rel.

; For determinerless-PP nouns ('within range')
bare_nom_rel := non_temp_nonpro_rel.
; Disallow adjective modifiers ('at eye level' but '*at high level')
bare_n_nmod_rel := bare_nom_rel & nbar_or_nger_rel.
; Disallow noun-noun compounding ('at close range' but '*at cellphone range')
bare_n_jmod_rel := bare_nom_rel & gen_nom_nbar_rel.
; Disallow any modification ('on top' 'of course')
bare_n_nomod_rel := bare_nom_rel.

;; DPF 2022-06-15 - Added supertype n-meas-or-ed_rel for nouns such as "foot"
;; that can be used either as measure noun or in n-ed construction
n-meas-or-ed_rel := nom_rel.
n-ed_rel := non_temp_nbar_rel & reg_or_temp_nom_rel & n-meas-or-ed_rel.

mnp_symb_rel := abstr_meas_nom_rel & nonpro_rel.

; For 'it is a pleasure to visit abrams.' and 'Abrams is a pleasure to visit.'
prednom_rel := nonpro_rel.
pred_a_rel := event_rel & independent_rel.

;; The relation event_or_mod_rel is designed to distinguish non-nominal signs, 
;; including verbs, adjectives, prepositions, and adverbs.  One use of this 
;; distinction is for the conjuncts accepted by "but": "*Kim but Sandy left."

event_or_mod_rel := predsort.

;; 2022-11-05 - Avoid modif of selected_rel PP, constraining hd-dtr in h-adj rule
;; to be --MIN independent_rel.
;mod_rel := event_or_mod_rel.
mod_rel := event_or_mod_rel & independent_rel.

event_mod_rel := event_rel & mod_rel.
event_arg_dim_rel := event_mod_rel & basic_event_dim_rel.
event_dim_rel := basic_event_dim_rel & nonaux_event_rel & noncop_event_rel.
;; 2022-11-05
;independent_mod_rel := independent_rel & mod_rel.
independent_mod_rel := independent_rel.
relative_mod_rel := independent_mod_rel.

abstr_excl_rel := independent_mod_rel.

greet_rel := abstr_excl_rel.
excl_rel := abstr_excl_rel.
polite_rel := excl_rel.

; For distinguishing passive from active VPs, needed for complement of "as"
;
passive_rel := event_dim_rel & role_rel.
;; DPF 2020-04-30 - Used in hd_xaj-int-s_c for |how is it that he disappeared?|
nonpass_or_aux_rel := event_rel.
nonpass_rel := event_dim_rel & role_rel & nonpass_or_aux_rel.

; For adjectival pro-forms like "the last", and derived number-nouns, neither
; of which appear in N-N-compounds
;nom_nocmpnd_rel := non_temp_nom_rel & gen_nom_nbar_rel.
nom_nocmpnd_rel := basic_basic_non_temp_nonpro_rel & gen_nom_nbar_rel.
num_nocmpnd_rel := nom_nocmpnd_rel & nonpro_rel & part_nom_rel.

;; DPF 2017-09-16 - But we do want "one" in compounds, as in |the titanium ones|
;;
;_one_n_1_rel := nom_nocmpnd_rel & nonpro_rel & nonpart_nom_rel.
_one_n_1_rel := non_temp_nbar_rel.

basic_pron_rel := non_temp_nom_rel & abstr_named_rel & non_proper_rel.
nonrefl_or_refl_rel := non_temp_nom_rel.
pron_rel := basic_pron_rel & nonpart_nom_rel & nonrefl_or_refl_rel.
; For partitives
pron_part_rel := basic_pron_rel.
; For WH and REL "who, whom" which can appear as second complement of "give"
; even though ordinary pronouns cannot, but which like other pronouns cannot
; appear as specifier of possessive 's: "*who's".
;; Also for possessive nominal pronousn like "mine".
;;
pron_nonlocal_rel := basic_pron_rel & nonpro_or_refl_or_num_rel & 
		     nonpart_nom_rel.
refl_pron_rel := nonpro_or_refl_or_num_rel & non_proper_rel & 
		 nonrefl_or_refl_rel.

recip_pro_rel := basic_non_temp_nonpro_rel.
generic_nom_rel := basic_non_temp_nonpro_rel & gen_nom_nbar_rel.
generic_entity_rel := non_temp_nonpro_rel.

generic_unk_nom_rel := non_temp_nonpro_rel & generic_unk_rel.

basic_adj_rel := event_dim_rel & nontemp_rel & compos_spec_rel.
;; Needed for coord |two or more cats| and for |first and biggest cat|
adj_or_card_or_much_rel := basic_adj_rel.
abstr_adj_rel := event_arg_dim_rel & adj_or_card_or_much_rel.
adj_rel := abstr_adj_rel & independent_mod_rel.
norm_adj_rel := adj_rel.

expl_adj_rel := basic_adj_rel & independent_rel.
;; 2022-11-05
;it_adj_rel := abstr_adj_rel & independent_rel.
it_adj_rel := abstr_adj_rel.
const_or_meas_rel := predsort.
meas_adj_rel := abstr_adj_rel & const_or_meas_rel.
adj_personal_rel := adj_rel.
adj_abstract_rel := adj_rel.
generic_unk_adj_rel := adj_rel & generic_unk_rel.

verb_or_subord_rel := independent_rel & event_rel.
verb_aspect_rel := verb_or_subord_rel.

prog_rel := verb_aspect_rel.

v_event_rel := verb_aspect_rel & event_arg_dim_rel.

mod_role_rel := v_event_rel.
nonaux_v_rel := mod_role_rel & nonaux_event_rel & noncop_event_rel.

no_role_rel := mod_role_rel. 
it_subj_nonaux_rel := no_role_rel & nonaux_v_rel.
weather_v_rel := it_subj_nonaux_rel.
_do_v_be_rel := nonaux_event_rel & verb_aspect_rel & noncop_event_rel.

role_rel := nontemp_rel & nonaux_v_rel.

; To support underspecification of can/able especially for future tense
; where 'able' is required.
;
can_able_rel := predsort.

;; add must/have+to like can_able
modal_rel := aux_arg1_rel.
_can_v_modal_rel := modal_rel.
_can_v_able_rel := _can_v_modal_rel & can_able_rel.
_could_v_modal_rel := modal_rel.
_dare_v_qmodal_rel := modal_rel.
_may_v_modal_rel := modal_rel.
_might_v_modal_rel := modal_rel.
_must_v_modal_rel := modal_rel.
_need_v_qmodal_rel := modal_rel.
_ought_v_qmodal_rel := modal_rel.
_shall_v_modal_rel := modal_rel.
_should_v_modal_rel := modal_rel.
_used+to_v_qmodal_rel := nonaux_v_rel.
_had+better_v_qmodal_rel := modal_rel.
_had+best_v_qmodal_rel := modal_rel.
_would_v_modal_rel := modal_rel.
ellipsis_rel := v_event_rel & aux_or_ellipt_rel.
ellipsis_ref_rel := ellipsis_rel.
ellipsis_expl_rel := ellipsis_rel.
; Used to ensure tag question agreement, but will not appear in RELS.
have_aux_rel := aux_arg1_rel.
; For infinitival relatives and purposive-to constructions: 'Kim is to stay'
eventuality_rel := v_event_rel.

; Needed to allow filtering of the relations for "will" and "would" for VIT.
will_modal_rel := aux_arg1_rel.
_will_v_aux_rel := will_modal_rel.
_going+to_v_qmodal_rel := will_modal_rel.
would_like_rel := predsort.
; Used in "how about" words:
generic_verb_rel := event_dim_rel.

; PRED for generic entry for unknown verbs.
generic_unk_verb_rel := event_dim_rel & generic_unk_rel.

; Support for can/able undespecification
_able_a_1_rel := adj_rel & can_able_rel.

prep_rel := event_dim_rel.
;; 2022-11-05
;basic_prep_mod_rel := prep_rel & event_arg_dim_rel & independent_rel.
basic_prep_mod_rel := prep_rel & event_arg_dim_rel.
prep_mod_rel := basic_prep_mod_rel.
nontemp_prep_rel := prep_mod_rel & nontemp_rel.
;; DPF 2022-12-29 - Removed this type, since it was only used in the
;; partitive_np_num_phrase, seemingly wrongly, since we don't want
;; "*Kim's of the cat".  The addition of this type also meant that positive
;; adjectives such as "very tall" were wrongly undergoing the partitive rule
;; for comparatives.
; comp_or_poss_rel := abstr_meas_nom_rel.
poss_rel := of_p_rel & dofw_or_poss_q_rel.
loc_abstr_rel := prep_mod_rel.
dir_or_state_rel := loc_abstr_rel & dir_state_modable_rel.
dir_or_state_nontemp_rel := dir_or_state_rel & nontemp_prep_rel.
dir_rel := dir_or_state_nontemp_rel & dir_or_unsp_loc_rel.
misc_or_state_loc_rel := prep_mod_rel & nondir_or_adv_rel.
state_loc_rel := dir_or_state_nontemp_rel & misc_or_state_loc_rel.
generic_loc_rel := loc_abstr_rel.

temp_loc_rel := independent_mod_rel & state_loc_rel.

miscprep_rel := nontemp_prep_rel & misc_or_state_loc_rel.

;; For PP complements of diadic from_to prep
abstr_until_rel := predsort.

part_nom_rel := named_or_part_nom_rel.
;part_of_rel := reg_diadic_nom_rel & part_nom_rel.
part_of_rel := non_temp_nom_rel & unspec_diadic_nom_rel & part_nom_rel & 
	       non_temp_or_nonday_nbar_rel.
;part_nc_rel := reg_nom_rel & nom_nbar_rel & part_nom_rel.
part_nc_rel := non_temp_nom_rel & nom_nbar_rel & part_nom_rel & nonpro_rel &
	       non_temp_or_nonday_nbar_rel.

diadic_nom_rel := reg_diadic_nom_rel & norm_nom_rel.

loc_rel := dir_or_state_rel.

dir_or_unsp_loc_rel := prep_mod_rel.
unspec_loc_or_mod_rel := prep_rel.

; Either specific 'in, on, at' or loc_nonsp_rel, whether temporal nor not
; Note this type is the supertype for loc_sp_rel and loc_nonsp_rel, so
; beware of potential for name confusion
;
;; DPF 2022-01-26 - Moved parent dir_or_unsp_loc_rel down to just the subtype
;; nontemp_loc_nonsp_rel, so we can coerce predicates such as _on_p_loc_rel to
;; _on_p_dir_rel when unified with dir_or_unsp_loc_rel, as for "We ran on the
;; table."
;; 
;unspec_loc_rel := loc_rel & dir_or_unsp_loc_rel & independent_mod_rel & 
;		  unspec_loc_or_mod_rel & compound_or_prep_rel.
unspec_loc_rel := loc_rel & independent_mod_rel & 
		  unspec_loc_or_mod_rel & compound_or_prep_rel.


temp_sp_or_nonsp_rel := temp_loc_rel.

; Used for implicit locative, as in "Kim arrived Tuesday" or "Kim is here"
; DPF 20-apr-10 - The parent type `dir_or_state_nontemp_rel' is needed to
; avoid unwanted GLBs, but at least the name is confusing, since we have
; temp_loc_nonsp_rel as a subtype of this.  Now fixed.
;;loc_nonsp_rel := unspec_loc_rel & dir_or_state_nontemp_rel.
loc_nonsp_rel := unspec_loc_rel & state_loc_rel.
;; DPF 2022-01-26
;nontemp_loc_nonsp_rel := loc_nonsp_rel & nontemp_sp_or_nonsp_rel.
nontemp_loc_nonsp_rel := loc_nonsp_rel & nontemp_sp_or_nonsp_rel &
  dir_or_unsp_loc_rel.
temp_loc_nonsp_rel := loc_nonsp_rel & temp_sp_or_nonsp_rel.


; For specific locatives whether temporal or not
loc_sp_rel := unspec_loc_rel.

; For specific temporal locatives 'in, on, at'
temp_loc_sp_rel := temp_sp_or_nonsp_rel & loc_sp_rel.
; Decomposed rel for e.g. free relative "when"
temp_loc_x_rel := temp_loc_rel.

; Specific nontemporal locatives 'in, on, at', potentially useful for
; underspecified generator input.
nontemp_sp_or_nonsp_rel := loc_rel & nontemp_prep_rel.
nontemp_loc_sp_rel := dir_or_state_nontemp_rel & nontemp_sp_or_nonsp_rel & 
		      loc_sp_rel.

interval_p_start_rel := miscprep_rel.
;; DPF 2020-03-25 - Added supertype for integer or interval, so we can get
;; |1-2 million|
card_or_interval_rel := independent_rel.
interval_p_end_rel := miscprep_rel & compos_spec_rel & card_or_interval_rel.
; For |5-10 ft. tall|
interval_meas_rel := interval_p_end_rel & const_or_meas_rel.

; For time zones like "PDT"
timezone_p_rel := temp_loc_rel.

; for 'talk to/with X (about Y)', 'speak' etc
to_or_with_p_rel := dir_or_state_nontemp_rel.

; For "how"
unspec_manner_rel := miscprep_rel.

; For VP modifiers that can be extracted (excluding directional PPs)
nondir_or_adv_rel := predsort.

basic_adv_rel := non_event_rel & nontemp_rel & event_or_degree_rel &
		 nonpro_or_event_rel & nondir_or_adv_rel.
abstr_adv_rel := basic_adv_rel & independent_mod_rel.

abstr_adv_dim_rel := abstr_adv_rel & non_event_dim_rel.

adv_rel := abstr_adv_dim_rel.

neg_rel := abstr_adv_rel.
generic_unk_adv_rel := abstr_adv_rel & generic_unk_rel.

neg_polar_rel := abstr_adv_dim_rel.
long_r_rel := abstr_adv_dim_rel.
long_a_rel := adj_rel.

degree_rel := compos_spec_rel & independent_rel & event_or_degree_rel
             & i_or_e_quant_or_deg_rel & non_day_or_deg_rel.
comp_degree_rel := degree_rel.
non_comp_degree_rel := degree_rel.

; For the subset of specifiers needed for adjectives (but not, e.g., subconj)
; DPF 07-may-04 - Added non_temp_nom_rel to allow MNPs as complements of
; e.g. 'under' which wants non-temporal NP.  Also blocks spurious parse for
; "kim sings in ten minutes"
; DPF 14-nov-05 - But this means degree_rels unify with nom_rels - undesirable.
; So try alternate approach to e.g. 'Kim hid under five feet of snow'

much_or_more_or_very_deg_rel := degree_rel.
much_or_very_deg_rel := much_or_more_or_very_deg_rel & nonpro_or_num_rel.
more_or_very_deg_rel := much_or_more_or_very_deg_rel.
more_this_deg_rel := degree_rel.
much_or_more_deg_rel := more_this_deg_rel.

; For specifiers of adjectives
deg_rel := non_comp_degree_rel.

very_this_that_rel := deg_rel & much_or_very_deg_rel & more_or_very_deg_rel.
; For specifiers of positive adjectives
very_deg_rel := very_this_that_rel & ord_or_very_rel.

; For degree specifiers "this/that/too/as" as in "that much", "so tall"
this_that_deg_rel := very_this_that_rel & more_this_deg_rel.

; For 'more" with positive adjectives and with adverbs
more_deg_rel := more_or_very_deg_rel & just_only_notvery_deg_rel &
		much_or_more_deg_rel & comp_as_too_enough_rel.

; For as..as, too..to
comp_as_too_enough_rel := comp_more_less_rel.
comp_as_too_degree_rel := this_that_deg_rel & comp_as_too_enough_rel.
comp_more_degree_rel := much_deg_rel & comp_more_less_rel.
enough_deg_rel := comp_as_too_enough_rel.

; For specifiers of superlatives: "very tallest", "next tallest"
sup_deg_rel := very_deg_rel.

; For specifiers of "the", including "only" and "just"
just_only_degree_rel := degree_rel.
; 'exactly in the center'
just_only_very_deg_rel := just_only_degree_rel & very_deg_rel.
just_only_notvery_deg_rel := just_only_degree_rel.
; 'far into the park'
just_only_much_deg_rel := just_only_notvery_deg_rel & much_deg_rel.
just_only_deg_rel := just_only_notvery_deg_rel & deg_rel.

; For "how" degree specifier
abstr_deg_rel := this_that_deg_rel.

; For specifiers of comparative adjectives
much_deg_rel := deg_rel & much_or_very_deg_rel & card_or_much_rel &
		much_or_more_deg_rel.
; To constrain adjectives to only take "much", as with modifiee of "than Sandy"
much_deg_only_rel := much_deg_rel.

; For specifiers of superlatives: "very tallest" "second tallest"
ord_or_very_rel := degree_rel.

; For specifiers of comparatives: "twenty more"
card_or_much_rel := degree_rel & adj_or_card_or_much_rel.

; For conjoined spr-less adjectives as in "sunny and cooler"
; DPF 5-Sep-03 - But this eliminates the blocking of inappropriate degree specs
; for head that want only one or the other.
;;very_and_much_deg_rel := very_deg_rel & much_deg_rel.

; For e.g. 'eightish'
approx_grad_rel := deg_rel.

; For syntactic rules (for indexing for generation)
gen_deg_rel := deg_rel.
comparative_rel := comp_degree_rel.
comp_more_less_rel := comparative_rel.
;;_more_x_comp_rel := comp_more_less_rel.
;;_less_x_comp_rel := comp_more_less_rel.
;;comp_most_least_rel := comparative_rel.
;;_most_x_comp_rel := comp_most_least_rel.
;;_least_x_comp_rel := comp_most_least_rel.

; For measure-NPs and other degree specifiers: 'how tall'
measure_rel := non_comp_degree_rel.

;; For "how" adjective, which quantifies over properties.
property_rel := reg_nom_rel.
prpstn_to_prop_rel := event_rel.
comp_or_superl_rel := miscprep_rel.
comp_equal_rel := miscprep_rel.
comp_deg_rel := miscprep_rel.
superl_rel := comp_or_superl_rel.
;comp_rel := comp_or_superl_rel & abstr_meas_nom_rel.
;comp_rel := comp_or_superl_rel & comp_or_poss_rel.
comp_rel := comp_or_superl_rel & comp_or_meas_rel.
comp_er_rel := comp_rel.
more_comp_rel := comp_rel.
_more_x_comp_rel := more_comp_rel.
_less_x_comp_rel := miscprep_rel.
_so_x_comp_rel := miscprep_rel.
_too_x_comp_rel := comp_deg_rel.
_enough_x_comp_rel := comp_deg_rel.
_all+too_x_comp_rel := comp_deg_rel.

; Abstract prep relations
; Needed for idiosyncratic decomposition of "why"
cause := miscprep_rel.
; For identity, as with pronoun in tag questions.
id_rel := predsort.
; For tag questions: notionally, "isn't it the case that ..."
ne_x_rel := predsort.

; Added event_or_degree_or_no_rel to enable coordination of these guys
subord_rel := verb_or_subord_rel & non_ellipt_rel.
;; DPF 2016-09-14 - Added noncop_event_rel as parent, to allow
;; |Chiang is a cat, admiring Browne.|
;; DPF 2022-04-22 - Added aux_event_rel as parent
cop_id_rel := v_event_rel & aux_event_rel & noncop_event_rel.
_be_v_id_rel := cop_id_rel.
_be_v_nv_rel := cop_id_rel.
;;title_id_rel := cop_id_rel.
;;person_name_rel := cop_id_rel.
_colon_v_id_rel := cop_id_rel.
;; DPF 2023-01-06 - Changed PRED of "how" to string, so it will trigger copula
;; for generation as with "How are you?"
;_unspec_a_rel := adj_rel & unspec_loc_or_mod_rel.
; To restrict heads in appositives
quantity_or_no_rel := quantity_or_norm_or_no_rel & non_number_rel.
quantity_rel := quantity_or_no_rel & norm_non_num_rel & quantity_or_norm_rel.
prednom_state_rel := reg_diadic_nom_rel.

be_v_there-or-prd_rel := aux_event_rel.
;; DPF 2018-06-02 - Added so we can allow the elided copula `be' to serve in 
;; tag questions both for |He is tall, isn't he| and |He is Browne, isn't he|
;;
be_v_prd-or-id_rel := event_rel.
be_v_prd_rel := v_event_rel & be_v_there-or-prd_rel & be_v_prd-or-id_rel.
be_v_there-or-id_rel := v_event_rel.
be_v_id-or-nv_rel := cop_id_rel & be_v_there-or-id_rel.
be_v_id_rel := be_v_id-or-nv_rel & be_v_prd-or-id_rel.
be_v_nv_rel := be_v_id-or-nv_rel.
be_v_there_rel := aux_arg1_rel & be_v_there-or-prd_rel & be_v_there-or-id_rel.
be_v_it_rel := aux_arg1_rel.

_be_v_do_rel := cop_id_rel.

unk_n_rel := norm_nom_rel & generic_unk_rel.
gen_currency_rel := reg_nom_rel.

; To distinguish class of nouns that can serve as measure-NP PP-specifiers
meas_nom_rel := reg_nom_rel & nom_nbar_rel & abstr_meas_nom_rel & 
                indef_or_udef_or_meas_rel & non_freerel_q_or_meas_rel &
                def_or_meas_noproper_rel & named_or_meas_rel & 
		dofw_or_poss_or_meas_rel & meas_or_numq_rel & n-meas-or-ed_rel.

meas_np_rel := named_or_meas_rel.

; To allow meas_nom_rel and comp_rel to unify for |four times as many| - FIX?
;; DPF 2022-12-29 - Having this type wrongly allows positive adjectives such
;; as "very tall" to undergo partitive rule meant only for comparatives.  So
;; remove and find a better solution for "four times as many".
;meas_nom_er_rel := meas_nom_rel & comp_rel.

; To support underspecification of compounds vs PPs in generation
compound_or_prep_rel := predsort.

unspec_rel := prep_rel.
compound_rel := unspec_rel & compound_or_prep_rel.
argument_rel := unspec_rel.
appos_rel := unspec_rel.

parenthetical_rel := unspec_rel.
; For n-ed as in "wide-eyed"
unspec_mod_rel := unspec_rel & unspec_loc_or_mod_rel.
; For reflexive pro modification: 'you yourself' 'do it yourself'
refl_mod_rel := miscprep_rel.

; For instrumental relative clauses
with_p_rel := miscprep_rel.

; For implicit scoring relation: |They lost ten to three|
with_p_score_rel := miscprep_rel.

; Relation introduced for tag questions
probable_rel := adj_rel.

; For comparative "as possible" (hack)
possible_rel := adj_rel.

; For how_about entries
how+about_r_rel := verb_or_subord_rel.

basic_conj_rel := non_freerel_rel & nontemp_or_conj_rel & 
            temp_abstr_or_conj_rel.
conj_rel := basic_conj_rel.
implicit_conj_rel := conj_rel.
pos_conj_rel := conj_rel.
_and_c_rel := pos_conj_rel.
_and+all_c_rel := conj_rel.
_and+not_c_rel := conj_rel.
_and_c_btwn_rel := conj_rel.
_and_c_then_rel := conj_rel.
_after_c_rel := conj_rel.
_along+with_c_rel := conj_rel.
_as+well+as_c_rel := conj_rel.
_but_c_rel := pos_conj_rel.
;; This one is for `We hired not Kim but Abrams'
_but_c_not_rel := conj_rel.
_but+also_c_rel := conj_rel.
;; This one is for "We hired Kim but not Abrams'
_but+not_c_rel := conj_rel.
_else_c_rel := conj_rel.
_formerly_c_rel := conj_rel.
_if_c_rel := conj_rel.
_if+not_c_rel := conj_rel.
_instead+of_c_rel := conj_rel.
_let+alone_c_rel := conj_rel.
_much+less_c_rel := conj_rel.
minus_c_rel := conj_rel.
_minus_c_rel := minus_c_rel.
_nor_c_rel := conj_rel.
_or_c_rel := pos_conj_rel.
_or+else_c_rel := conj_rel.
plus_c_rel := conj_rel.
_plus_c_rel := plus_c_rel.
_plus-minus_c_rel := conj_rel.
_rather+than_c_rel := conj_rel.
_than_c_rel := conj_rel.
_then_c_rel := conj_rel.
_though_c_rel := conj_rel.
_though+not_c_rel := conj_rel.
_to_c_from_rel := conj_rel.
_so_c_rel := conj_rel.
_versus_c_rel := conj_rel.
_except+that_c_rel := conj_rel.
_except_c_rel := conj_rel.
_not_c_rel := conj_rel.
_et+al_c_rel := conj_rel.
_etc_c_rel := conj_rel.
_so+on_c_rel := conj_rel.
_vice+versa_c_rel := conj_rel.
_to+name+a+few_c_rel := conj_rel.
_not+to+mention_c_rel := conj_rel.
_not+to+say_c_rel := conj_rel.
_together-with_c_rel := conj_rel.
_yet_c_rel := conj_rel.
_even_c_rel := conj_rel.
_albeit_c_rel := conj_rel.

;; These types enable a paraphrase rule that reverses the order of conjuncts 
;; without feeding itself, by specializing the input.
conj_nonrev_rel := pos_conj_rel.
conj_reversed_rel := pos_conj_rel.

_and_c_nrev_rel := _and_c_rel & conj_nonrev_rel.
_and_c_rev_rel := _and_c_rel & conj_reversed_rel.
_or_c_nrev_rel := _or_c_rel & conj_nonrev_rel.
_or_c_rev_rel := _or_c_rel & conj_reversed_rel.
_but_c_nrev_rel := _but_c_rel & conj_nonrev_rel.
_but_c_rev_rel := _but_c_rel & conj_reversed_rel.

; For fragments
discourse_rel := conj_rel. 

; For number sequences
num_seq_rel := conj_rel.
; For foreign/funny word sequences
fw_seq_rel := conj_rel.

basic_place_n_rel := unspec_diadic_nom_rel & non_temp_nonpro_rel &
                   norm_nom_or_place_rel & reg_or_temp_nom_rel &
		   abstr_named_rel & modable_rel.
place_n_rel :=  basic_place_n_rel.
_place_n_1_rel := basic_place_n_rel & non_temp_nbar_rel.

;; DPF 2022-06-01 - Changed parent from temp_abstr_rel to temp_nondim_rel so
;; we can get "once a day" where "once" is akin to "one time"
time_n_rel := modable_rel & temp_nondim_rel & independent_mod_rel.
_awhile_n_1_rel := time_n_rel.
person_rel := norm_nom_rel.
thing_rel := norm_nom_rel.
manner_rel := norm_nom_rel.
reason_rel := norm_nom_rel.
title_rel := basic_nom_rel.
;pre_title_rel := reg_or_temp_nom_rel.
pre_title_rel := gen_nom_nbar_rel & reg_or_temp_nom_rel.
addressee_rel := basic_nom_rel.
score_n_rel := non_temp_nom_rel.

_be_v_there_rel := aux_arg1_rel.
_be_v_itcleft_rel := aux_arg1_rel.
_gotta_v_modal_rel := modal_rel.
_got_v_to_rel := aux_arg1_rel.
lex_imp_rel := nonaux_event_rel & noncop_event_rel.
_have_v_qmodal_rel := modal_rel.

; Want these to undergo the adj-coord rule
integer_rel := integer_or_color_rel.
const_rel := integer_rel & gen_named_rel & const_or_meas_rel.
plus_rel := integer_rel.
times_rel := integer_rel.
basic_ord_rel := const_rel & ord_or_very_rel & basic_adj_rel.
ord_rel := basic_ord_rel.
ord_unk_rel := basic_ord_rel & generic_unk_rel.

;; DPF 2022-06-04 - Added supertype card_or_fract_rel so the num_det rule
;; can also accept fractions, as in "2 1/2 bottles"
card_or_fract_rel := const_rel.
basic_card_rel := card_or_fract_rel & card_or_much_rel & card_or_interval_rel.
card_rel := basic_card_rel.
card_unk_rel := basic_card_rel & generic_unk_rel.
;;card_of_rel := card_rel.

; DPF 23-May-03 - minute_n_rel is never in a predicative adjective lexeme, so
; we can identify its ARG0 with its ARG1, to allow ordinary cardinal adjectives
; to specialize to minute semantics and let hour-words get the ARG0 index of
; the minute_rel by asking for the lexeme's HOOK.INDEX which is reentrant with
; ARG1 like ordinary adjectives.
minute_rel := card_rel.
range_num_rel := const_rel.
fraction_rel := card_or_fract_rel & named_num_or_fract_rel & num_or_meas_rel.

unknown_rel := v_event_rel.

; Predicate supertype for generic unknown lexical entries
generic_unk_rel := predsort.

; For QUE-word complements as in "what the hell"
wh_the_hell_rel := predsort.
_the+devil_x_rel := wh_the_hell_rel.
_the+heck_x_rel := wh_the_hell_rel.
_the+hell_x_rel := wh_the_hell_rel.
_the+fuck_x_rel := wh_the_hell_rel.
_on+earth_x_rel := wh_the_hell_rel.
_oh+where_x_rel := wh_the_hell_rel.
_in+the+world_x_rel := wh_the_hell_rel.
_exactly_x_rel := wh_the_hell_rel.
_else_x_rel := wh_the_hell_rel.
_more_x_rel := wh_the_hell_rel.

punct_rel := predsort.
paren_rel := punct_rel.
hyphen_rel := punct_rel.
dbl_hyphen_rel := punct_rel.

idiom_expr := sign &
  [ IDIOM + ].

v_nbar_idiom := idiom_expr &
  [ SYNSEM.LOCAL.CONT.RELS <! [ LBL handle,
                                ARG0 event,
                                ARG1 ref-ind,
                                ARG2 ref-ind & #arg2 ],
                              [ LBL handle,
                                ARG0 #arg2 ] !> ].

v_nbar_pp_idiom := idiom_expr &
  [ SYNSEM.LOCAL.CONT.RELS <! [ LBL handle,
                                ARG0 event,
                                ARG1 ref-ind,
                                ARG2 ref-ind & #arg2,
                                ARG3 ref-ind & #arg3 ],
                              [ LBL handle,
                                ARG0 #arg2 ],
                              [ LBL handle,
                                ARG0 #arg3 ] !> ].


; Punctuation marks

punctuation_min := *avm*.

punctuation_min1 := punctuation_min &
 [ PNCTPR pnctpair ].

; DPF 06-sep-07 - Added RCLSTR to record presence of right-half members of
; paired punctuation like parentheses.  Needed independent of RPUNCT since
; these left-right pairs co-occur with commas, periods, etc.  Also needed
; independent of PNCTPR/PAIRED since these features are concerned with
; matching up non-local requirements of RPUNCT on two distinct signs, as
; with matching commas for appositives.  For now, only record right paren,
; since this is needed to constrain the "floating" rules for parenthesized
; sentences and nominals, as in "Kim (my cousin is a doctor) arrived").
;; DPF 2016-09-12 - Added IGNOREQ boolean feature to record that we have 
;; ignored a right quote mark on a token; needed in order to prevent the 
;; foreigh-word sequence rule from continuing on past a closing right quote 
;; mark.
;; DPF 2017-02-01 - Also added RITAL (right italics) for foreign-word sequences
;; such as |the phrase "el amor".| 
;; DPF 2019-03-31 - Added LCLSTR so we can verify matched parens, and perhaps
;; other paired punctuation.
;
punctuation := punctuation_min1 &
  [ LPUNCT basic_punct_mark,
    RPUNCT basic_punct_mark,
    PAIRED pnctpair,
    LCLSTR lpunct_cluster,
    RCLSTR rpunct_cluster ].

;; DPF 2018-06-14 - And added LITAL (paired right and left italics) for single
;; italicized words, to mark so they don't get filtered by the lexical filtering
;; rule even after undergoing punctuation, as in
;; |we admired the ⌊/glump/⌋.| where neither the synsem type nor the LPUNCT 
;; attributes would block filtering.
;;
rpunct_cluster := *avm* &
  [ RPAREN luk,
    RFP bool,
    IGNOREQ bool,
    RITAL bool,
    LITAL bool ].

lpunct_cluster := *avm* &
  [ LPAREN luk ].

no_punctuation_min := punctuation_min1.
;; DPF 2019-03-31 - Make default LPAREN value be na_or_- so we can constrain
;; the right dtr of a binary rule to require unification of LPAREN and RPAREN,
;; allowing an unpaired right paren (with RPAREN na_or_+) to continue upward, 
;; but not an unpaired LPAREN.
;;
no_punctuation := punctuation & no_punctuation_min &
  [ LPUNCT no_punct,
    RPUNCT no_punct,
    PNCTPR ppair,
    RCLSTR [ RPAREN -,
	     RFP -,
	     RITAL -,
	     LITAL - ],
    LCLSTR.LPAREN na_or_- ].

;; DPF 2017-12-16 - Type to contrast with inherited lexical no_punctuation,
;; a contrast we use in blocking verbal gerunds which are only lexical
;; participles such as |eating| that have undergone the optcomp rule but
;; no other construction that would change the type of PUNCT.
norm_punctuation := punctuation.

basic_punct_mark := *avm* &
  [ PSF iforce ].

clause_or_semi_or_pair_or_no_punct := basic_punct_mark.
clause_or_semi_or_comma_or_no_punct := 
				hyphen_or_comma_or_clause_or_semi_or_no_punct.
clause_or_semi_or_comma := clause_or_semi_or_comma_or_no_punct.
clause_or_semicol_or_no_punct := clause_or_semi_or_pair_or_no_punct &
				 clause_or_semi_or_comma_or_no_punct.
clause_or_semicol_or_hyphen_or_no_punct := basic_punct_mark.
clause_or_semicol_or_hyphen := clause_or_semicol_or_hyphen_or_no_punct.
clause_or_semicol := clause_or_semicol_or_no_punct &
		     clause_or_semicol_or_hyphen & clause_or_semi_or_comma.
;; 2022-12-13 - Used in rbc-appositive rule
semicol_or_hyphen_or_rbc := basic_punct_mark.
semicol_or_hyphen := clause_or_semicol_or_hyphen & semicol_or_hyphen_or_rbc.
comma_or_rbc_or_clause_or_pair_or_no_punct := basic_punct_mark.
comma_or_rbc_or_semi_or_pair_or_no_punct := basic_punct_mark.
comma_or_clause_or_pair_or_no_punct := 
    comma_or_rbc_or_clause_or_pair_or_no_punct.
comma_or_rbc_or_clause_or_no_punct := 
    comma_or_rbc_or_clause_or_pair_or_no_punct.
comma_or_semi_or_pair_or_no_punct := comma_or_rbc_or_semi_or_pair_or_no_punct.
clause_or_pair_or_no_punct := comma_or_clause_or_pair_or_no_punct &
			      clause_or_semi_or_pair_or_no_punct.
clause_or_no_punct := clause_or_semicol_or_no_punct & 
                      clause_or_pair_or_no_punct &
		      quote_or_hyphen_or_clause_or_no_punct &
		      rparen_or_clause_or_no_punct.
comma_or_clause_or_pair_punct := comma_or_clause_or_pair_or_no_punct &
                                 hyphen_or_comma_or_pair_or_clause.
comma_or_clause_or_no_punct := comma_or_clause_or_pair_or_no_punct &
			       hyphen_or_comma_or_clause_or_no_punct &
			       clause_or_semi_or_comma_or_no_punct &
			       rparen_or_comma_or_clause_or_no_punct &
                               comma_or_rbc_or_clause_or_no_punct.
comma_or_rbc_or_hyphen_or_pair_or_no_punct := basic_punct_mark.
comma_or_rbc_or_colon_or_pair_or_no_punct := basic_punct_mark.
colon_or_pair_or_no_punct := comma_or_rbc_or_colon_or_pair_or_no_punct.
comma_or_hyphen_or_pair_or_no_punct := comma_or_rbc_or_hyphen_or_pair_or_no_punct.
rbc_or_hyphen_or_pair_or_no_punct := comma_or_rbc_or_hyphen_or_pair_or_no_punct.
hyphen_or_pair_or_no_punct := comma_or_hyphen_or_pair_or_no_punct &
                              rbc_or_hyphen_or_pair_or_no_punct.
comma_or_rbc_or_pair_or_no_punct := comma_or_rbc_or_hyphen_or_pair_or_no_punct &
				    comma_or_rbc_or_colon_or_pair_or_no_punct &
				    comma_or_rbc_or_semi_or_pair_or_no_punct.
comma_or_rbc_or_no_punct := comma_or_rbc_or_pair_or_no_punct &
                            comma_or_rbc_or_clause_or_no_punct.
comma_or_pair_or_no_punct := comma_or_hyphen_or_pair_or_no_punct &
                             comma_or_rbc_or_pair_or_no_punct &
                             comma_or_clause_or_pair_or_no_punct &
			     comma_or_semi_or_pair_or_no_punct &
			     lital_or_pair_or_comma_or_no_punct.
rbc_or_pair_or_no_punct := comma_or_rbc_or_pair_or_no_punct &
                           comma_or_hyphen_or_pair_or_no_punct &
                           rbc_or_hyphen_or_pair_or_no_punct.
rbc_or_no_punct := rbc_or_pair_or_no_punct & hyphen_sgl_or_rbc_or_no_punct &
		   rparen_or_rbc_or_no_punct.

comma_or_hyphen_or_pair_punct := comma_or_hyphen_or_pair_or_no_punct.

non_double_quote_punct := basic_punct_mark.
hyphen_or_comma_or_clause_or_semi_or_no_punct := non_double_quote_punct.
hyphen_or_comma_or_clause_or_no_punct := 
                                 hyphen_or_comma_or_clause_or_semi_or_no_punct.
hyphen_sgl_or_clause_or_no_punct := hyphen_or_comma_or_clause_or_no_punct.
hyphen_dbl_or_clause_or_no_punct := basic_punct_mark.
hyphen_sgl_or_rbc_or_rparen_or_no_punct := basic_punct_mark.
hyphen_sgl_or_rbc_or_no_punct := hyphen_sgl_or_rbc_or_rparen_or_no_punct.
;; 2012-12-21 - Added supertype rparen_or_rbc_or_no_punct to comma_or_no_punct
;; in order to admit e.g |cats which, in Paris, arise arrive|
;;
comma_or_no_punct := comma_or_clause_or_no_punct & comma_or_pair_or_no_punct &
                     comma_or_rbc_or_no_punct & comma_or_semi_or_no_punct &
		     rparen_or_rbc_or_no_punct.
comma_or_rbc_punct := comma_or_rbc_or_no_punct & 
		      hyphen_or_comma_or_rbc_or_pair_or_clause.
hyphen_sgl_or_no_punct := hyphen_sgl_or_clause_or_no_punct &
			  hyphen_sgl_or_rbc_or_no_punct &
			  hyphen_or_pair_or_no_punct.
hyphen_dbl_or_no_punct := hyphen_dbl_or_clause_or_no_punct &
                          hyphen_or_pair_or_no_punct.
3dots_or_no_punct := basic_punct_mark.
;; Allow for robust prefixed comma in head_spec
lital_or_pair_or_comma_or_no_punct := basic_punct_mark.
lital_or_pair_or_no_punct := lital_or_pair_or_comma_or_no_punct.
pair_or_no_punct := comma_or_pair_or_no_punct & hyphen_or_pair_or_no_punct
                    & clause_or_pair_or_no_punct & rbc_or_pair_or_no_punct &
		    semi_or_pair_or_no_punct & lital_or_pair_or_no_punct &
                    colon_or_pair_or_no_punct.
;; DPF 2020-03-09 - Needed for |Kim was ⌊/launched/⌋, where we want period to 
;; attach after first lital-drop and then rital-drop, but still want to 
;; constrain interactions of lital(-drop) and rital(-drop).
;;
lital_or_dropped_or_no_punct := lital_or_pair_or_no_punct.
lital_or_no_punct := lital_or_dropped_or_no_punct.
no_punct := clause_or_no_punct & comma_or_no_punct & hyphen_sgl_or_no_punct &
            hyphen_dbl_or_no_punct & 3dots_or_no_punct & pair_or_no_punct &
            lparen_or_no_punct & rbc_or_no_punct & dq_or_no_punct &
	    semi_or_no_punct & dq_or_sq_or_lital_or_no_punct & 
	    clause_or_semicol_or_hyphen_or_no_punct & rparen_or_no_punct.
no_punct_dropped := no_punct & lital_or_dropped_or_no_punct.
no_punct_norm := no_punct & lital_or_no_punct.

pnctpair := *sort*.
no_ppair := pnctpair.
ppair := pnctpair.

punct_mark := basic_punct_mark.

hyphen_or_comma_or_rbc_or_pair_or_clause := punct_mark.
hyphen_or_comma_or_pair_or_clause := hyphen_or_comma_or_rbc_or_pair_or_clause.
;; For num-cl as in |1. We arise| or |1) We arise|
hyphen_or_comma_or_rparen_or_clause := punct_mark.
hyphen_or_comma_or_clause := hyphen_or_comma_or_pair_or_clause &
			     hyphen_or_comma_or_rparen_or_clause.
hyphen_or_comma_or_semicol_punct := non_double_quote_punct.
hyphen_or_comma_or_sdash := punct_mark.
hyphen_or_comma := hyphen_or_comma_or_clause & comma_or_hyphen_or_pair_punct &
		   hyphen_or_comma_or_semicol_punct & hyphen_or_comma_or_sdash.
hyphen_sgl_or_clause := punct_mark.
hyphen_sgl_dbl_sdash_or_clause := punct_mark.
hyphen_sgl_or_dbl_or_sdash := hyphen_or_rparen_or_comma_or_no_punct &
			      hyphen_or_comma_or_sdash & semicol_or_hyphen &
			      hyphen_sgl_dbl_sdash_or_clause.
hyphen_sgl_or_dbl := hyphen_sgl_or_dbl_or_sdash.
;; DPF 2022-12-13 - Moved semicol_or_hyphen up to include double-hyphen and
;; s-dash, now used for rbc-marked appositives
hyphen_sgl := hyphen_sgl_or_clause & hyphen_sgl_or_no_punct &
              hyphen_or_comma & pair_or_no_punct &
	      quote_or_hyphen_or_no_punct &
	      comma_or_rbc_or_clause_or_no_punct & hyphen_sgl_or_dbl &
	      clause_or_semi_or_comma_or_no_punct.

hyphen_dbl_or_clause := punct_mark.
comma_or_clause := comma_or_clause_or_no_punct & hyphen_or_comma_or_clause &
                   comma_or_clause_or_pair_punct & clause_or_semi_or_comma.
comma_or_pair_punct := comma_or_pair_or_no_punct & 
                       comma_or_clause_or_pair_punct &
		       comma_or_hyphen_or_pair_punct.

;; DPF 2014-04-28 - Added quote_or_hyphen_or_clause_or_no_punct to allow 
;; city-state compound marked with comma to still be followed by parenthetical,
;; as in  |Sausalito, California, (IBM)|.
;; FIX to clean up.
;;
comma_punct := comma_or_clause & comma_or_no_punct & comma_or_pair_punct &
	       comma_or_rbc_punct & comma_or_semicol & 
	       rparen_or_comma_or_no_punct & hyphen_or_comma &
	       quote_or_hyphen_or_clause_or_no_punct &
	       lparen_or_dq_or_comma_or_no_punct.

3dots_or_clause := basic_punct_mark.
3dots_punct := 3dots_or_clause & 3dots_or_no_punct & basic_clause_punct.
comma_or_semi_or_no_punct := comma_or_semi_or_pair_or_no_punct.
semi_or_pair_or_no_punct := comma_or_semi_or_pair_or_no_punct.
semi_or_no_punct := comma_or_semi_or_no_punct & semi_or_pair_or_no_punct.
comma_or_semicol := comma_or_semi_or_no_punct & 
		    hyphen_or_comma_or_semicol_punct.
basic_semicol_punct := clause_or_semicol & semi_or_no_punct & semicol_or_hyphen
		       & comma_or_semicol & hyphen_or_comma_or_pair_or_clause.
basic_clause_punct := clause_or_no_punct & clause_or_semicol &
		      comma_or_clause_or_pair_punct &
		      hyphen_sgl_dbl_sdash_or_clause.
clause_punct := comma_or_clause & 3dots_or_clause & basic_clause_punct.
semicol_punct := basic_clause_punct & basic_semicol_punct &
		 comma_or_rbc_or_clause_or_no_punct.

clause_sh_punct := hyphen_sgl_or_clause & basic_clause_punct.
clause_dh_punct := hyphen_dbl_or_clause & basic_clause_punct.
;; DPF 2016-09-17 - Changed parent from comma_or_pair_or_no_punct to
;; comma_or_pair_punct to get |We arose - because he arrived.|
;; Trying to reduce need for single hyphen ...
hyphen_dbl_or_sdash := hyphen_sgl_or_dbl_or_sdash.
s_dash_punct := basic_clause_punct & comma_or_rbc_or_clause_or_no_punct &
                hyphen_sgl_or_rbc_or_no_punct & hyphen_dbl_or_sdash &
		comma_or_hyphen_or_pair_punct & pair_or_no_punct &
		hyphen_or_comma_or_clause & hyphen_or_comma_or_semicol_punct.
colon_punct := colon_or_pair_or_no_punct & basic_clause_punct &
               comma_or_clause_or_no_punct.
pair_punct := pair_or_no_punct & comma_or_pair_punct.
lparen_or_dq_or_comma_or_no_punct := basic_punct_mark.
lparen_or_dq_or_no_punct := lparen_or_dq_or_comma_or_no_punct.
lparen_or_no_punct := lparen_or_dq_or_no_punct & non_double_quote_punct.
; Include parent type dq_or_sq_or_no_punct for np-hdn_nme-cpd_c (unused 
; elsewhere)
lparen_punct := pair_punct & lparen_or_no_punct & dq_or_sq_or_no_punct.
rparen_or_rbc_or_no_punct := basic_punct_mark.
hyphen_or_rparen_or_comma_or_no_punct := basic_punct_mark.
rparen_or_comma_or_no_punct := non_double_quote_punct &
			       hyphen_or_rparen_or_comma_or_no_punct.
rparen_or_comma_or_clause_or_no_punct := basic_punct_mark.
rparen_or_clause_or_no_punct := rparen_or_comma_or_clause_or_no_punct.
rparen_or_no_punct := rparen_or_rbc_or_no_punct & rparen_or_comma_or_no_punct &
  rparen_or_clause_or_no_punct.
; Add comma_or_rbc_or_clause_or_no_punct to allow e.g. |(those who smile)|
rparen_punct := pair_punct & comma_or_rbc_or_clause_or_no_punct & 
		rparen_or_no_punct & quote_or_hyphen_or_clause_or_no_punct &
		hyphen_or_comma_or_rparen_or_clause &
		hyphen_sgl_or_rbc_or_rparen_or_no_punct.
quote_or_hyphen_or_clause_or_no_punct := basic_punct_mark.
quote_or_hyphen_or_no_punct := quote_or_hyphen_or_clause_or_no_punct.
dq_or_sq_or_no_punct := comma_or_rbc_or_clause_or_no_punct &
			quote_or_hyphen_or_no_punct.
dq_or_no_punct := dq_or_sq_or_no_punct & lparen_or_dq_or_no_punct.
dq_or_sq_or_lital_or_no_punct := punct_mark.
dq_or_sq_or_lital_punct := dq_or_sq_or_lital_or_no_punct.
dq_or_sq_or_rital_punct := punct_mark.
dq_punct := basic_clause_punct & pair_punct & 3dots_or_clause &
            dq_or_no_punct & hyphen_or_comma_or_clause &
            dq_or_sq_or_lital_punct & dq_or_sq_or_rital_punct.
sq_punct := basic_clause_punct & pair_punct & dq_or_sq_or_no_punct &
            dq_or_sq_or_lital_punct & dq_or_sq_or_rital_punct &
	    lparen_or_dq_or_no_punct.
hyphen_dbl := hyphen_dbl_or_clause & hyphen_dbl_or_no_punct &
              hyphen_or_comma_or_clause & pair_or_no_punct & hyphen_sgl_or_dbl &
	      hyphen_dbl_or_sdash.

; Robust punctuation
rbcomma_punct := rbc_or_no_punct & comma_or_rbc_punct &
		 semicol_or_hyphen_or_rbc.
; Inserted by preprocessor.
cap_punct := punct_mark.

asterisk_punct := punct_mark & pair_or_no_punct.

; For italicized (foreign/funny) words
lital_punct := dq_or_sq_or_lital_punct & lital_or_no_punct &
	       comma_or_hyphen_or_pair_or_no_punct.
rital_punct := dq_or_sq_or_rital_punct.

genre := *sort*.
formality := genre.
formal := formality.
nonformal := formality.
g-medium := genre.
written := g-medium.
spoken := g-medium.
standard := genre.
edited := formal & standard.
informal := nonformal & standard.
nonstandard := nonformal.
prescrip := formal.
robust := nonformal.
paraphrase := genre.
formal-w := formal & written.
formal-s := formal & spoken.
edited-w := edited & written.
edited-s := edited & spoken.
prescrip-w := prescrip & written.
prescrip-s := prescrip & spoken.
standard-w := standard & written.
standard-s := standard & spoken.
informal-w := informal & written.
informal-s := informal & spoken.
nonformal-w := nonformal & written.
nonformal-s := nonformal & spoken.
robust-w := robust & written.
robust-s := robust & spoken.

;; Dialect

dialect := *sort*.
us := dialect.
br := dialect.
uk := br.
au := br.
sgp := dialect.

basic_root_synsem := canonical_synsem &
  [ LOCAL [ CAT [ VAL [ SUBJ *olist*,
                        SPR *olist*,
                        COMPS < > ] ] ],
    NONLOC [ SLASH .LIST < >,
             REL.LIST < >,
             QUE.LIST < > ] ].

root_synsem := basic_root_synsem &
  [ LOCAL [ CAT [ HEAD verbal_or_conj-s & 
		       [ VFORM fin_or_imp,
			 TAM indic_tam ],
		  MC + ],
	    CONT.HOOK.INDEX.SF #pred,
	    CONJ cnil ],
    PUNCT.RPUNCT comma_or_clause_or_pair_or_no_punct &
	         [ PSF #pred ] ].

root_orth := orthog.

basic_root_phr_synsem := basic_root_synsem & phr_synsem.
basic_root_lex_synsem := basic_root_synsem & lex_synsem.
root_phr_synsem := root_synsem & phr_synsem.
;; DPF 2020-03-24 - Added SLASH constraint as per trunk.
;;
root_lex_synsem := root_synsem & lex_synsem &
  [ NONLOC.SLASH.LIST < > ].

;; DPF 2022-06-11 - Removed identity of HOOK..SF and RPUNCT.PSF since we
;; also want "and that he would be late?" where complementizer "that" wants
;; its complement to be SF prop.

#|
root_frag_synsem := canonical_synsem &
  [ LOCAL [ CAT [ HEAD conj_or_frag,
		  VAL.COMPS *olist*,
		  MC na_or_+ ],
	    CONJ cnil_or_lexconj,
	    CONT.HOOK.INDEX.SF #pred ],
    NONLOC.SLASH.LIST < >,
    PUNCT.RPUNCT comma_or_clause_or_pair_or_no_punct & [ PSF #pred ] ].
|#
root_frag_synsem := canonical_synsem &
  [ LOCAL [ CAT [ HEAD conj_or_frag,
		  VAL.COMPS *olist*,
		  MC na_or_+ ],
	    CONJ cnil_or_lexconj ],
    NONLOC.SLASH.LIST < >,
    PUNCT.RPUNCT comma_or_clause_or_pair_or_no_punct ].

frag_phr_synsem := root_frag_synsem & phr_synsem.

;; DPF 2020-07-17 - We don't want to identify root's INDEX.SF with the 
;; phrase's RPUNCT.PSF because at least for some tag questions, we've
;; elected to treat the SF of the whole as prop rather than ques, e.g. in 
;; "He left, didn't he?". 
;;
root_gen_synsem := basic_root_phr_synsem &
  [ LOCAL [ CAT [ HEAD verb_or_conj-s &
		       [ VFORM fin_or_imp,
			 TAM indic_tam ],
		  MC + ],
	    CONT.HOOK.INDEX.SF #pred,
	    CONJ cnil ],
    PUNCT.RPUNCT basic_clause_punct &
	         [ PSF #pred ] ].

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Logical operations
;
;; DPF 2022-11-12 - Added initially for feature --SLASHED which is used to
;; report whether a phrase contains a gap, to improve efficiency in packing and
;; unpacking after change to use Emerson-Turing computation type lists for the
;; value of SLASH.

bool-wrapper := *avm* &
  [ BOOL bool ].

logical-and := bool-wrapper &
  [ BOOL #result,
    AND list-of-bools-with-and & [ AND-RESULT #result ] ].

logical-or := bool-wrapper &
  [ BOOL #result,
    OR list-of-bools-with-or & [ OR-RESULT #result ] ].

logical-not := bool-wrapper &
  [ BOOL #result,
    NOT bool-wrapper & [ BOOL bool-with-not & [ RESULT-BOOL #result ] ] ].

list-of-bools-with-and := *list* &
  [ AND-RESULT bool ].

cons-of-bools-with-and := list-of-bools-with-and & *cons* &
  [ FIRST.BOOL bool-with-and & [ OTHER-BOOL #other,
				 RESULT-BOOL #result ],
    REST list-of-bools-with-and & [ AND-RESULT #other ],
    AND-RESULT #result ].

null-of-bools-with-and := list-of-bools-with-and & *null* &
  [ AND-RESULT + ].

list-of-bools-with-or := *list* &
  [ OR-RESULT bool ].

cons-of-bools-with-or := list-of-bools-with-or & *cons* &
  [ FIRST.BOOL bool-with-or & [ OTHER-BOOL #other,
				RESULT-BOOL #result ],
    REST list-of-bools-with-or & [ OR-RESULT #other ],
    OR-RESULT #result ].

null-of-bools-with-or := list-of-bools-with-or & *null* &
  [ OR-RESULT - ].

bool-with-operation := bool &
  [ RESULT-BOOL bool ].

bool-with-not := bool-with-operation.

+-with-not := bool-with-not & + &
  [ RESULT-BOOL - ].

--with-not := bool-with-not & - &
  [ RESULT-BOOL + ].

bool-with-binary-operation := bool-with-operation &
  [ OTHER-BOOL bool ].

bool-with-and := bool-with-binary-operation.

+-with-and := bool-with-and & + &
  [ OTHER-BOOL #result,
    RESULT-BOOL #result ].

--with-and := bool-with-and & - &
  [ RESULT-BOOL - ].

bool-with-or := bool-with-binary-operation.

+-with-or := bool-with-or & + &
  [ RESULT-BOOL + ].

--with-or := bool-with-or & - &
  [ OTHER-BOOL #result,
    RESULT-BOOL #result ].
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;