;;; Hey, emacs(1), this is -*- Mode: TDL; Coding: utf-8; -*- got it?

;;;
;;; first shot of minimal type hierarchy for transfer rules in LOGON; derived
;;; from LinGO Grammar Matrix, but greatly stripped down.       (7-oct-03; oe)
;;;

mrs := top &
[ LTOP h,
  INDEX u,
  RELS list,
  HCONS list ].

psoa := mrs &
[ INDEX e ].

nom-obj := mrs &
[ INDEX x ].

qeq := top &
[ HARG h,
  LARG h ].        


;;;
;;; minimal hierarchy of variable types, using the new (R)MRS naming scheme.
;;;

;;;
;;; introduce two transfer-only `scratch' slots in variables: one that will be
;;; purged after each successful rule application, one that will stick until we
;;; leave transfer.  additionally, provide DITCH property to mark variables we
;;; want to loose in the final output (e.g. to ditch the ARG0 from conjunctions
;;; while the ERG used to have C-ARG instead).
;;;
u := top & [ SKOLEM string, SCRATCH scratch, MARK scratch, DITCH bool ].
i := u.
p := u.
h := p.
e := i & 
[ TENSE tense, MOOD mood, PERF luk, PROG luk, STATIVE luk, BOUNDED luk,
  PSVTYPE psvtype ].
x := i & p & 
[ PERS person, NUM number, NATGEND gender, 
  DIV bool, GRIND luk,
  PRONTYPE prontype ].

;;;
;;; to check for `arity' in MTRs, maybe we need an `anti-'variable type
;;;
a := u.

tense := top.
tensed := tense.
past := tensed.
non-past := tensed.
pres := non-past.
fut := non-past.
untensed := tense.

;;;
;;; _fix_me_
;;; these should not be exposed from the ERG SEM-I, we think.
;;;
notense := tense.
nontense := untensed.
no_tense := untensed.

mood := top.
indicative := mood.
subjunctive := mood.

psvtype := top.
passive := psvtype.
periph := passive.
morph := passive.
active := psvtype.

;;;
;;; _fix_me_
;;; the following two are required to generate `could' in the (jun-04) version
;;; of the ERG; this will likely need more harmonization.       (25-aug-04; oe)
;;;
real_tense := tense.
ind_or_mod_subj := mood.

luk := top.
bool := luk.
na := luk.
+ := bool.
- := bool.

person := top.
1 := person.
2 := person.
3 := person.
no_person := person.

number := top.
sg := number.
pl := number.
no_number := number.

gender := top.
animate := gender.
m := animate.
f := animate.
n := gender.
andro := animate.
no_gender := gender.

;;;
;;; _fix_me_
;;; the following are simply imported from the ERG, thus not sanctioned by the
;;; LOGON MRS Design Committee.                                (19-nov-04; oe)
;;;
prontype := top.
real_pron := prontype.
std_pron := real_pron.
recip := real_pron.
refl := real_pron.
impers := real_pron.
demon := real_pron.

;;;
;;; the scratch slot in variables: used during transfer to control application
;;; of rules, e.g. the rules that introduce selected preposition EPs in the ERG
;;; accomodation phase which would otherwise be cyclic, i.e. the rule would
;;; fire on its own output (since it does not consume anything).
;;;
scratch := top.
test := scratch.
complete := scratch.
one := scratch.
two := scratch.
three := scratch.
four := scratch.
five := scratch.
six := scratch.

;;;
;;; _fix_me_
;;; in `abrams saw a chair in berlin', the ERG uses `untensed' on the PP event
;;; when attaching inside of the NP, but `no_tense' when attaching to the VP.
;;; check with ERG documentation or dan to see whether this is intended.  also,
;;; is there a hierarchical relation between the two?          (28-jan-04; oe)
;;;
e_tensed := e [ TENSE tensed ].
e_untensed := e & [ TENSE untensed ].
e_no_tense := e & [ TENSE no_tense ].
e_nontense := e & [ TENSE nontense ].

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

relation := top &
[ LBL h,
  PRED predsort ].

arg0-relation := relation &
[ ARG0 u ].

arg1-relation := relation &
[ ARG1 u ].

arg01-relation := arg0-relation & arg1-relation.

arg2-relation := relation &
[ ARG2 u ].

arg012-relation := arg01-relation & arg2-relation.

arg3-relation := relation &
[ ARG3 u ].

arg0123-relation := arg012-relation & arg3-relation.

arg4-relation := relation &
[ ARG4 u ].

arg01234-relation := arg0123-relation & arg4-relation.


event-relation := arg0-relation &
[ ARG0 e ].

noun-relation := arg0-relation &
[ ARG0 x ].

relational-noun-relation := noun-relation & arg1-relation &
[ ARG1 x ].

named-relation := arg0-relation &
[ CARG top ].

named-arg1-relation := named-relation & arg1-relation.

;;;
;;; _fix_me_
;;; this reflects the current (4-apr-04) ERG, but not the Matrix.  presumably,
;;; i would have to agree with emily, these should use L-HNDL and R-HNDL too.
;;;                                                           (17-apr-04; oe)
;;;
;;; --- but maybe i no longer believe that nowadays.          (14-jul-04; oe)
;;;
subord-relation := relation &
[ MAIN h,
  SUBORD h ].

conjunction-relation := subord-or-conj-relation &
[ L-INDEX i,
  R-INDEX i ].

subord-or-conj-relation := arg0-relation &
[ L-HNDL u,
  R-HNDL u ].

unspec-compound-relation := arg012-relation &
[ ARG0 e,
  ARG1 x,
  ARG2 x ].

quant-relation := arg0-relation &
[ ARG0 x,
  RSTR h,
  BODY h ].

unknown-relation := arg0-relation &
[ ARG u ].

;;;
;;; some basic types
;;;

list := top.

cons := list &
[ FIRST top,
  REST list ].

null := list.

string := predsort.

flags := top &
[ OPTIONAL luk,
  EQUAL list,
  SUBSUME list,
  EXHAUSTIVE bool,
  AUTHOR string,
  DATE string,
  KF bool,
  RANK string ].

mrs_transfer_rule :=  top &
[ FILTER mrs,
  CONTEXT mrs,
  INPUT mrs,
  OUTPUT mrs,
  FLAGS flags ].

;;;
;;; a few `special-purpose' types, transfer operators in a sense
;;;

+upcase+ := string.
+downcase+ := string.

operator := top.
+copy+ := operator.