; ;;; -*- Mode: TDL; Coding: utf-8 -*- 

; ;;; Author: 
; ;;; 2011 Berthold Crysmann

; ;;; Features not yet predicted by fixup rules:

; ;;; --zu luk

; ;;; --tpc

; ;;; ---psv (but see below)

; ;;; --cls semarg

; ;;; reentrant with ARG0 of highest verb in clause 
; ;;; percolate down from finite verbs

; ;;; finite predicates: do not set --cls: otherwise 
; ;;; problem with complement clauses
; ;;; non-finite predicates: --cls points to arg0 of finite pred
; ;;; clause-level dependents: --cls points to arg0 of finite pred

; ;;; Corresponding syntactic constraint: 
; ;;; structure-share --cls on UCOMPS list members

; ;;; 

; ;;; Expected efficiency: 
; ;;; - blocks sneaking in on skolemised finite preds 
; ;;; - blocks mixing of arguments from different clauses 
; ;;;   on semantically empty heads

; ;;; --sind p-n-g

; ;;; Modals 
; ;;; Raising 

; ;;; --oind semarg 
; ;;; subj-to-obj raising verbs (--sub -)
; ;;; experiencer raising verbs (--sub -)
; ;;; control verbs (--sub -)

; ;;; Assumptions about initial VPM values in input (performance features only):
; ;;; Most general types

; ;;; --coh: luk 
; ;;; --top: luk-or-undef
; ;;; --cas: *top* 
; ;;; --bnd: luk
; ;;; --punct: mess-punct
; ;;; --sub: luk




; ;;; Explicitly mark non-passives:




psv+_mark_rule := 
		  fully_monotonic_mtr & 
		  [INPUT.RELS <! [ARG0 #ev & event & [--PSV psv-]] !>,
		   CONTEXT.RELS <! [PRED parg_d_rel,
				    ARG1 #ev]!>,
		   OUTPUT.RELS <! +copy+ & [ARG0.--PSV  psv+] !> ].

psv-_mark_rule := 
 		 fully_monotonic_mtr & 
 		 [INPUT.RELS <! [ARG0 #ev & event & [--PSV #0 & psv]] !>,
		  FILTER.RELS <! [PRED parg_d_rel,
				  ARG1 #ev] !>, 
 		  FLAGS.EQUAL <#0>,
 		  OUTPUT.RELS <! +copy+ & [ARG0.--PSV  psv-] !> ].




		     
; ;;; Grammar-internally, personal and unpersonal passives are distinguished into ppsv and ipsv, 
; ;;; externally they are just --psv +.  



;;; Fix tense information on finite coordinate structures


fix_coord_tense_fin :=  
		    fully_monotonic_mtr & 
		    [INPUT.RELS <! [ARG0 #e & [E.TENSE none],
				    R-INDEX #ri ] !>,
		     FLAGS.SUBSUME <#ri>,
		     CONTEXT.RELS <! 
				   [ARG0 #ri & event &[E.TENSE finite] ] !>,
		     OUTPUT.RELS <! +copy+ & [ARG0.E.TENSE finite ] !> ].


;;; First set --top: --tpc depends on it
top_sel_prep_type_rule := 
		fully_monotonic_mtr & 
		[INPUT.RELS <! [ARG0 #i & [--TOP undef ]] !>,
		 CONTEXT.RELS <! 
			       [PRED topic-or-focus_d_rel,
				ARG2 #i ], 
			       [PRED prep-sel-rel,
				ARG0 #e,
				ARG2 #i] !>,
		 OUTPUT.RELS <! +copy+ & [ARG0.--TOP na] !> ].

top_sel_prep_rule := 
		fully_monotonic_mtr & 
		[INPUT.RELS <! [ARG0 #i & [--TOP undef ]] !>,
		 CONTEXT.RELS <! 
			       [PRED topic-or-focus_d_rel,
				LBL #h,
				ARG2 #i ], 
			       [PRED "~_p_sel_rel",
				ARG0 #e,
				ARG2 #i] !>,
		 OUTPUT.RELS <! +copy+ & [ARG0.--TOP na] !> ].

top-_sel_prep_rule := 
		fully_monotonic_mtr & 
		[INPUT.RELS <! [ARG0 #i & [--TOP undef ]] !>,
		 CONTEXT.RELS <! 
			       [PRED prep-sel-rel,
				ARG2 #i] !>,
		 FILTER.RELS <! [PRED topic-or-focus_d_rel,
				 ARG2 #i ] 
			      !>,
		 OUTPUT.RELS <! +copy+ & [ARG0.--TOP -] !> ].

		   
;;; Relative clauses


top_rel_rule := 
		fully_monotonic_mtr & 
		[INPUT.RELS <! [LBL #l,
				ARG0 ref-ind & [--TOP undef]] !>,
		 CONTEXT.RELS <! 
			       [PRED topic-or-focus_d_rel,
				LBL #l ] !>,
		 OUTPUT.RELS <! +copy+ & [ARG0.--TOP na] !> ].



top_coord_rel_rule := 
		      fully_monotonic_mtr &
		      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--TOP undef]] !>,
		       CONTEXT.RELS <! 
				     [PRED  topic-or-focus_d_rel,
				      ARG0 [E.TENSE real_tense],
				      ARG2 #0 ],
				     [PRED topic-or-focus_d_rel,
				      ARG0 [E.TENSE real_tense],
				      ARG2 #0 ] !>,
		       OUTPUT.RELS <! +copy+ & [ARG0.--TOP na] !> ].


; top+_h_rule := 
; 	     fully_monotonic_mtr & 
; 	     [INPUT.RELS <! [ARG0 event & #i & [--TOP undef]] !>,
; 	      CONTEXT.RELS <! [PRED message_m_rel,
; 			       ARG0 #i],
; 			    [PRED message_m_rel,
; 			     LBL #h,
; 			     TPC #i ] !>,
; 	      OUTPUT.RELS <! +copy+ & [ARG0.--TOP na] !> ].



top+_rule := 
	     fully_monotonic_mtr & 
	     [INPUT.RELS <! [ARG0 #i & individual & [--TOP undef]] !>,
	      CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
			       ARG2 #i ] !>,
	      FLAGS.SUBSUME <#i>,
	      OUTPUT.RELS <! +copy+ & [ARG0.--TOP +] !> ].

top-_rule := 
	     fully_monotonic_mtr & 
	     [INPUT.RELS <! [ARG0 #i & [--TOP undef],
			     LBL #l] !>,
	      OUTPUT.RELS <! +copy+ & [ARG0.--TOP -] !> ].



; ;;; arg1_equate_rule := fully_monotonic_mtr & 
; ;;; 		    [CONTEXT [RELS <! [PRED "~_rel",
; ;;; 				       LBL #l1,
; ;;; 				       ARG0 #e1 & event,
; ;;; 				       ARG1 #l2
; ;;; 					   ],
; ;;; 				    [LBL #l2 & handle,
; ;;; 				     ARG0 #e2 & [E.TENSE no_tense]]
; ;;; 				    !>],
; ;;; 		     FLAGS.SUBSUME <#l2>,
; ;;; 		     FILTER.RELS <! [PRED "coh_mark",
; ;;; 				     LBL #l1,
; ;;; 				     ARG0 #e1,
; ;;; 				     ARG1 #l2,
; ;;; 				     ARG2 #e2
; ;;; 					  ] !>,
; ;;; 		     OUTPUT.RELS  <! [PRED "coh_mark",
; ;;; 				      LBL #l1,
; ;;; 				      ARG0 #e1,
; ;;; 				      ARG1 #l2,
; ;;; 				      ARG2 #e2
; ;;; 					   ] !>].

; ;;; arg2_equate_rule := fully_monotonic_mtr & 
; ;;; 		    [CONTEXT [RELS <! [PRED "~_rel",
; ;;; 				       LBL #l1,
; ;;; 				       ARG0 #e1 & event,
; ;;; 				       ARG2 #l2
; ;;; 					   ],
; ;;; 				    [LBL #l2 & handle,
; ;;; 				     ARG0 #e2 & [E.TENSE no_tense]]
; ;;; 				    !>],
; ;;; 		     FLAGS.SUBSUME <#l2>,
; ;;; 		     FILTER.RELS <! [PRED "coh_mark",
; ;;; 				     LBL #l1,
; ;;; 				     ARG0 #e1,
; ;;; 				     ARG1 #l2,
; ;;; 				     ARG2 #e2
; ;;; 					  ] !>,
; ;;; 		     OUTPUT.RELS  <! [PRED "coh_mark",
; ;;; 				      LBL #l1,
; ;;; 				      ARG0 #e1,
; ;;; 				      ARG1 #l2,
; ;;; 				      ARG2 #e2
; ;;; 					   ] !>].

; ;;; arg3_equate_rule := fully_monotonic_mtr & 
; ;;; 		    [CONTEXT [RELS <! [PRED "~_rel",
; ;;; 				       LBL #l1,
; ;;; 				       ARG0 #e1 & event,
; ;;; 				       ARG3 #l2
; ;;; 					   ],
; ;;; 				    [LBL #l2 & handle,
; ;;; 				     ARG0 #e2 & [E.TENSE no_tense]]
; ;;; 				    !>],
; ;;; 		     FLAGS.SUBSUME <#l2>,
; ;;; 		     FILTER.RELS <! [PRED "coh_mark",
; ;;; 				     LBL #l1,
; ;;; 				     ARG0 #e1,
; ;;; 				     ARG1 #l2,
; ;;; 				     ARG2 #e2
; ;;; 					  ] !>,
; ;;; 		     OUTPUT.RELS  <! [PRED "coh_mark",
; ;;; 				      LBL #l1,
; ;;; 				      ARG0 #e1,
; ;;; 				      ARG1 #l2,
; ;;; 				      ARG2 #e2
; ;;; 					   ] !>].


; ;;; marg_equate_rule := fully_monotonic_mtr & 
; ;;; 		    [CONTEXT [RELS <! [PRED message_m_rel,
; ;;; 				       LBL #l1,
; ;;; 				       ARG0 #e1 & event,
; ;;; 				       MARG #l2
; ;;; 					   ],
; ;;; 				    [LBL #l2 & handle,
; ;;; 				     ARG0 #e2 & [E.TENSE no_tense]]
; ;;; 				    !>],
; ;;; 		     FLAGS.SUBSUME <#l2>,
; ;;; 		     FILTER.RELS <! [PRED "coh_mark",
; ;;; 				     LBL #l1,
; ;;; 				     ARG0 #e1,
; ;;; 				     ARG1 #l2,
; ;;; 				     ARG2 #e2
; ;;; 					  ] !>,
; ;;; 		     OUTPUT.RELS  <! [PRED "coh_mark",
; ;;; 				      LBL #l1,
; ;;; 				      ARG0 #e1,
; ;;; 				      ARG1 #l2,
; ;;; 				      ARG2 #e2
; ;;; 					   ] !>].

 
; ;;; coord_equate_l_rule := fully_monotonic_mtr & 
; ;;; 		       [CONTEXT [RELS <! [PRED "~_coord_rel",
; ;;; 					  LBL #l1,
; ;;; 					  ARG0 #e1 & event,
; ;;; 					  L-INDEX #e2,
; ;;; 					  L-HNDL #l2 & handle],
; ;;; 				       [LBL #l2 & handle]
; ;;; 				       !>],
; ;;; 			FLAGS.SUBSUME <#l2>,
; ;;; 			FILTER.RELS <! [PRED "coord_mark",
; ;;; 					LBL #l1,
; ;;; 					ARG0 #e1,
; ;;; 					ARG1 #l2,
; ;;; 					ARG2 #e2
; ;;; 					     ] !>,
; ;;; 			OUTPUT.RELS  <! [PRED "coord_mark",
; ;;; 					 LBL #l1,
; ;;; 					 ARG0 #e1,
; ;;; 					 ARG1 #l2,
; ;;; 					 ARG2 #e2
; ;;; 					      ] !>].

; ;;; coord_equate_r_rule := fully_monotonic_mtr & 
; ;;; 		  [CONTEXT [RELS <! [PRED "~_coord_rel",
; ;;; 				     LBL #l1,
; ;;; 				     ARG0 #e1 & event,
; ;;; 				     R-INDEX #e2,
; ;;; 				     R-HNDL #l2],
; ;;; 				  [LBL #l2 & handle]
; ;;; 				  !> ],
; ;;; 		   FLAGS.SUBSUME <#l2>,
; ;;; 		   FILTER.RELS <! [PRED "coord_mark",
; ;;; 				   LBL #l1,
; ;;; 				   ARG0 #e1,
; ;;; 				    ARG1 #l2,
; ;;; 				   ARG2 #e2
; ;;; 					] !>,
; ;;; 		   OUTPUT.RELS  <! [PRED "coord_mark",
; ;;; 				    LBL #l1,
; ;;; 				    ARG0 #e1,
; ;;; 				    ARG1 #l2,
; ;;; 				    ARG2 #e2
; ;;; 					 ] !>].

; ;;; ;;; Insert zu_mark
; ;;; ;;; Keep eq_mark
; ;;; ;;; Add coherence equivalence rels
; ;;; ;;; Insert cls_mark




; ;;; coord_eq_init_2 := fully_monotonic_mtr &
; ;;; 	   [INPUT.RELS <! [PRED "coord_mark",
; ;;; 			   LBL #l1,
; ;;; 			   ARG0 #e1,
; ;;; 			   ARG1 #l2,
; ;;; 			   ARG2 #e2],
; ;;; 			[PRED "coord_mark",
; ;;; 			 LBL #l1,
; ;;; 			 ARG0 #e1,
; ;;; 			 ARG1 #l3,
; ;;; 			 ARG2 #e3] !>,
; ;;; 	    FILTER.RELS <! [PRED "~coord_mark",
; ;;; 			    ARG1 #l1,
; ;;; 			    ARG2 #e1]
; ;;; 			 !>,
; ;;; 	    OUTPUT.RELS  <!
; ;;; 			  [PRED "top_coord_mark",
; ;;; 			   LBL #l1,
; ;;; 			   ARG0 #e1,
; ;;; 			   ARG1 #l2,
; ;;; 			   ARG2 #e2],
; ;;; 			[PRED "top_coord_mark",
; ;;; 			 LBL #l1,
; ;;; 			 ARG0 #e1,
; ;;; 			 ARG1 #l3,
; ;;; 			 ARG2 #e3],
; ;;; 			  [PRED "coord_eq_mark",
; ;;; 			   ARG0 #0 & event,
; ;;; 			   LBL #l1,
; ;;; 			   ARG1 #e1]
; ;;; 			  !>].

; ;;; ;;; Catch case where one conjunct is not instantiated
; ;;; coord_eq_init_1 := fully_monotonic_mtr &
; ;;; 	   [INPUT.RELS <! [PRED "coord_mark",
; ;;; 			     LBL #l1,
; ;;; 			     ARG0 #e1,
; ;;; 			     ARG1 #l2,
; ;;; 			     ARG2 #e2]
; ;;; 			  !>,
; ;;; 	    FILTER.RELS <! [PRED "~coord_mark",
; ;;; 			    ARG1 #l1,
; ;;; 			    ARG2 #e1]
; ;;; 			 !>,
; ;;; 	    OUTPUT.RELS  <!
; ;;; 			  [PRED "top_coord_mark",
; ;;; 			     LBL #l1,
; ;;; 			     ARG0 #e1,
; ;;; 			     ARG1 #l2,
; ;;; 			     ARG2 #e2],
; ;;; 			  [PRED "coord_eq_mark",
; ;;; 			   ARG0 #0 & event,
; ;;; 			   LBL #l1,
; ;;; 			   ARG1 #e1]
; ;;; 			  !>].
	       

; ;;; coord_eq_recurse := fully_monotonic_mtr &
; ;;;  		  [FILTER.RELS <! [PRED "coord_eq_mark",
; ;;;  				    ARG0 #0,
; ;;;  				    LBL #l2 ,
; ;;;  				    ARG1 #e2] !>,
; ;;;  		   CONTEXT.RELS <! [PRED "~coord_mark",
; ;;; 				    LBL #l1,
; ;;; 				    ARG0 #e1,
; ;;; 				    ARG1 #l2,
; ;;; 				    ARG2 #e2],
; ;;; 				 [PRED "coord_eq_mark",
; ;;;  				    ARG0 #0 & event,
; ;;;  				    LBL #l1,
; ;;;  				    ARG1 #e1]
; ;;;  				   !>,
; ;;;  		   OUTPUT.RELS  <! [PRED "coord_eq_mark",
; ;;;  				    ARG0 #0,
; ;;;  				    LBL #l2,
; ;;;  				    ARG1 #e2] !>].
 

; ;;; ;;; 


; ;;; ;;; Catch case where there might be two top relations in coiherence chain
; ;;; coh_eq_init_2 := fully_monotonic_mtr &
; ;;; 		 [INPUT.RELS <! [PRED "~^(top_coord|coh)_mark",
; ;;; 				 LBL #l1,
; ;;; 				 ARG0 #e1,
; ;;; 				 ARG1 #l2,
; ;;; 				 ARG2 #e2],
; ;;; 			      [PRED "~^(top_coord|coh)_mark",
; ;;; 			       LBL #l1,
; ;;; 			       ARG0 #e1,
; ;;; 			       ARG1 #l3,
; ;;; 			       ARG2 #e3] !>,
; ;;; 		  FILTER.RELS <! [PRED "~(coord|coh)_mark",
; ;;; 				  ARG1 #l1,
; ;;; 				  ARG2 #e1]
; ;;; 			       !>,
; ;;; 		  OUTPUT.RELS  <!
; ;;; 				[PRED "top_coh_mark",
; ;;; 				 LBL #l1,
; ;;; 				 ARG0 #e1,
; ;;; 				 ARG1 #l2,
; ;;; 				 ARG2 #e2],
; ;;; 				[PRED "top_coh_mark",
; ;;; 				 LBL #l1,
; ;;; 				 ARG0 #e1,
; ;;; 				 ARG1 #l3,
; ;;; 				 ARG2 #e3],
; ;;; 				[PRED "coh_eq_mark",
; ;;; 				 ARG0 #0 & event,
; ;;; 				 LBL #l1,
; ;;; 				 ARG1 #e1]
; ;;; 				!>].

; ;;; ;;; Catch default case with only 1 top relation
; ;;; coh_eq_init_1 := fully_monotonic_mtr &
; ;;; 		 [INPUT.RELS <! [PRED "~^(top_coord|coh)_mark$",
; ;;; 				 LBL #l1,
; ;;; 				 ARG0 #e1,
; ;;; 				 ARG1 #l2,
; ;;; 				 ARG2 #e2]
; ;;; 			      !>,
; ;;; 		  FILTER.RELS <! [PRED "~(coord|coh)_mark",
; ;;; 				  ARG1 #l1,
; ;;; 				  ARG2 #e1]
; ;;; 			       !>,
; ;;; 		  OUTPUT.RELS  <!
; ;;; 				[PRED "top_coh_mark",
; ;;; 				 LBL #l1,
; ;;; 				 ARG0 #e1,
; ;;; 				 ARG1 #l2,
; ;;; 				 ARG2 #e2],
; ;;; 				[PRED "coh_eq_mark",
; ;;; 				 ARG0 #0 & event,
; ;;; 				 LBL #l1,
; ;;; 				 ARG1 #e1]
; ;;; 				!>].


; ;;; coh_eq_recurse := fully_monotonic_mtr &
; ;;; 		  [FILTER.RELS <! [PRED "coh_eq_mark",
; ;;; 				   ARG0 #0,
; ;;; 				   LBL #l2,
; ;;; 				   ARG1 #e2] !>,
; ;;;  		   CONTEXT.RELS <! [PRED "~(coord|coh)_mark$",
; ;;; 				    LBL #l1,
; ;;; 				    ARG0 #e1,
; ;;; 				    ARG1 #l2,
; ;;; 				    ARG2 #e2],
; ;;; 				 [PRED "coh_eq_mark",
; ;;;  				    ARG0 #0 & event,
; ;;;  				    LBL #l1,
; ;;;  				    ARG1 #e1]
; ;;;  				   !>,
; ;;;  		   OUTPUT.RELS  <! [PRED "coh_eq_mark",
; ;;;  				    ARG0 #0,
; ;;;  				    LBL #l2,
; ;;;  				    ARG1 #e2] !>].


; ;;; coord_or_coh_mark_del := 
; ;;; 			 fully_monotonic_mtr &
; ;;; 			 [INPUT.RELS <! [PRED "~(coord|coh)_mark$" ] !>].



; ;;; --tpc

; ;;; Rule order

; ;;; 0. set tpc-non-event-non-mod from --TOP + 
; ;;;    (hopefully contains scopal mods a bit)
; ;;; 1. tpc-isect
; ;;; 2. tcp-event 
; ;;; 3. tpc-scop
; ;;; 4. Default: tpc-non-event-non-mod 

; ;;; Expected efficency: 
; ;;; Controls introduction of PVP 
; ;;; Partially controls intersective modifiers    
; ;;; Partially controls scopal modifiers 
   
; ;;; Relegates argument extraction to --top feature   

; ;;; How to set tpc-isect when attached to scopal mod?
; ;;; Need equivalence marks (recurse over scopal mods)


; ; isect_equiv := fully_monotonic_mtr &
; ; 	       [CONTEXT.RELS <! 
; ; 			      [PRED "~_rel",
; ; 			       ARG0 #e0 & event  & [E.TENSE none],
; ; 			       LBL #h0,
; ; 			       ARG1 #e1 & event],
; ; 			      [PRED "~_[avp]_",
; ; 			       ARG0 #e1,
; ; 			       LBL #h0] 
; ; 			      !>,
; ; 		FLAGS.SUBSUME <#e1>,
; ; 		FILTER.RELS <! [PRED "mod_mark",
; ; 			       ARG0 #e0,
; ; 				LBL #h0,
; ; 				ARG1 #e1 ] !>,
; ; 		OUTPUT.RELS <! [PRED "mod_mark",
; ; 				ARG0 #e0,
; ; 				LBL #h0,
; ; 				ARG1 #e1 ] !> ].




; scop_equiv := fully_monotonic_mtr &
; 	      [CONTEXT.RELS <! 
; 			     [PRED "~_rel",
; 			      ARG0 #e0 & event & [E.TENSE none],
; 			      LBL #h0,
; 			      ARG1 #h1 & handle],
; 			     [PRED "~_[avp]_",
; 			      ARG0 #e1 & event,
; 			      LBL #h1] 
; 			     !>,
; 	       FLAGS.SUBSUME <#h1>,
; 	       FILTER.RELS <! [PRED "mod_mark",
; 			       ARG0 #e0,
; 			       LBL #h0,
; 			       ARG1 #e1 ] !>,
; 	       OUTPUT.RELS <! [PRED "mod_mark",
; 			       ARG0 #e0,
; 			       LBL #h0,
; 			       ARG1 #e1 ] !>].



; tpc_equiv_ini := fully_monotonic_mtr &
; 		 [CONTEXT.RELS <! 
; 				[LBL #l & handle,
; 				 PRED "~_([vap]|coord)_",
; 				 ARG0 #e & 
; 				     event & 
; 				     [E.TENSE real_tense,
; 				      --TPC tpc-undef]] !>,
; 		  FLAGS.SUBSUME <#l,#e>,
; 		  FILTER.RELS <! [PRED "scop_eq_mark",
; 				  LBL #l,
; 				  ARG1 #e] !>,
; 		  OUTPUT.RELS <! [PRED "scop_eq_mark",
; 				  LBL #l,
; 				  ARG0 #e,
; 				  ARG1 #e] !> ].

; tpc_equiv_recurse := fully_monotonic_mtr &
; 		     [INPUT.RELS <! [PRED "mod_mark",
; 				     LBL #h1,
; 				     ARG0 #e1,
; 				     ARG1 #e0
; 					  ] !>,
; 		      CONTEXT.RELS <! [PRED "scop_eq_mark",
; 				       LBL #h0,
; 				       ARG1 #e0,
; 				       ARG0 #e] !>,
; 		      FLAGS.SUBSUME <#e0,#e1>,
; 		      FILTER.RELS <! [PRED "scop_eq_mark",
; 				      LBL #h1,
; 				      ARG1 #e1] !>,
; 		      OUTPUT.RELS <! [PRED "scop_eq_mark",
; 				      LBL #h1,
; 				      ARG0 #e,
; 				      ARG1 #e1] !> ].

; mod_mark_del := fully_monotonic_mtr &
; 		[INPUT.RELS <! [PRED "mod_mark"] !>].
		 
; isect_tpc_rule :=  fully_monotonic_mtr &
; 		   [INPUT.RELS <! [PRED "scop_eq_mark",
; 				   LBL #l,
; 				   ARG1 #e1, 
; 				   ARG0 event & 
; 					[--TPC tpc-undef]] !>,
; 		    FLAGS.SUBSUME <#l,#e0,#e1>,
; 		    CONTEXT.RELS <! [PRED topic-or-focus_d_rel, 
; 				     ARG2 #e0 ],
; 				  [ARG0 #e0 & event, 
; 				   ARG1 #e1 & event, 
; 				   LBL #l & handle],
; 				  [LBL #l,
; 				   ARG0 #e1 ] !>,
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC tpc-isect] !>].




; scop_tpc_rule :=  fully_monotonic_mtr &
; 		   [INPUT.RELS <! [PRED "scop_eq_mark",
; 				   LBL #l,
; 				   ARG1 #e1, 
; 				   ARG0 event & 
; 					[--TPC tpc-undef]] !>,
; 		    FLAGS.SUBSUME <#l,#e0,#e1>,
; 		    CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 				     ARG2 #e0 ],
; 				  [ARG0 #e0 & event, 
; 				   ARG1 #l & handle,
; 				   LBL handle ],
; 				  [LBL #l,
; 				   ARG0 #e1 ] !>,
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC tpc-scop] !>].

; 2nd_isect_tpc_rule :=  fully_monotonic_mtr &
; 		   [INPUT.RELS <! [PRED "scop_eq_mark",
; 				   LBL #l,
; 				   ARG1 #e1, 
; 				   ARG0 event & 
; 					[--TPC tpc-undef]] !>,
; 		    FLAGS.SUBSUME <#l,#e0,#e1>,
; 		    CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 				     ARG2 #e0 ],
; 				  [ARG0 #e0 & event, 
; 				   ARG1 event & [--bnd -], 
; 				   LBL #l & handle],
; 				  [PRED "~_[vap]_",
; 				   LBL #l,
; 				   ARG0 #e1 & [E.TENSE real_tense]] !>,
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC tpc-isect] !>].


; ;;; 

; topic_cop_aux_pvp_rule := fully_monotonic_mtr &
; 		    [INPUT.RELS <! [ARG1 #e,
;  				    PRED #p & topic-or-focus_d_rel,
;  				    ARG2 #e & 
;  					 event & 
;  					 [--TPC tpc-undef]] !>,
;  		     FLAGS.SUBSUME <#e.#p>,
;  		     CONTEXT.RELS <! [PRED "~_[va]_",
;  				      ARG0 #e ]
;  				   !>,
; 		     OUTPUT.RELS <! +copy+ & [PRED #p, 
; 					      ARG1.--TPC tpc-event] !>].


; pvp_arg1_tpc_rule := fully_monotonic_mtr &
; 		     [INPUT.RELS <! [PRED "scop_eq_mark",
; 				     LBL #h1,
; 				     ARG0 #e1 & event & [--TPC tpc-undef]] !>,
; 		      FLAGS.SUBSUME <#e0,#h0>, 
; 		      CONTEXT.RELS <! 
; 				    [PRED topic-or-focus_d_rel,
; 				     ARG2 #e0 ],
; 				    [PRED "~(_[va]|coord)_",
; 				     ARG0 #e0 & event & [E.TENSE no_tense]],
; 				    [PRED "~_[va]_",
; 				     LBL #h1,
; 				     ARG0 #e1 & event & [E.TENSE real_tense],
; 				     ARG1 #h0 & handle],
; 				    [PRED "~(scop_eq_mark|prpstn_m_rel)",
; 				     LBL #h0,
; 				     ARG0 #e0 ] 
; 				    !>,
; 		      OUTPUT.RELS <! +copy+ & [ARG0.--TPC tpc-non-mod] !>].


; pvp_arg2_tpc_rule := fully_monotonic_mtr &
; 		     [INPUT.RELS <! [PRED "scop_eq_mark",
; 				     LBL #h1,
; 				     ARG0 #e1 & event & [--TPC tpc-undef]] !>,
; 		      FLAGS.SUBSUME <#h1,#e0,#h0>, 
; 		      CONTEXT.RELS <! 
; 				    [PRED topic-or-focus_d_rel,
; 				     ARG2 #e0 ],
; 				    [PRED "~(_[va]|coord)_",
; 				     ARG0 #e0 & event & [E.TENSE no_tense]],
; 				    [PRED "~_[va]_",
; 				     LBL #h1,
; 				     ARG0 #e1 & event & [E.TENSE real_tense],
; 				     ARG2 #h0 & handle],
; 				    [PRED "~(scop_eq_mark)",
; 				     LBL #h0,
; 				     ARG0 #e0 ] 
; 				    !>,
; 		      OUTPUT.RELS <! +copy+ & [ARG0.--TPC tpc-non-mod] !>].

; pvp_arg3_tpc_rule := fully_monotonic_mtr &
; 		     [INPUT.RELS <! [PRED "scop_eq_mark",
; 				     LBL #h1,
; 				     ARG0 #e1 & event & [--TPC tpc-undef]] !>,
; 		      FLAGS.SUBSUME <#h1,#e0,#h0>, 
; 		      CONTEXT.RELS <! 
; 				    [PRED topic-or-focus_d_rel,
; 				     ARG2 #e0 ],
; 				    [PRED "~(_[va]|coord)_",
; 				     ARG0 #e0 & event & [E.TENSE no_tense]],
; 				    [PRED "~_[va]_",
; 				     LBL #h1,
; 				     ARG0 #e1 & event & [E.TENSE real_tense],
; 				     ARG3 #h0 & handle],
; 				    [PRED "~(scop_eq_mark)",
; 				     LBL #h0,
; 				     ARG0 #e0 ] 
; 				    !>,
; 		      OUTPUT.RELS <! +copy+ & [ARG0.--TPC tpc-non-mod] !>].



; isect_default_tpc_rule :=  fully_monotonic_mtr &
; 			   [INPUT.RELS <! [ARG0 event & 
; 						[E.TENSE real_tense,
; 						 --TPC tpc-undef]] !>,
; 			    FLAGS.SUBSUME <#e0,#e1>,
; 			    CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					     ARG2 #e0 & event ],
; 					  [PRED "~_[ap]_.*rel",
; 					   ARG0 #e0,
; 					   ARG1 #e1 & event],
; 					  [PRED "~_rel",
; 					   ARG0 #e1]
; 				  !>, 
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC  tpc-non-event] !>].

; scop_default_tpc_rule :=  fully_monotonic_mtr &
; 		   [INPUT.RELS <! [ARG0 event & 
; 					[E.TENSE real_tense,
; 					 --TPC tpc-undef]] !>,
; 		    FLAGS.SUBSUME <#e0,#h1>,
; 		    CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 				     ARG2 #e0],
; 				  [ARG0 #e0 & event,
; 				   ARG1 #h1 & handle],
; 				  [LBL #h1]
; 				  !>, 
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC  tpc-non-event] !>].



; coord_rule :=  fully_monotonic_mtr &
; 		   [INPUT.RELS <! [ARG0 event & 
; 					[E.TENSE real_tense,
; 					 --TPC tpc-undef]] !>,
; 		    CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 				     ARG2 #e],
; 				  [ARG0 #e & event,
; 				   L-INDEX #e0],
; 				  [ARG0 #e0]
; 				  !>, 
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC  tpc-def] !>].




; ; default_tpc_rule :=  fully_monotonic_mtr &
; ; 		   [INPUT.RELS <! [ARG0 event & 
; ; 				       [E.TENSE real_tense,
; ; 					--TPC tpc-undef]] !>,
; ; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC  tpc-non-event-non-mod] !>].


; default_-tpc_rule :=  fully_monotonic_mtr &
; 		   [INPUT.RELS <! [ARG0 event & 
; 					[E.TENSE real_tense,
; 					 --TPC tpc-undef]] !>,
; 		    OUTPUT.RELS <! +copy+ & [ARG0.--TPC  tpc-non-event] !>].



; ;;; --OIND
; ;;; Need to insert coordination equivalence marks (only for full approach) 
; ;;; Partial solution possible without.


; ;;; set to --OIND.--BND - on finites





; coord_or_coh_eq_mark_del := 
; 			 fully_monotonic_mtr &
; 			 [INPUT.RELS <! [PRED "~(coord|coh)_eq_mark$" ] !>].

			 
; ;;; --zu and --tpc operate on coord_eq_mark
; ;;; --cls operates on coh_eq_mark
; ;;; What about --coh ???



; ;;; --sub

; ;;; Mark all verbs and coordinatons of verbs with sub_mark

; ;;; New regime:

; ;;; Set --sub on finite verbs (+/-/bool)
; ;;; Set on non-finite verbs/coordination in verb movement contexts
; ;;; Default for remaining verbs/coord



; ; sub_v_a := fully_monotonic_mtr &
; ; 	   [CONTEXT.RELS <! [PRED "~(_[va]_|coord_)",
; ; 			     LBL #l,
; ; 			     ARG0 #e & [E.TENSE real_tense]] !>,
; ; 	    FILTER.RELS <! [PRED "sub_mark",
; ; 			    LBL #l,
; ; 			    ARG1 #e]
; ; 			 !>,
; ; 	    OUTPUT.RELS  <! [PRED "sub_mark",
; ; 			     ARG0 event & [--SUB na],
; ; 			     LBL #l,
; ; 			     ARG1 #e]
; ; 			  !>].



; ; sub+_rel_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #h] !>, 
; ; 		  CONTEXT.RELS <!
; ; 				[LBL #h,
; ; 				 ARG0 ref-ind],
; ; 				[PRED message_m_rel,
; ; 				 LBL #h,
; ; 				 ARG0 #e]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].


; ; sub-_v1_subord_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <!
; ; 				 [PRED "~implicit_wenn_x_rel",
; ; 				  ARG2 #h & handle],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e],
; ; 				 [PRED "~(_[av]|coord)_",
; ; 				  LBL #l,
; ; 				  ARG0 #e]
; ; 				 !>],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].

; ; sub+_subord_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <!
; ; 				 [PRED "~_x_sub_rel",
; ; 				  ARG2 #h & handle],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e],
; ; 				 [PRED "~(_[av]|coord)_",
; ; 				  LBL #l,
; ; 				  ARG0 #e]
; ; 				 !>],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].




; ; ;;; Restricted to embedded wh-questions


; ; sub+_wh_arg1_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT.RELS <!
; ; 				[ARG0 #0],
; ; 				[PRED int_m_rel,
; ; 				 LBL #h,
; ; 				 TPC #0 & individual,
; ; 				 ARG0 #e],
; ; 				[ARG1 #h & handle ]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_wh_arg2_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT.RELS <!
; ; 				[ARG0 #0],
; ; 				[PRED #pred & int_m_rel,
; ; 				 LBL #h,
; ; 				 TPC #0 & individual,
; ; 				 ARG0 #e],
; ; 				[ARG2 #h & handle ]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_wh_arg3_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT.RELS <!
; ; 				[ARG0 #0],
; ; 				[PRED #pred &  int_m_rel,
; ; 				 LBL #h,
; ; 				 TPC #0 & individual,
; ; 				 ARG0 #e],
; ; 				[ARG3 #h & handle ]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].


; ; sub+_rel_disloc_tpc_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT.RELS <!
; ; 				[PRED prpstn_m_rel,
; ; 				 LBL #h,
; ; 				 TPC #0,
; ; 				 ARG0 #e],
; ; 				[LBL #h,
; ; 				 ARG0 #0]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_rel_tpc_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT.RELS <!
; ; 				[LBL #h],
; ; 				[PRED prpstn_m_rel,
; ; 				 LBL #h,
; ; 				 TPC #0,
; ; 				 ARG0 #e],
; ; 				[ARG0 #0]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].



; ; sub+_lindex_rel_rule := 
; ; 			     fully_monotonic_mtr &
; ; 			     [INPUT.RELS <! [PRED "sub_mark",
; ; 					     ARG0 [--SUB na],
; ; 					     ARG1 #e,
; ; 					     LBL #l] !>,
; ; 			      CONTEXT.RELS <! [LBL #h,
; ; 					       ARG0 #0 & ref-ind & [--TOP na]],
; ; 					    [PRED "~coord_.*rel",
; ; 					     LBL #h,
; ; 					     L-INDEX #e],
; ; 					    [PRED message_m_rel,
; ; 					     ARG0 #e & [E.TENSE real_tense]] !>,
; ; 			      OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_rindex_rel_rule := 
; ; 			     fully_monotonic_mtr &
; ; 			     [INPUT.RELS <! [PRED "sub_mark",
; ; 					     ARG0 [--SUB na],
; ; 					     ARG1 #e,
; ; 					     LBL #l] !>,
; ; 			      CONTEXT.RELS <! [LBL #h,
; ; 					       ARG0 #0 & ref-ind & [--TOP na]],
; ; 					    [PRED "~coord_.*rel",
; ; 					     LBL #h,
; ; 					     R-INDEX #e],
; ; 					    [PRED message_m_rel,
; ; 					     ARG0 #e & [E.TENSE real_tense]] !>,
; ; 			      OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub-_tpc_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <>,
; ; 		  CONTEXT.RELS <!
; ; 				[ARG0 #0],
; ; 				[PRED prpstn_m_rel,
; ; 				 TPC #0 & individual,
; ; 				 ARG0 #e]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].

; ; sub-_imp_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  CONTEXT.RELS <!
; ; 				[PRED imp_m_rel,
; ; 				 ARG0 #e]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].





; ; sub_+_del_rule_1 :=
; ; 	       fully_monotonic_mtr & 
; ; 	       [INPUT.RELS <! [ARG0 #e,
; ; 			       LBL #l],
; ; 			    [PRED "sub_mark",
; ; 			     ARG0.--SUB + & #0,
; ; 			     ARG1 #e,
; ; 			     LBL #l] !>,
; ; 		FLAGS.SUBSUME <#0>,
; ; 		OUTPUT.RELS <! +copy+ & [ARG0.--SUB +]!>].


; ; sub_-_del_rule_1 :=
; ; 		  fully_monotonic_mtr & 
; ; 		  [INPUT.RELS <! [ARG0 #e,
; ; 				  LBL #l],
; ; 			       [PRED "sub_mark",
; ; 				ARG0.--SUB - & #0,
; ; 				ARG1 #e,
; ; 				LBL #l] !>,
; ; 		   FLAGS.SUBSUME <#0>,
; ; 		   OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].

; ; #|
; ; sub-_arg1_coord_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    LBL #l1,
; ; 					    ARG0 #e1 & [E [TENSE present+past,
; ; 							   PERFECTIVE -],
; ; 							--PSV psv-],
; ; 					    ARG1 handle & #l],
; ; 					 [PRED "sub_mark", 
; ; 					  ARG0 [--SUB -],
; ; 					  ARG1 #e1,
; ; 					  LBL #l1],
; ; 					 [PRED "~coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!>,
; ; 				   HCONS <!  !> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB -] !> ].

; ; sub-_arg1_coord_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG1 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #marg
; ; 				       ],
; ; 				 [PRED "~coord_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].

; ; sub+_part_arg1_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 #e0 & [E [TENSE present+past,
; ; 						     PERFECTIVE -],
; ; 						  --PSV psv-],
; ; 					    LBL #h,
; ; 					    ARG1 handle & #l],
; ; 					 [PRED "~_x_sel_rel",
; ; 					  LBL #h, 
; ; 					  ARG1 #e0],
; ; 					 [PRED "~(_[va]_|coord_)",
; ; 					  ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					  LBL #l]
; ; 					 !> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].

; ; sub-_arg1_nomsg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [E [TENSE present+past,
; ; 						     PERFECTIVE -],
; ; 						  --PSV psv-,
; ; 						  --SUB -],
; ; 					    ARG1 handle & #l],
; ; 					 [PRED "~(_[va]_|coord_)",
; ; 					  ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					  LBL #l]
; ; 					 !> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB -] !> ].



; ; sub-_arg1_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG1 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~(_[va]|coord)_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].

; ; sub-_arg2_coord_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [E [TENSE present+past,
; ; 							   PERFECTIVE -],
; ; 							--PSV psv-,
; ; 							--SUB -],
; ; 					    ARG2 handle & #l],
; ; 					 [PRED "~coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB -] !> ].

; ; sub-_arg2_coord_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG2 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l],
; ; 				 [PRED "~coord_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !>],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].


; ; ;;; Add negative regexp on predicates
; ; sub-_arg2_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  CONTEXT [RELS <! 
; ; 					 [PRED "~_(?!(hören|sehen|scheinen|anfangen|lassen))_v_",
; ; 					  ARG0 [E [TENSE present+past,
; ; 						   PERFECTIVE -],
; ; 						--PSV psv-,
; ; 						--SUB -],
; ; 					  ARG2 handle & #l],
; ; 					 [PRED "~_v_|_a_|coord_",
; ; 					  ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					  LBL #l]
; ; 					 !> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB -] !> ].

; ; sub+_part_arg2_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_x_sel_rel",
; ; 				  LBL #l1,
; ; 				  ARG1 #e1],
; ; 				 [PRED "~_v_",
; ; 				    LBL #l1,
; ; 				    ARG0 #e1 & [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG2 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~_[va]_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !>  ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub-_arg2_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  FILTER.RELS <! [PRED "~_x_sel_rel",
; ; 				  LBL #l1,
; ; 				  ARG1 #e1] !>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    LBL #l1,
; ; 				    ARG0 #e1 & [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG2 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~_[va]_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !>  ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].



; ; sub-_arg3_coord_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [E [TENSE present+past,
; ; 							   PERFECTIVE -],
; ; 							--PSV psv-,
; ; 							--SUB -],
; ; 					    ARG3 handle & #l],
; ; 					 [PRED "~coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!>],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB -] !> ].

; ; sub-_arg3_coord_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG3 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~coord_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].


; ; sub-_arg3_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [E [TENSE present+past,
; ; 							   PERFECTIVE -],
; ; 						  --PSV psv-,
; ; 						  --SUB -],
; ; 					    ARG3 handle & #l],
; ; 					 [PRED "~_[va]_|coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB -] !> ].


; ; sub-_arg3_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [E [TENSE present+past,
; ; 					     PERFECTIVE -],
; ; 					  --PSV psv-,
; ; 					  --SUB -],
; ; 				    ARG3 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~(_[va]|coord)_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].


; ; ; sub+_non-fin_rule := 
; ; ; 		     fully_monotonic_mtr & 
; ; ; 		     [INPUT.RELS <! [PRED "sub_mark",
; ; ; 				     ARG0 [--SUB na],
; ; ; 				     ARG1 #e,
; ; ; 				     LBL #l] !>,
; ; ; 		      CONTEXT.RELS <! [PRED "~(_[va]_|coord_)",
; ; ; 				       ARG0 #e & [E.TENSE no_tense],
; ; ; 				       LBL #l]
; ; ; 				    !>,
; ; ; 		      OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].



; ; sub+_arg1_coord_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    LBL #l1,
; ; 					    ARG0 [--SUB +],
; ; 					    ARG1 handle & #l],
; ; 					 [PRED "~coord_",
; ; 					  ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					  LBL #l]
; ; 					!>,
; ; 				   HCONS <!  !> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].

; ; sub+_arg1_coord_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [--SUB +],
; ; 				    ARG1 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #marg
; ; 				       ],
; ; 				 [PRED "~coord_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_arg1_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [--SUB +],
; ; 					    ARG1 handle & #l],
; ; 					 [PRED "~(_[va]_|coord_)",
; ; 					  ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					  LBL #l]
; ; 					 !> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].


; ; sub+_arg1_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [--SUB +],
; ; 				    ARG1 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~(_[va]|coord)_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_arg2_coord_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [--SUB +],
; ; 					    ARG2 handle & #l],
; ; 					 [PRED "~coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].

; ; sub+_arg2_coord_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [--SUB +],
; ; 				    ARG2 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l],
; ; 				 [PRED "~coord_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !>],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_arg2_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  CONTEXT [RELS <! 
; ; 					 [PRED "~_v_",
; ; 					  ARG0 [--SUB +],
; ; 					  ARG2 handle & #l],
; ; 					 [PRED "~_v_|_a_|coord_",
; ; 					  ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					  LBL #l]
; ; 					!> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].


; ; sub+_arg2_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [--SUB +],
; ; 				    ARG2 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~_[va]_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !>  ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_arg3_coord_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [--SUB +],
; ; 					    ARG3 handle & #l],
; ; 					 [PRED "~coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!>],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].

; ; sub+_arg3_coord_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [--SUB +],
; ; 				    ARG3 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~coord_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].


; ; sub+_arg3_no_msg_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e,
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#l>,
; ; 			  CONTEXT [RELS <! [PRED "~_v_",
; ; 					    ARG0 [--SUB +],
; ; 					    ARG3 handle & #l],
; ; 					 [PRED "~_[va]_|coord_",
; ; 					 ARG0 #e & [E.TENSE none_or_no_tense],
; ; 					 LBL #l]
; ; 					!> ],
; ; 			  OUTPUT.RELS <! +copy+ & 
; ; 				       [ARG0.--SUB +] !> ].


; ; sub+_arg3_msg_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		 [INPUT.RELS <! [PRED "sub_mark",
; ; 				 ARG0 [--SUB na],
; ; 				 ARG1 #e,
; ; 				 LBL #l] !>, 
; ; 		  FLAGS.SUBSUME <#h>,
; ; 		  CONTEXT [RELS <! [PRED "~_v_",
; ; 				    ARG0 [--SUB +],
; ; 				    ARG3 handle & #h],
; ; 				 [PRED message_m_rel,
; ; 				  LBL #h,
; ; 				  ARG0 #e,
; ; 				  MARG #l
; ; 				       ],
; ; 				 [PRED "~(_[va]|coord)_",
; ; 				  ARG0 #e & [E.TENSE no_tense],
; ; 				  LBL #l]
; ; 				 !> ],
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].


; ; sub+_no_tpc_arg1_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		    [INPUT.RELS <! [PRED "sub_mark",
; ; 				    ARG0 [--SUB na],
; ; 				    ARG1 #e & [E.TENSE finite],
; ; 				    LBL #l] !>, 
; ; 		     FLAGS.SUBSUME <#h>,
; ; 		     CONTEXT.RELS <!
; ; 				   [ARG1 #h & handle],
; ; 				   [PRED prpstn_m_rel,
; ; 				    LBL #h,
; ; 				    TPC anti,
; ; 				    ARG0 #e]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].

; ; sub+_no_tpc_arg2_rule := 
; ; 		 fully_monotonic_mtr & 
; ; 		    [INPUT.RELS <! [PRED "sub_mark",
; ; 				    ARG0 [--SUB na],
; ; 				    ARG1 #e & [E.TENSE finite],
; ; 				    LBL #l] !>, 
; ; 		     FLAGS.SUBSUME <#h>,
; ; 		     CONTEXT.RELS <!
; ; 				   [ARG2 #h & handle],
; ; 				   [PRED prpstn_m_rel,
; ; 				    LBL #h,
; ; 				    TPC anti,
; ; 				    ARG0 #e]
; ; 				!>,
; ; 		  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].



; ; sub+_no_tpc_arg3_rule := 
; ; 			 fully_monotonic_mtr & 
; ; 			 [INPUT.RELS <! [PRED "sub_mark",
; ; 					 ARG0 [--SUB na],
; ; 					 ARG1 #e & [E.TENSE finite],
; ; 					 LBL #l] !>, 
; ; 			  FLAGS.SUBSUME <#h>,
; ; 			  CONTEXT.RELS <!
; ; 					[ARG3 #h & handle],
; ; 					[PRED prpstn_m_rel,
; ; 					 LBL #h,
; ; 					 TPC anti,
; ; 					 ARG0 #e]
; ; 					!>,
; ; 			  OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !> ].
; ; |#
		      
; ; sub_na_del_rule :=
; ; 		  fully_monotonic_mtr & 
; ; 		  [INPUT.RELS <! [ARG0 #e,
; ; 				  LBL #l],
; ; 			       [PRED "sub_mark",
; ; 				ARG0.--SUB na & #0,
; ; 				ARG1 #e,
; ; 				LBL #l] !>,
; ; 		   FLAGS.SUBSUME <#0>,
; ; 		   OUTPUT.RELS <! +copy+ & [ARG0.--SUB bool] !> ].

; ; #|
; ; sub_+_del_rule_2 :=
; ; 	       fully_monotonic_mtr & 
; ; 	       [INPUT.RELS <! [ARG0 #e,
; ; 			       LBL #l],
; ; 			    [PRED "sub_mark",
; ; 			     ARG0.--SUB + & #0,
; ; 			     ARG1 #e,
; ; 			     LBL #l] !>,
; ; 		FLAGS.SUBSUME <#0>,
; ; 		OUTPUT.RELS <! +copy+ & [ARG0.--SUB +] !>].


; ; sub_-_del_rule_2 :=
; ; 		  fully_monotonic_mtr & 
; ; 		  [INPUT.RELS <! [ARG0 #e,
; ; 				  LBL #l],
; ; 			       [PRED "sub_mark",
; ; 				ARG0.--SUB - & #0,
; ; 				ARG1 #e,
; ; 				LBL #l] !>,
; ; 		   FLAGS.SUBSUME <#0>,
; ; 		   OUTPUT.RELS <! +copy+ & [ARG0.--SUB -] !> ].

; ; |#


;;; Explicitly set unbound arguments to unbound
 


bound_ini_rule := 
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0  [--BND na]] !>,
		OUTPUT.RELS <! +copy+ & [ARG0.--BND + ] !>]. 


; unbound_reli_rule :=  
; 		  fully_monotonic_mtr &
; 		  [INPUT.RELS <! [ARG0 ref-ind,
; 				  --RELI #x & ref-ind & [--BND na]] !>,
; 		   OUTPUT.RELS <! +copy+ & 
; 				[--RELI ref-ind & [--BND -] ]!> ].
		    

unbound_arg1_rule :=  
		  fully_monotonic_mtr &
		  [FILTER.RELS <! [ARG0 #x] !>,
		   FLAGS.SUBSUME <#x>,
		   INPUT.RELS <! [ARG1 #x & individual & [--BND na]] !>,
		   OUTPUT.RELS <! +copy+ & 
				[ARG1 [--BND -] ]!> ].

unbound_arg2_rule :=  
		      fully_monotonic_mtr &
		      [FILTER.RELS <! [ARG0 #x] !>,
		       FLAGS.SUBSUME <#x>,
		       INPUT.RELS <! [PRED "bnd_mark",
				      ARG2 #x & individual & [--BND na]] !>,
		       OUTPUT.RELS <! +copy+ & 
				    [ARG2 [--BND -] ]!> ].

unbound_arg3_rule :=  
		  fully_monotonic_mtr &
		  [FILTER.RELS <! [ARG0 #x] !>,
		   FLAGS.SUBSUME <#x>,
		   INPUT.RELS <! [ARG3 #x & individual & [--BND na]] !>,
		   OUTPUT.RELS <! +copy+ & 
				[ARG3 [--BND -] ]!> ].




;;;
free_rel_extra_rule := 
		  fully_monotonic_mtr &
		  [INPUT.RELS <! !>,
		   FILTER.RELS <! [PRED "extra_mark",
				   ARG0 #x,
				   LBL #h] !>,
		   CONTEXT.RELS <! [PRED "abstr_nom_rel",
				    LBL #h,
				    ARG0 #x],
				 [PRED topic_d_rel,
				  LBL #h] !>,
		   OUTPUT.RELS <!  
				[PRED "extra_mark",
				 ARG0 #x,
				 LBL #h]!> ].


rel_+arg1_extra_rule := 
		  fully_monotonic_mtr &
		  [INPUT.RELS <! [PRED #pred,
				  ARG0 #x,
				  LBL #h, 
				  ARG1 #u1]!>,
		   FLAGS.SUBSUME <#u1>,
		   FILTER.RELS <! [PRED "extra_mark",
				   ARG0 #x,
				   LBL #h] !>,
		   CONTEXT.RELS <! [PRED topic_d_rel,
				    LBL #h] !>,
		   OUTPUT.RELS <! [PRED #pred,
				   ARG0 #x,
				   LBL #h, 
				   ARG1 #u1,
				   --RELH #h,
				   --RELI #x ], 
				[PRED "extra_mark",
				 ARG0 #x,
				 LBL #h]!> ].

rel_+carg_extra_rule := 
		  fully_monotonic_mtr &
		  [INPUT.RELS <! [PRED #pred,
				  ARG0 #x,
				  LBL #h, 
				  CARG #u1]!>,
		   FLAGS.SUBSUME <#u1>,
		   FILTER.RELS <! [PRED "extra_mark",
				   ARG0 #x,
				   LBL #h] !>,
		   CONTEXT.RELS <! [PRED topic_d_rel,
				    LBL #h] !>,
		   OUTPUT.RELS <! [PRED #pred,
				   ARG0 #x,
				   LBL #h, 
				   CARG #u1,
				   --RELH #h,
				   --RELI #x ], 
				[PRED "extra_mark",
				 ARG0 #x,
				 LBL #h]!> ].

rel_extra_rule := 
		  fully_monotonic_mtr &
		  [INPUT.RELS <! [PRED #pred,
				  ARG0 #x & ref-ind,
				  LBL #h] !>,
		   FILTER.RELS <! [PRED "extra_mark",
				   ARG0 #x,
				   LBL #h] !>,
		   CONTEXT.RELS <! [PRED topic_d_rel,
				    LBL #h] !>,
		   OUTPUT.RELS <! [PRED #pred,
				   ARG0 #x,
				   LBL #h, 
				   --RELH #h,
				   --RELI #x ],
				[PRED "extra_mark",
				 ARG0 #x,
				 LBL #h] !> ].



extra_mark_del_rule := 
		      fully_monotonic_mtr &
		      [INPUT.RELS <! [PRED "extra_mark"] !>,
		       OUTPUT.RELS <! !> ].







;;; rel (necessarily exempt)
;;; control verbs (trivial) 
;;; raising verbs (exempt for the moment)


;;; lexical verbs

pas_nom_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & [--CAS *null*,
				      --TOP bool]] !>,
		CONTEXT.RELS <! [PRED parg_d_rel, 
				 ARG0 [E.TENSE real_tense],
				 ARG2 #0 ] !>,
		OUTPUT.RELS <! +copy+ & [ARG0 [--CAS n-list]] !> ].


;;; prep


prep_sel_gen_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool]] !>,
	       CONTEXT.RELS <! [PRED gen-prep-sel-rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS g-list] !> ].

an_prep_sel_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       FLAGS.SUBSUME <#0>,
	       CONTEXT.RELS <! [PRED _an_p_sel_rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS da-list] !> ].

auf_prep_sel_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED _auf_p_sel_rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].

ueber_prep_sel_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED _ueber_p_sel_rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].

hinter_prep_sel_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED _hinter_p_sel_rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS da-list] !> ].

neben_prep_sel_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED _neben_p_sel_rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS da-list] !> ].

unter_prep_sel_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED _unter_p_sel_rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS da-list] !> ].


prep_sel_von+durch_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED _durch-von_p_sel_rel,
				ARG2 #0] !>, 
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS da-list] !> ].


prep_sel_dat_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED dat-prep-sel-rel,
				ARG2 #0] !>, 
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].

prep_sel_acc_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED acc-prep-sel-rel,
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].


prep_dat-gen_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED "~_(wegen|laut)_p_", 
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS gd-list] !> ].


prep_gen_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED "~_(abseits|abzueglich|angesichts|anhand|anlaesslich|anstatt|anstelle|aufgrund|ausserhalb|betreffens|bezueglich|binnen|einschliesslich|exklusiv|gegenueber|gemaess|halber|infolge|inklusive|innerhalb|jenseits|mangels|mittels|samt|seitens|trotz|ungeachtet|waehrend|westlich|zugunsten|zuungunsten|zuzueglich|zwecks)_p_", 
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS g-list] !> ].


prep_loc_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED "~_p_loc_", 
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].

prep_dir_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED "~_p_dir_", 
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].


prep_dat_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED "~_(ab|aus|ausser|bei|entgegen|mit|nach|seit|von|vor|zu|zwischen)_p_", 
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].

prep_acc_rule :=  
	      fully_monotonic_mtr & 
	      [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
	       CONTEXT.RELS <! [PRED "~_(durch|fuer|gegen|ins|inbegriffen|ohne|plus|um|via|wider|gen)_p_", 
				ARG2 #0] !>,  
	       OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].




act_nom_modal_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool]] !>,
		CONTEXT [RELS <! [PRED "~_v_n-", 
				  LBL #larg,
				  ARG0 [--PSV psv-],
				  ARG1 #0],
			       [PRED "~_v_.*modal",
				ARG1 #larg] !> ,
			 HCONS <! qeq & [HARG #larg,
					 LARG #larg] !>
			 ],
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS n-list] !> ].

act_nom_1_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool]] !>,
		CONTEXT.RELS <! [PRED "~_v_n-", 
				 ARG0 [--PSV psv-,
				       E.TENSE present+past],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS n-list] !> ].



act_nom_2_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool]] !>,
		CONTEXT.RELS <! [PRED "~_v_n-", 
				 ARG0 [--PSV psv-,
				       E.TENSE future+cond],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS n-list] !> ].

act_arg1-acc_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_a-", 
				 ARG0 [E.TENSE real_tense],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].

act_arg1-dat_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_[av]_d-", 
				 ARG0 [E.TENSE real_tense],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].

act_arg1-datacc_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_da-", 
				 ARG0 [E.TENSE real_tense],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS da-list] !> ].


act_arg2-acc_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-a-", 
				 ARG0 [--PSV psv-,
				       E.TENSE real_tense],
				 ARG2 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].

act_arg2-dat_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-d-", 
				 ARG0 [E.TENSE real_tense],
				 ARG2 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].

act_arg2-gen_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-g-", 
				 ARG0 [E.TENSE real_tense],
				 ARG2 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS g-list] !> ].

act_arg3-dat-acc_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-([ngdah]+)-da-", 
				 ARG0 [E.TENSE real_tense],
				 ARG3 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].

act_arg3-gen-dat_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-([ngdah]+)-gd-", 
				 ARG0 [E.TENSE real_tense],
				 ARG3 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].


act_arg3-gen-acc_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-([ngdah]+)-ga-", 
				 ARG0 [E.TENSE real_tense],
				 ARG3 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS g-list] !> ].

act_arg3-acc_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-([ngdah]+)-a-", 
				 ARG0 [E.TENSE real_tense],
				 ARG3 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS a-list] !> ].

act_arg3-dat_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-([ngdah]+)-d-", 
				 ARG0 [E.TENSE real_tense],
				 ARG3 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS d-list] !> ].


act_arg3-gen_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_v_([ngdah]+)-([ngdah]+)-g-", 
				 ARG0 [E.TENSE real_tense],
				 ARG3 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS g-list] !> ].



prd_adj_arg1-nom_2_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_[ap]_", 
				 ARG0 [E.TENSE future+cond],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS n-list] !> ].

prd_adj_arg1-nom_1_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						    --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "~_[ap]_", 
				 ARG0 [E.TENSE present+past],
				 ARG1 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS n-list] !> ].

;;; copulae

;;; not yet accounted for



;;; poss_rel: Order dependent (possessive pronouns do not take genitive case) 

poss_cas_rule :=
	       fully_monotonic_mtr & 
	       [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
						   --TOP bool ]] !>,
		CONTEXT.RELS <! [PRED "poss_rel", 
				 ARG2 #0] !>,  
		OUTPUT.RELS <! +copy+ & [ARG0.--CAS g-list] !> ].


; ;;; zu+_arg1_rule := 
; ;;; 		 fully_monotonic_mtr & 
; ;;; 		 [INPUT.RELS <! [ARG0 #0 & ref-ind & [--CAS *null*,
; ;;; 						      --TOP bool ]] !>,
; ;;; 		  CONTEXT.RELS <! [PRED "poss_rel", 
; ;;; 				   ARG1 #h] !>,  
; ;;; 		  OUTPUT.RELS <! +copy+ & [ARG0.--ZU +] !> ].



l-r-hndl_prop_punct_rule :=
			   fully_monotonic_mtr & 
			   [INPUT.RELS <! [ARG0.--PUNCT nomess-punct] !>,
			    CONTEXT [HOOK.LTOP #t,
				     RELS <! 
					   [LBL #t & handle,
					    L-INDEX #e1 & event & [SF prop], 
					    R-INDEX #e2 & event & [SF prop]]
					   !>
					       ],
			    FLAGS.SUBSUME <#e1,#e2>,
			    OUTPUT.RELS <! +copy+ & [ARG0.--PUNCT prop-punct] !>].



prop_punct_rule :=
		 fully_monotonic_mtr & 
		 [INPUT.RELS <! [ARG0.--PUNCT nomess-punct] !>,
		  CONTEXT  [HOOK.INDEX.SF prop],
		  OUTPUT.RELS <! +copy+ & [ARG0 [--PUNCT prop-punct]] !>].

ques_punct_rule :=
		 fully_monotonic_mtr & 
		 [INPUT.RELS <! [ARG0.--PUNCT nomess-punct] !>,
		  CONTEXT  [HOOK.INDEX [SF ques] ],
		  OUTPUT.RELS <! +copy+ & [ARG0 [--PUNCT ques-punct]] !>].


imp_punct_rule :=
		 fully_monotonic_mtr & 
		 [INPUT.RELS <! [ARG0.--PUNCT nomess-punct] !>,
		  CONTEXT  [HOOK.INDEX.SF comm],
		  OUTPUT.RELS <! +copy+ & [ARG0 [--PUNCT imp-punct]] !>].

punct_rel_del_rule :=
		     fully_monotonic_mtr & 
		     [INPUT.RELS <! [PRED "punct_rel"] !>,
		      OUTPUT.RELS <!  !>].



; coh-_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 [--COH na]] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH -] !> ].


; prd-adj_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [LBL #l,
; 				       PRED "~_a_",
; 				       ARG0 #e & event & [E tensed],
; 				       ARG1 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +], 
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; prd-adj_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [LBL #l,
; 				       PRED "~_a_",
; 				       ARG0 #e & event & [E tensed],
; 				       ARG2 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +], 
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; perfect_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [PRED "~_rel",
; 				       LBL #l,
; 				       ARG0 #e & event & [E [TENSE real_tense,
; 							     PERFECTIVE +]],
; 				       ARG1 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +], 
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; perfect_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [ARG0 #e & event & [E [TENSE real_tense,
; 							     PERFECTIVE +]],
; 					 ARG2 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +], 
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; perfect_coh+_arg3_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [PRED "~_rel",
; 				       ARG0 #e & event & [E [TENSE real_tense,
; 							     PERFECTIVE +]],
; 					 ARG3 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; future_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [PRED "~_rel",
; 				       ARG0 #e & event & [E.TENSE future+cond],
; 				       ARG1 #x] !>,
			
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; future_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [ARG0 #e & event & [E.TENSE future+cond],
; 					 ARG2 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; future_coh+_arg3_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [ARG0 #e & event & [E.TENSE future+cond],
; 					 ARG3 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].


; passive_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [PRED "~_rel",
; 				       LBL #l,
; 				       ARG0 #e & event & [--PSV psv+],
; 				       ARG1 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +], 
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; passive_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x ] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [ARG0 #e & event & [--PSV psv+],
; 					 ARG2 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +], 
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].



			


; passive_coh+_arg3_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x ] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED topic-or-focus_d_rel,
; 					 ARG2 #e],
; 				      [ARG0 #e & event & [--PSV psv+],
; 					 ARG3 #x] !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; part_coh+_arg1_h_rule :=
; 		       fully_monotonic_mtr & 
; 			[INPUT.RELS <! [ARG0 #x & event,
; 					LBL #h] !>,
; 			 FLAGS.SUBSUME <#e,#h,#h1>,
; 			 FILTER.RELS <! [PRED "coh_mark",
; 					 LBL #l,
; 					 ARG0 #e, 
; 					 ARG1 #x] !>, 
; 			 CONTEXT.RELS <! [LBL #l,
; 					  ARG0 #e & event,
; 					  ARG1 #h & handle],
; 				       [PRED "~_x_sel_rel",
; 					LBL #l,
; 					ARG1 #e]
; 				       !>,
; 			 OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				      [PRED "coh_mark",
; 				       LBL #l,
; 				       ARG0 #e, 
; 				       ARG1 #x] !> ].

; part_coh+_arg1_no_msg_h_rule :=
; 			       fully_monotonic_mtr & 
; 			       [INPUT.RELS <! [ARG0 #x & event,
; 					       LBL #h] !>,
; 				FLAGS.SUBSUME <#e,#h>,
; 				FILTER.RELS <! [PRED "coh_mark",
; 						LBL #l,
; 						ARG0 #e, 
; 						ARG1 #x] !>, 
; 				CONTEXT.RELS <! [LBL #l,
; 						 PRED "~_v_",
; 						 ARG0 #e & event,
; 						 ARG1 #h & handle],
; 					      [PRED "~_x_sel_rel",
; 					       LBL #l,
; 					       ARG1 #e]
; 					      !>,
; 				OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 					     [PRED "coh_mark",
; 					      LBL #l,
; 					      ARG0 #e, 
; 					      ARG1 #x]
; 					     !> ].

; part_coh+_arg2_h_rule :=
; 		       fully_monotonic_mtr & 
; 			[INPUT.RELS <! [ARG0 #x & event,
; 					LBL #h] !>,
; 			 FLAGS.SUBSUME <#e,#h>,
; 			 FILTER.RELS <! [PRED "coh_mark",
; 					 LBL #l,
; 					 ARG0 #e, 
; 					 ARG1 #x] !>, 
; 			 CONTEXT.RELS <! [LBL #l,
; 					  PRED "~_v_",
; 					  ARG0 #e & event,
; 					  ARG2 #h & handle],
; 				       [PRED "~_x_sel_rel",
; 					LBL #l,
; 					ARG1 #e]
; 				       !>,
; 			 OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				      [PRED "coh_mark",
; 				       LBL #l,
; 				       ARG0 #e, 
; 				       ARG1 #x] !> ].

; part_coh+_arg3_h_rule :=
; 		       fully_monotonic_mtr & 
; 			[INPUT.RELS <! [ARG0 #x & event,
; 					LBL #h] !>,
; 			 FLAGS.SUBSUME <#e,#h>,
; 			 FILTER.RELS <! [PRED "coh_mark",
; 					 LBL #l,
; 					 ARG0 #e, 
; 					 ARG1 #x] !>, 
; 			 CONTEXT.RELS <! [LBL #l,
; 					  ARG0 #e & event,
; 					  ARG3 #h & handle],
; 				       [PRED "~_x_sel_rel",
; 					LBL #h,
; 					ARG1 #e]
; 				       !>,
; 			 OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				      [PRED "coh_mark",
; 				       LBL #l,
; 				       ARG0 #e, 
; 				       ARG1 #x] !> ].



; ;;; part_coh+_arg2_h_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [LBL #l,
; ;;; 				       ARG0 #e & event,
; ;;; 				       ARG2 #h & handle] !>,
; ;;; 			FLAGS.SUBSUME <#e,#h>,
; ;;; 			FILTER.RELS <! [PRED "coh_mark",
; ;;; 					LBL #l,
; ;;; 					ARG0 #e, 
; ;;; 					ARG1 #x] !>, 
; ;;; 			CONTEXT.RELS <! [PRED message_m_rel,
; ;;; 					 ARG0 #x,
; ;;; 					 LBL #h],
; ;;; 				      [PRED "~_x_sel_rel",
; ;;; 				       LBL #l,
; ;;; 				       ARG1 #e]
; ;;; 				      !>,
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; ;;; 				     [PRED "coh_mark",
; ;;; 				      LBL #l,
; ;;; 				      ARG0 #e, 
; ;;; 				      ARG1 #x] !> ].


; ;;; part_coh+_arg3_h_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [LBL #l,
; ;;; 				       ARG0 #e & event,
; ;;; 				       ARG3 #h & handle] !>,
; ;;; 			FLAGS.SUBSUME <#e,#h>,
; ;;; 			FILTER.RELS <! [PRED "coh_mark",
; ;;; 					LBL #l,
; ;;; 					ARG0 #e, 
; ;;; 					ARG1 #x] !>, 
; ;;; 			CONTEXT.RELS <! [PRED message_m_rel,
; ;;; 					 ARG0 #x,
; ;;; 					 LBL #h],
; ;;; 				      [PRED "~_x_sel_rel",
; ;;; 				       LBL #l,
; ;;; 				       ARG1 #e]
; ;;; 				      !>,
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; ;;; 				     [PRED "coh_mark",
; ;;; 				      LBL #l,
; ;;; 				      ARG0 #e, 
; ;;; 				      ARG1 #x] !> ].


; part_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [PRED "~_rel",
; 					 ARG0 #e & event,
; 					 ARG1 #x],
; 				      [PRED "~_x_sel_rel",
; 				       ARG1 #e]
; 				      !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; part_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [ARG0 #e & event,
; 					 ARG2 #x],
; 				      [PRED "~_x_sel_rel",
; 				       ARG1 #e]
; 				      !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; part_coh+_arg3_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT.RELS <! [ARG0 #e & event,
; 					 ARG3 #x],
; 				      [PRED "~_x_sel_rel",
; 				       ARG1 #e]
; 				      !>,
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #l,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; modal_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x,#h0,#h1>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT [RELS <! 
; 				       [ARG0 #e & event,
; 					PRED "~(_v_.*modal|_scheinen_v_)",
; 					ARG1 #h0 ],
; 				       [PRED "scop_eq_mark",
; 					LBL #h1,
; 					ARG0 #e1],
; 				       [PRED "~_rel",
; 					ARG0 #e1 & [E.TENSE none_or_no_tense],
; 					ARG1 #x] !>,
; 				 HCONS <! qeq & [HARG #h0,
; 						 LARG #h1] !>
; 				      ],
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #h,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; modal_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT [RELS <! 
; 				       [ARG0 #e & event,
; 					PRED "~(_v_.*modal|_scheinen_v_)",
; 					ARG1 #h0 ],
; 				       [PRED "scop_eq_mark",
; 					LBL #h1,
; 					ARG0 #e1],
; 				       [ARG0 #e1 & [E.TENSE none_or_no_tense],
; 					ARG2 #x] !>,
; 				 HCONS <! qeq & [HARG #h0,
; 						 LARG #h1] !>
; 				 ],
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #h,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; modal_coh+_arg3_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT [RELS <! 
; 				       [ARG0 #e & event,
; 					PRED "~(_v_.*modal|_scheinen_v_)",
; 					ARG1 #h0 ],
; 				       [PRED "scop_eq_mark",
; 					LBL #h1,
; 					ARG0 #e1],
; 				       [ARG0 #e1 & [E.TENSE none_or_no_tense],
; 					ARG3 #x] !>,
; 				 HCONS <! qeq & [HARG #h0,
; 						 LARG #h1] !>
; 				      ],
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #h,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].


; wollen_coh+_arg1_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT [RELS <! 
; 				       [ARG0 #e & event,
; 					PRED "~(_v_.*modal)",
; 					ARG2 #h0 ],
; 				       [PRED "scop_eq_mark",
; 					LBL #h1,
; 					ARG0 #e1],
; 				       [PRED "~_rel",
; 					ARG0 #e1 & [E.TENSE none_or_no_tense],
; 					ARG1 #x] !>, 
; 				 HCONS <! qeq & [HARG #h0,
; 						 LARG #h1] !>
; 				 ],
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #h,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; wollen_coh+_arg2_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT [RELS <! 
; 				       [ARG0 #e & event,
; 					PRED "~(_v_.*modal)",
; 					ARG2 #h ],
; 				       [PRED "scop_eq_mark",
; 					LBL #h,
; 					ARG0 #e1],
; 				       [ARG0 #e1 & [E.TENSE none_or_no_tense],
; 					ARG2 #x] !>
; 				 ],
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #h,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].

; wollen_coh+_arg3_rule :=
; 		       fully_monotonic_mtr & 
; 		       [INPUT.RELS <! [ARG0 #x] !>,
; 			FLAGS.SUBSUME <#e,#x>,
; 			FILTER.RELS <! [PRED "coh_mark",
; 					LBL #l,
; 					ARG0 #e, 
; 					ARG1 #x] !>, 
; 			CONTEXT [RELS <! 
; 				       [ARG0 #e & event,
; 					PRED "~(_v_.*modal)",
; 					ARG2 #h0 ],
; 				       [PRED "scop_eq_mark",
; 					LBL #h1,
; 					ARG0 #e1],
; 				       [ARG0 #e1 & [E.TENSE none_or_no_tense],
; 					ARG3 #x] !>, 
; 				 HCONS <! qeq & [HARG #h0,
; 						 LARG #h1] !>
; 				 ],
; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +],
; 				     [PRED "coh_mark",
; 				      LBL #h,
; 				      ARG0 #e, 
; 				      ARG1 #x] !> ].






; ;;; v_arg1_coh+_arg1_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG1 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG1 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].

; ;;; v_arg1_coh+_arg2_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG1 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG2 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].
; ;;; v_arg1_coh+_arg3_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG1 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG3 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].


; ;;; v_arg2_coh+_arg1_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG2 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG1 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].

; ;;; v_arg2_coh+_arg2_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG2 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG2 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].
; ;;; v_arg2_coh+_arg3_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG2 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG3 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].


; ;;; v_arg3_coh+_arg1_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG3 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG1 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].

; ;;; v_arg3_coh+_arg2_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG3 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG2 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].

; ;;; v_arg3_coh+_arg3_rule :=
; ;;; 		       fully_monotonic_mtr & 
; ;;; 		       [INPUT.RELS <! [ARG0 #x & [--COH na_or_-]] !>,
; ;;; 			FLAGS.SUBSUME <#e,#x>,
; ;;; 			CONTEXT [RELS <! 
; ;;; 				       [ARG0 #e & event,
; ;;; 					PRED "~_v_",
; ;;; 					ARG3 #v ],
; ;;; 				       [PRED prpstn_m_rel,
; ;;; 					ARG0 #e0,
; ;;; 					LBL #v,
; ;;; 					MARG #h],
; ;;; 				       [LBL #l,
; ;;; 					ARG0 #e0 & event & [E.TENSE none_or_no_tense],
; ;;; 					ARG3 #x] !>,
; ;;; 				 HCONS <! qeq & [HARG #h,
; ;;; 						 LARG #l]!>
; ;;; 				 ],
; ;;; 			OUTPUT.RELS <! +copy+ & [ARG0.--COH +] !> ].


; ;;; 


; coh_mark_del_rule :=
; 		   fully_monotonic_mtr & 
; 		   [INPUT.RELS <! [PRED "coh_mark"] !>,
; 		    OUTPUT.RELS <! !>].




;;; oind

; oind_123_del := fully_monotonic_mtr &
; 		 [INPUT.RELS <!
; 				[PRED #pred,
; 				 LBL #l,
; 				 ARG0 #e,
; 				 ARG1 #1 & handle_or_individual, 
; 				 ARG2 #2 & handle_or_individual,
; 				 ARG3 #3 & handle_or_individual,
; 				 --OIND #x & ref-ind ]
; 			      !>,
; 		  FLAGS.SUBSUME <#1,#2,#3,#x>,
; 		  OUTPUT.RELS <! [PRED #pred,
; 				  LBL #l,
; 				  ARG0 #e,
; 				  ARG1 #1,
; 				  ARG2 #2,
; 				  ARG3 #3 ] !> ].


; oind_12_del := fully_monotonic_mtr &
; 		 [INPUT.RELS <!
; 				[PRED #pred,
; 				 LBL #l,
; 				 ARG0 #e,
; 				 ARG1 #1 & handle_or_individual, 
; 				 ARG2 #2 & handle_or_individual,
; 				 --OIND #x & ref-ind ]
; 			      !>,
; 		  FLAGS.SUBSUME <#1,#2,#x>,
; 		  OUTPUT.RELS <! [PRED #pred,
; 				  LBL #l,
; 				  ARG0 #e,
; 				  ARG1 #1,
; 				  ARG2 #2 ] !> ].

; oind_1_del := fully_monotonic_mtr &
; 		 [INPUT.RELS <!
; 				[PRED #pred,
; 				 LBL #l,
; 				 ARG0 #e,
; 				 ARG1 #1 & handle_or_individual, 
; 				 --OIND #x & ref-ind ]
; 			      !>,
; 		  FLAGS.SUBSUME <#1,#x>,
; 		  OUTPUT.RELS <! [PRED #pred,
; 				  LBL #l,
; 				  ARG0 #e,
; 				  ARG1 #1 ] !> ].

; oind_0_del := fully_monotonic_mtr &
; 	      [INPUT.RELS <!
; 			   [PRED #pred,
; 			    LBL #l,
; 			    ARG0 #e,
; 			    --OIND #x & ref-ind ]
; 			   !>,
; 	       FLAGS.SUBSUME <#x>,
; 	       OUTPUT.RELS <! [PRED #pred,
; 			       LBL #l,
; 			       ARG0 #e ] !> ].

oind_ini_rule := 
		 fully_monotonic_mtr &
		 [INPUT.RELS <! !>,
		  CONTEXT.RELS <!
				[LBL #l,
				 PRED "~_[va]_",
				 ARG0 #e & [E.TENSE real_tense]] !>,
		  FILTER.RELS <! [PRED "oind_mark",
				  LBL #l,
				  ARG1 #e] !>,
		  OUTPUT.RELS <! [PRED "oind_mark",
				  LBL #l,
				  ARG0 [--BND na],
				  ARG1 #e]
			       !> ].




finite_oind_rule := fully_monotonic_mtr &
		    [INPUT.RELS <! [PRED "oind_mark",
				    ARG0 [--BND na],
				    ARG1 #e & [E [TENSE finite]]] !>,
		     FLAGS.SUBSUME <#e>,
		     OUTPUT.RELS <! +copy+ & [ARG0 individual & [--BND -]] !> ].

imp_oind_rule := fully_monotonic_mtr &
		 [INPUT.RELS <! [PRED "oind_mark",
				 ARG0 [--BND na],
				 ARG1 #e & [E [TENSE no_tense,
					       MOOD imperative]]] !>,
		  FLAGS.SUBSUME <#e>,
		  OUTPUT.RELS <! +copy+ & [ARG0 individual & [--BND -]] !> ].



lassen_modal_arg1_oind_rule :=
		  fully_monotonic_mtr &
		    [INPUT.RELS <! [PRED "oind_mark",
				    ARG0 [--BND na],
				    LBL #l,
				    ARG1 #e] !>,
		     CONTEXT [RELS <!
				   [PRED "~lassen_v_.*refl.*modal",
				    ARG1 #h0],
				   [PRED "scop_eq_mark",
				    LBL #h1,
				    ARG0 #e],
				   [LBL #l,
				    PRED "~_[va]_",
				    ARG0 #e & event & [E.TENSE no_tense]] !>,
			      HCONS <! qeq & [HARG #h0,
					      LARG #h1] !>],
		     FLAGS.SUBSUME <#e,#h0,#h1>,
		     OUTPUT.RELS <! +copy+ & [ARG0 [--BND +]]
				  !> ].

modal_arg1_oind_rule :=
		  fully_monotonic_mtr &
		    [INPUT.RELS <! [PRED "oind_mark",
				    ARG0 [--BND na],
				    LBL #l,
				    ARG1 #e] !>,
		     CONTEXT [RELS <!
				   [PRED "~_v_.*modal",
				    ARG1 #h0],
				   [PRED "scop_eq_mark",
				    LBL #h1,
				    ARG0 #e],
				   [LBL #l,
				    PRED "~_[va]_",
				    ARG0 #e & event & [E.TENSE no_tense]] !>, 
			      HCONS <! qeq & [HARG #h0,
					      LARG #h1] !>],
		     FLAGS.SUBSUME <#e,#h0,#h1>,
		     OUTPUT.RELS <! +copy+ & [ARG0.--BND -]
				  !> ].

modal_arg2_oind_rule :=
		       fully_monotonic_mtr &
		       [INPUT.RELS <! [PRED "oind_mark",
				       ARG0 [--BND na],
				       LBL #l,
				       ARG1 #e] !>,
			CONTEXT [RELS <!
				      [PRED "~_v_.*modal",
				       ARG2 #h0],
				       [PRED "scop_eq_mark",
					LBL #h1,
					ARG0 #e],
				       [LBL #l,
					PRED "~_[va]_",
					--OIND.--BND na,
				       ARG0 #e & event & [E.TENSE no_tense]] !>,
				 HCONS <! qeq & [HARG #h0,
						 LARG #h1] !>],

			FLAGS.SUBSUME <#e,#h0,#h1>,
			OUTPUT.RELS <! +copy+ & [ARG0.--BND -]
				     !> ].


				

subj_to_obj_raising_oind_rule :=
				fully_monotonic_mtr &
				[INPUT.RELS <! [PRED "oind_mark",
						ARG0 [--BND na],
						LBL #l,
						ARG1 #e] !>,
				 CONTEXT [RELS <!
						[PRED "~_v_.*raise",
						 ARG0 [E [TENSE present+past,
							  PERFECTIVE -],
						       --PSV psv-],
						 ARG2 #h0],
						[PRED "scop_eq_mark",
						 LBL #h1,
						 ARG0 #e],
						[LBL #l,
						PRED "~_[va]_",
						 ARG0 #e & event & [E.TENSE no_tense],
						 ARG1 #x]
						!>,
				 HCONS <! qeq & [HARG #h0,
						 LARG #h1] !>],
				 
					    FLAGS.SUBSUME <#e,#h0,#h1>,
				 OUTPUT.RELS <! [PRED "oind_mark",
						 LBL #l,
						 ARG1 #e,
						 ARG0 #x]
					      !> ].

subj_to_subj_raising_oind1_rule :=
				fully_monotonic_mtr &
				[INPUT.RELS <! [PRED "oind_mark",
						ARG0 [--BND na],
						LBL #l,
						ARG1 #e] !>,
				 CONTEXT.RELS <!
					       [PRED "~erscheinen_v_d-h.*",
						ARG0 [E [TENSE present+past,
							 PERFECTIVE -],
						      --PSV psv-],
						ARG2 #h,
						ARG1 #x & ref-ind ],
					       [PRED "scop_eq_mark",
						LBL #h,
						ARG0 #e],
					       [LBL #l,
						PRED "~_[va]_",
						ARG0 #e & event & [E.TENSE no_tense]] !>,
				 FLAGS.SUBSUME <#e,#h>,
				 OUTPUT.RELS <! [PRED "oind_mark",
						 LBL #l,
						 ARG1 #e,
						 ARG0 #x]
					      !> ].

subj_to_subj_raising_oind2_rule :=
				fully_monotonic_mtr &
				[INPUT.RELS <! [PRED "oind_mark",
						ARG0 [--BND na],
						LBL #l,
						ARG1 #e] !>,
				 CONTEXT [RELS <!
						[PRED "~scheinen_v_h-d.*",
						 ARG0 [E [TENSE present+past,
							  PERFECTIVE -],
						       --PSV psv-],
						 ARG1 #h,
						 ARG2 #x & ref-ind ],
						[PRED "scop_eq_mark",
						 LBL #h,
						 ARG0 #e],
						[LBL #l,
						 PRED "~_[va]_",
						 ARG0 #e & event & [E.TENSE no_tense]] !>,
					  HCONS <! qeq & [HARG #h0,
							  LARG #h1] !>],
				 FLAGS.SUBSUME <#e,#h>,
				 OUTPUT.RELS <! [PRED "oind_mark",
						 LBL #l,
						 ARG1 #e,
						 ARG0 #x]
					      !> ].


control_particle_oind-_arg2_rule := 
			  fully_monotonic_mtr &
			  [INPUT.RELS <! [PRED "oind_mark",
					  ARG0 [--BND na],
					  LBL #l,
					  ARG1 #e] !>,
			   CONTEXT.RELS <!
					 [PRED "~_v_",
					  LBL #h0,
					  ARG0 #e0 & event,
					  ARG2 #x & ref-ind, 
					  ARG3 #h1],
					 [PRED "~_x_sel_rel",
					  ARG1 #e0,
					  LBL #h0],
					 [LBL #h1,
					  PRED "~_[va]_",
					  ARG0 #e & event & [E.TENSE no_tense]] !>,
			   FLAGS.SUBSUME <#e,#h1,#x>,
			   OUTPUT.RELS <! +copy+ & [ARG0.--BND -]
					!> ].

control_oind+_arg2_rule := 
			  fully_monotonic_mtr &
			   [INPUT.RELS <! [PRED "oind_mark",
					   ARG0 [--BND na],
					   LBL #l,
					   ARG1 #e] !>,
			    CONTEXT [RELS <!
					   [PRED "~_v_",
					    ARG0 event & [E [TENSE present+past,
							     PERFECTIVE -],
							  --PSV psv-],
					    ARG2 #x & ref-ind, 
					    ARG3 #h0],
					   [PRED "scop_eq_mark",
					    LBL #h1,
					    ARG0 #e],
					   [PRED "~_[va]_",
					    ARG0 #e & event & [E.TENSE no_tense]] !>,
				     HCONS <! qeq & [HARG #h0, 
						     LARG #h1] !>],
			    FLAGS.SUBSUME <#e,#h0,#h1,#x>,
			    OUTPUT.RELS <! [PRED "oind_mark",
					    LBL #l,
					    ARG1 #e,
					    ARG0 #x]
					!> ].
			  
default_oind-_rule := 
			  fully_monotonic_mtr &
			  [INPUT.RELS <! [PRED "oind_mark",
					   ARG0 [--BND na],
					   LBL #l,
					   ARG1 #e] !>,
			   CONTEXT.RELS <!
					 [LBL #l,
					  PRED "~_[va]_",
					  ARG0 #e & event & [E [TENSE no_tense,
								MOOD no_mood]]] !>,
			   FLAGS.SUBSUME <#e>,
			   OUTPUT.RELS <! +copy+ & 
					[ARG0 [--BND -]]
					!> ].


oind_mark_123_del := fully_monotonic_mtr &
		 [INPUT.RELS <!
			      [PRED #pred,
			       LBL #l,
			       ARG0 #e,
			       ARG1 #1 & handle_or_individual, 
			       ARG2 #2 & handle_or_individual,
			       ARG3 #3 & handle_or_individual,
			       --OIND individual ],
			      [PRED "oind_mark",
			       LBL #l,
			       ARG0 #x,
			       ARG1 #e]
			      !>,
		  FLAGS.SUBSUME <#1,#2,#3>,
		  CONTEXT.RELS <! [PRED "scop_eq_mark",
				   LBL #l,
				   ARG0 #e ] !>,
		  OUTPUT.RELS <! [PRED #pred,
				  LBL #l,
				  ARG0 #e,
				  ARG1 #1,
				  ARG2 #2,
				  ARG3 #3,
				  --OIND #x ] !> ].


oind_mark_12_del := fully_monotonic_mtr &
		 [INPUT.RELS <!
			      [PRED #pred,
			       LBL #l,
			       ARG0 #e,
			       ARG1 #1 & handle_or_individual, 
			       ARG2 #2 & handle_or_individual],
			      [PRED "oind_mark",
			       LBL #l,
			       ARG0 #x,
			       ARG1 #e]
			      !>,
		  FLAGS.SUBSUME <#1,#2>,
		  CONTEXT.RELS <! [PRED "scop_eq_mark",
				   LBL #l,
				   ARG0 #e ] !>,
		  OUTPUT.RELS <! [PRED #pred,
				  LBL #l,
				  ARG0 #e,
				  ARG1 #1,
				  ARG2 #2,
				  --OIND #x ] !> ].


oind_mark_1_del := fully_monotonic_mtr &
		 [INPUT.RELS <!
			      [PRED #pred,
			       LBL #l,
			       ARG0 #e,
			       ARG1 #1 & handle_or_individual],
			      [PRED "oind_mark",
			       LBL #l,
			       ARG0 #x & individual,
			       ARG1 #e]
			      !>,
		  CONTEXT.RELS <! [PRED "scop_eq_mark",
				   LBL #l,
				   ARG0 #e ] !>,
		  FLAGS.SUBSUME <#1>,
		  OUTPUT.RELS <! [PRED #pred,
				  LBL #l,
				  ARG0 #e,
				  ARG1 #1,
				  --OIND #x ] !> ].



oind_mark_0_del := fully_monotonic_mtr &
		 [INPUT.RELS <!
			      [PRED #pred,
			       LBL #l,
			       ARG0 #e ,
			       --OIND individual ],
			      [PRED "oind_mark",
			       LBL #l,
			       ARG0 #x,
			       ARG1 #e]
			      !>,
		  CONTEXT.RELS <! [PRED "scop_eq_mark",
				   LBL #l,
				   ARG0 #e ] !>,
		  OUTPUT.RELS <! [PRED #pred,
				  LBL #l,
				  ARG0 #e,
				  --OIND #x ] !> ].



; ;;; --sind 




; sind_act_rule := 
; 		 fully_monotonic_mtr &
; 		 [CONTEXT.RELS <! [LBL #l,
; 				   PRED "~_[vap]_n-.*",
; 				   ARG0 #e & [E [TENSE no_tense,
; 						 MOOD no_mood],
; 					      --PSV psv-],
; 				   ARG1 #x & ref-ind & [PNG.PN #pn]
; 				     ]
; 				!>,
; 		  FILTER.RELS <! [PRED "sind_mark",
; 				  ARG0 #x,
; 				  ARG1 #e,
; 				  LBL #l] !>,
; 		  OUTPUT.RELS <! [PRED "sind_mark",
; 				  ARG0 #x,
; 				  ARG1 #e,
; 				  LBL #l] !>
; 			       ].

; sind_psv_rule := 
; 		 fully_monotonic_mtr &
; 		 [CONTEXT.RELS <! [LBL #l,
; 				   PRED "~_[vap]_n-.*",
; 				   ARG0 #e & [E [TENSE no_tense,
; 						 MOOD no_mood],
; 					      --PSV psv+],
; 				   ARG2 #x & ref-ind & [PNG.PN #pn]
; 				     ],
; 				[PRED parg_d_rel,
; 				 ARG2 #x ]
; 				!>,
; 		  FLAGS.SUBSUME <#x>,
; 		  FILTER.RELS <! [PRED "sind_mark",
; 				  ARG0 #x,
; 				  ARG1 #e,
; 				  LBL #l] !>,
; 		  OUTPUT.RELS <! [PRED "sind_mark",
; 				  ARG0 #x,
; 				  ARG1 #e,
; 				  LBL #l] !>
; 			       ].



; sind_modal_rule := 
; 		   fully_monotonic_mtr &
; 		   [CONTEXT.RELS <! [PRED "sind_mark",
; 				     ARG0 #x,
; 				     ARG1 #e1], 
; 				  [PRED "~_v_.*modal",
; 				   ARG0 #e0,
; 				   LBL #l0,
; 				   ARG1 #h],
; 				  [PRED "scop_eq_mark",
; 				   LBL #h,
; 				   ARG0 #e1] !>,
; 		    FILTER.RELS <! [PRED "sind_mark",
; 				    ARG1 #e0,
; 				    LBL #l0,
; 				    ARG0 #x] !>,
; 		    OUTPUT.RELS <! [PRED "sind_mark",
; 				    ARG1 #e0,
; 				    LBL #l0,
; 				    ARG0 #x] !>].

; sind_raising_rule := 
; 		     fully_monotonic_mtr &
; 		     [CONTEXT.RELS <! [PRED "sind_mark",
; 				       ARG0 #x,
; 				       ARG1 #e1], 
; 				    [PRED "~_(scheinen)_v_",
; 				     ARG0 #e0,
; 				     LBL #l0,
; 				     ARG1 #h],
; 				    [PRED "scop_eq_mark",
; 				     LBL #h,
; 				     ARG0 #e1] !>,
; 		      FILTER.RELS <! [PRED "sind_mark",
; 				      ARG1 #e0,
; 				      LBL #l0,
; 				      ARG0 #x] !>,
; 		      OUTPUT.RELS <! [PRED "sind_mark",
; 				      ARG1 #e0,
; 				      LBL #l0,
; 				      ARG0 #x] !>].


; sind_nonfin_del_rule :=
; 		       fully_monotonic_mtr &
; 		       [INPUT.RELS <! [PRED "sind_mark",
; 				       ARG1 [E [TENSE no_tense,
; 						MOOD no_mood]]
; 				       ] !> ].

; sind_3s_rule :=
; 	       fully_monotonic_mtr &
; 	       [INPUT.RELS <! [ARG0 #e ,
; 			       LBL #l],
; 			    [PRED "sind_mark",
; 			     LBL #l,
; 			     ARG1 #e & [E.TENSE finite],
; 			     ARG0.PNG.PN 3s] !>,
; 		OUTPUT.RELS <! +copy+ & [ARG0 [--SIND 3s]] !>].



; sind_2s_rule :=
; 	       fully_monotonic_mtr &
; 	       [INPUT.RELS <! [ARG0 #e ,
; 			       LBL #l],
; 			    [PRED "sind_mark",
; 			     LBL #l,
; 			     ARG1 #e,
; 			     ARG0.PNG.PN 2s] !>,
; 		OUTPUT.RELS <! +copy+ & [ARG0 [--SIND 2s]] !>].


; sind_1s_rule :=
; 	       fully_monotonic_mtr &
; 	       [INPUT.RELS <! [ARG0 #e ,
; 			       LBL #l],
; 			    [PRED "sind_mark",
; 			     LBL #l,
; 			     ARG1 #e & [E.TENSE finite],
; 			     ARG0.PNG.PN 1s] !>,
; 		OUTPUT.RELS <! +copy+ & [ARG0 [--SIND 1s]] !>].


; sind_3p_rule :=
; 	       fully_monotonic_mtr &
; 	       [INPUT.RELS <! [ARG0 #e ,
; 			       LBL #l],
; 			    [PRED "sind_mark",
; 			     LBL #l,
; 			     ARG1 #e & [E.TENSE finite],
; 			     ARG0.PNG.PN 3p] !>,
; 		OUTPUT.RELS <! +copy+ & [ARG0 [--SIND 3p]] !>].



; sind_2p_rule :=
; 	       fully_monotonic_mtr &
; 	       [INPUT.RELS <! [ARG0 #e ,
; 			       LBL #l],
; 			    [PRED "sind_mark",
; 			     LBL #l,
; 			     ARG1 #e & [E.TENSE finite],
; 			     ARG0.PNG.PN 2p] !>,
; 		OUTPUT.RELS <! +copy+ & [ARG0 [--SIND 2p]] !>].

; sind_1p_rule :=
; 	       fully_monotonic_mtr &
; 	       [INPUT.RELS <! [ARG0 #e ,
; 			       LBL #l],
; 			    [PRED "sind_mark",
; 			     LBL #l,
; 			     ARG1 #e,
; 			     ARG0.PNG.PN 1p] !>,
; 		OUTPUT.RELS <! +copy+ & [ARG0 [--SIND 1p]] !>].


; sind_mark_del :=  
; 		   fully_monotonic_mtr &
; 		   [INPUT.RELS <! [PRED "sind_mark"] !>,
; 		    OUTPUT.RELS <! !>].







scop_mark_del := fully_monotonic_mtr &
		 [INPUT.RELS <! [PRED "scop_eq_mark"] !>].

oind_mark_del := fully_monotonic_mtr &
		 [INPUT.RELS <! [PRED "oind_mark"] !>].