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

;;;
;;; finally, perform some post-core fix-up: make sure variable equations are
;;; being propagated, delete transfer-internal meta EPs, et al.
;;;

;;;
;;;
;;; NorGram has relatively vanilla analyses of V+N and Adj+N compounds; for the
;;; ones that made it this far, convert them into a compositonal structure.
;;;
v+n_compound_cf := monotonic_mtr &
[ INPUT.RELS < [ PRED "~_v_", LBL #h4, ARG0 #e3 ],
               [ PRED compound_rel, LBL #h0, 
                 ARG0 #e1, ARG1 #x2, ARG2 #e3 & e ] >,
  OUTPUT [ RELS < +copy+ & [ ARG0 [ PROG + ] ],
                  [ PRED compound_rel, LBL #h0, 
                    ARG0 #e1, ARG1 #x2, ARG2 #x5 ],
                  [ PRED udef_q_rel, 
                    ARG0 #x5 & [ PERS 3, NUM sg, GRIND - ], RSTR #h6 ],
                  [ PRED nominalization_rel, LBL #h7, ARG0 #x5, ARG1 #h8 ],
                  [ PRED prpstn_m_rel, LBL #h8, 
                    ARG0 #e3, MARG #h9 ] >,
           HCONS < qeq & [ HARG #h6, LARG #h7 ],
                   qeq & [ HARG #h9, LARG #h4 ] > ],
  FLAGS.EQUAL < #e3 > ].

adj+n_compound_cf := monotonic_mtr &
[ INPUT.RELS < [ PRED #pred, LBL #h4, ARG0 #e3, ARG1 a ],
               [ PRED compound_rel, LBL #h0, 
                 ARG0 #e1, ARG1 #x2, ARG2 #e3 & e ] >,
  OUTPUT.RELS < [ PRED #pred, LBL #h0, ARG0 #e1, ARG1 #x2 ] >,
  FLAGS.EQUAL < #e3 > ].

;;;
;;; a genuine difference between the languages: where Norwegian allows 
;;; non-finite VPs as internal arguments to prepositions, English requires a
;;; nominalization in the corresponding construction.     (16-oct-06; dan & oe)
;;;
;;; _fix_me_
;;; the three-rule solution is rather baroque, simply because we cannot have a
;;; PRED regular expression (on the preposition) plus a variable :-{.
;;;                                                             (16-oct-06; oe)
prep_mark_cf := monotonic_mtr &
[ CONTEXT.RELS < [ PRED "~_p_", LBL #h0, ARG0 #e0 & e, ARG2 #h1 & h ] >,
  FILTER.RELS < [ PRED prep_mark, LBL #h0, ARG0 #e0 ] >,
  OUTPUT.RELS < [ PRED prep_mark, LBL #h0, ARG0 #e0 ] >,
  FLAGS.EQUAL < #e0, #h1 > ].
  
prep+prpstn_cf := monotonic_mtr &
[ CONTEXT.RELS < [ PRED prpstn_m_rel, LBL #h0, ARG0 #e0 & e ] >,
  INPUT.RELS < [ PRED "~_v_", ARG0 #e0 ],
               [ PRED #p, LBL #h1, ARG0 #e1, ARG1 #i1, ARG2 #h0 ],
               [ PRED prep_mark, LBL #h1, ARG0 #e1 ] >,
  OUTPUT [ RELS < +copy+ & [ ARG0 [ PROG + ] ],
                  [ PRED udef_q_rel, ARG0 #x2, RSTR #h2 ],
                  [ PRED nominalization_rel, LBL #h3,
                    ARG0 #x2 & x & [ NUM sg, PERS 3, GRIND - ], ARG1 #h0 ],
                  [ PRED #p, LBL #h1, ARG0 #e1, ARG1 #i1, ARG2 #x2 ] >,
           HCONS < qeq & [ HARG #h2, LARG #h3 ] > ],
  FLAGS.EQUAL < #e0 > ].

prep_ditch_cf := elision_mtr &
[ INPUT.RELS < [ PRED prep_mark ] > ].


;;;
;;; _fix_me_
;;; the way +copy+ works, we cannot change variable bindings; using a variable
;;; for PRED, on the other hand, results in a spurious overwrite with the PRED
;;; regular expression.  we should fix the way +copy+ works!  for now, just go
;;; for a larg-ish set of rules ... :-{.                       (24-jul-04; oe)
;;;
equate_m_cf := monotonic_mtr &
[ CONTEXT.RELS < [ PRED equate, ARG0 #e0 & e, ARG1 #e1 & e ] >,
  INPUT.RELS < [ PRED #pred, LBL #h0, 
                 ARG0 #e1, MARG #h3 & h, TPC #u4, PSV #u5 ] >,
  FILTER.RELS < [ PRED equate_mark, LBL #h0, ARG0 #h3 ] >,
  OUTPUT.RELS < [ PRED #pred, LBL #h0, ARG0 #e0, MARG #h3, TPC #u4, PSV #u5 ],
                [ PRED equate_mark, LBL #h0, ARG0 #h3 ] >,
  FLAGS.EQUAL < #e0, #e1, #h3 > ].

equate_p_cf := monotonic_mtr &
[ CONTEXT.RELS < [ PRED intersective_equate, ARG0 #i0 & i, ARG1 #i1 & i ],
                 [ PRED intersective_equate, ARG0 #h0 & h, ARG1 #h1 & h ] >,
  INPUT.RELS < [ PRED #pred, LBL #h1, ARG0 #e2 & e, ARG1 #i1, ARG2 #x0 & x ] >,
  FILTER.RELS < [ PRED equate_mark, ARG0 #e2 ] >,
  OUTPUT.RELS < [ PRED #pred, LBL #h0, ARG0 #e2, ARG1 #i0, ARG2 #x0 & x ],
                [ PRED equate_mark, ARG0 #e2 ] >,
  FLAGS.SUBSUME < #i0, #i1, #h0, #h1, #e2, #x0 > ].

equate_a_cf := monotonic_mtr &
[ CONTEXT.RELS < [ PRED intersective_equate, ARG0 #i0 & i, ARG1 #i1 & i ],
                 [ PRED intersective_equate, ARG0 #h0 & h, ARG1 #h1 & h ] >,
  INPUT.RELS < [ PRED #pred, LBL #h1, ARG0 #e2 & e, ARG1 #i1 ] >,
  FILTER.RELS < [ PRED equate_mark, ARG0 #e2 ] >,
  OUTPUT.RELS < [ PRED #pred, LBL #h0, ARG0 #e2, ARG1 #i0 ],
                [ PRED equate_mark, ARG0 #e2 ] >,
  FLAGS.SUBSUME < #i0, #i1, #h0, #h1, #e2 > ].

equate_ditch_cf := elision_mtr &
[ INPUT.RELS < [ PRED equate ] > ].

mark_ditch_cf := elision_mtr &
[ INPUT.RELS < [ PRED equate_mark ] > ].

;;;
;;; _fix_me_
;;; see comments on `adjective_prp_participle_mtr' definition for the rationale
;;; behind the following mechanism.                             (29-may-06; oe)
;;;
progressive_cf := monotonic_mtr &
[ INPUT.RELS < [ LBL #h4 & h, ARG0 #e2 & e ],
               [ PRED progressive_mark, LBL #h4, ARG0 #e2 ] >,
  OUTPUT.RELS < +copy+ & [ ARG0 [ PROG +, TENSE untensed ] ] >,
  FLAGS.EQUAL < #h4, #e2 > ].

progressive_ditch_cf := elision_mtr &
[ INPUT.RELS < [ PRED progressive_mark ] > ].

;;;
;;; something in the same spirit, for the `n+n_n+p+q+n_sg_mtr' type, et al.
;;;
sg_cf := monotonic_mtr &
[ INPUT.RELS < [ PRED "~_n_", LBL #h0 & h, ARG0 #x1 & x ],
               [ PRED sg_mark, LBL #h0, ARG0 #x1 ] >,
  OUTPUT.RELS < +copy+ & [ ARG0 [ PERS 3, NUM sg, GRIND - ] ] >,
  FLAGS.EQUAL < #h0, #x1 > ].

pl_cf := monotonic_mtr &
[ INPUT.RELS < [ PRED "~_n_", LBL #h0 & h, ARG0 #x1 & x ],
               [ PRED pl_mark, LBL #h0, ARG0 #x1 ] >,
  OUTPUT.RELS < +copy+ & [ ARG0 [ PERS 3, NUM pl, GRIND - ] ] >,
  FLAGS.EQUAL < #h0, #x1 > ].

number_mark_ditch_cf := elision_mtr &
[ INPUT.RELS < [ PRED number_mark ] > ].