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

;;; Authors: 
;;; 1997-2000 Walter Kasper & Stefan Müller
;;; 2000-2002 Stefan Müller
;;; 2002-2006 Berthold Crysmann

;;; Copyright: DFKI GmbH




slash-intro-sign := 
		    sign &
		    [synsem [nonloc contains-slash]].


anc-retrieval-rule := 
		      grammar-rule.


h-opt-rule:=
	    headed-unary-rule-type &
	    inher-nonloc &
	    inher-anc-unary &
	    [synsem saturated-synsem & 
		    [loc.cat.extra-poss x_- & s-,
		     phrase +,
		     lex -],
	     head-dtr #h, 
	     args <#h & [synsem.loc.cat [subcat.list *opt-cons*,
					 subj <> ]]>].

bind-anc := anc-retrieval-rule &
		 headed-unary-rule-type &
		  inher-nonloc &
		  [synsem saturated-synsem & 
			  [loc [cat.extra-poss x_+,
				anc anc-inher-bound & [self <! !>,
						       active <! !>,
						       inert <! !>
			    ]],
			   phrase +,
			   lex -],
		   head-dtr #h,
		   args <#h & anc-retrieval-rule &
			 [synsem saturated-anc-to-bind-synsem & 
				 [loc.anc anc-to-bind & 
				      [self [
					     last *null*],
				       active [
					       last *null* ]
					    ],
				  phrase +,
				  lex -
				  ]
				 ]>].


find-anc := 
	    headed-unary-rule-type &
	    anc-retrieval-rule &
	    inher-nonloc &
	    [synsem saturated-anc-to-bind-synsem & 
		    [loc [adjunction modified-unmodifiable,
			  cat.extra-poss x_+,
			  anc anc-to-bind & 
				     [self #self,
				      active [list #rest,
					      last *null* ],
				      inert <! !>
					   ]],
		     phrase +,
		     lex -],
	     head-dtr #h,
	     args <#h & anc-retrieval-rule &
		   [synsem saturated-anc-to-bind-synsem & 
				[loc [adjunction modified-unmodifiable,
				      anc anc-to-bind & 
						 [self #self & [list <[]>,
								last *null*],
						  active [list <[] . #rest>,
							  last *null* ]
						       ]],
				 phrase +,
				 lex -
				     ]
			   ]>].
		  
		      


h-extra-rel-type := anc-retrieval-rule &
		    head-first-rule &
		    bin-headed-inher-rule-type &
		    head-non-valence-rule-type & 
		    [synsem saturated-anc-to-bind-synsem & 
			    [loc [cat [no_adj #no_adj,
				       extra-poss s-
					      ],
				  anc anc-to-bind & 
				      [self  <! [LBL #h,
						 index #i] !> ,
				       active #active ,
				       inert <! !>],
				  adjunction modified & 
				      unmodifiable,
				  sgf #sgf ],
			     v2  #v2,
			     phrase +,
			     lex -  ],
		     NON-HEAD-DTR [ synsem saturated-modifier-synsem & 
					   [loc [cat [ head rel-clause-head &
							    [ extra + ],
						       no_adj   #no_adj
							    ],
						 cont.modcont.hook [ltop #h,
						       index #i & [png 3-n-g]]],
					    nonloc contains-no-rel,
					    phrase +,
					    lex -
						],
				    vf -,
				    key-arg +
					   ],
		     head-dtr 
			    [ synsem  saturated-synsem &  
				      [loc [cat.extra-poss x_+,
					    adjunction modifiable,
					    anc anc-inher &
							   [self <! !>,
							    active #active & 
								 [last *null*]
								 ],
					    sgf #sgf],
				       v2  #v2
					   ]
				      ]
			     ].

		     

inher-anc-binary :=  cle-binary-rule &
		    [synsem.loc.anc anc-inher-unbound & 
				       [active [list #a1,
						last #a5],
					inert [list #i1,
					       last #i3]],
		     args <[synsem.loc.anc anc-inher & 
					      [active [list #a4,
						       last #a5],
					       inert [list #a3,
						      last #a4],
					       self [list #a1,
						     last #a2]]],
			   [synsem.loc.anc anc-inher & 
					      [active [list #a2,
						      last #a3],
					      inert [list #i2,
						     last #i3 ],
					      self [list #i1,
						    last #i2 ]]]> ].

inher-anc-unary :=  cle-unary-rule &
		    [synsem.loc.anc anc-inher-unbound & 
				      [active [list #a1,
					       last #a2],
					inert [list #i1,
					       last #i3]],
		     args <[synsem.loc.anc anc-inher &
					      [active [list #a1,
						       last #a2],
					       inert [list #i2,
						      last #i3 ],
					       self [list #i1,
						     last #i2 ]]]> ].




self-less-rule-type := grammar-rule &
		      [synsem.loc.anc anc-inher & [self <! !>]].
		      


det-or-np-n1-head-rule-type :=
			      anc-intro-sign &
			      inher-anc-binary &
			      head-last-rule          &
			      head-mrs-spec-binary-rule   & 
			      inher-nonloc2               & [
    synsem saturated-noun-synsem & [
           loc [ coord -,
                 CONT.MESSAGE #mess
               ],
           lex    -,
           phrase +
           ],
  ARGS <
         [ 
           synsem.loc.CONT.MESSAGE #mess,
	   vf -
         ],
         [
           synsem noun-synsem & [
                  loc.cat.subcat [list #last & *null*,
                                  last #last]
                  ],
           key-arg +
         ]
       >
  ].



det-n1-head-rule-type :=
  det-or-np-n1-head-rule-type &
  head-last-spec-p-2 & [
  synsem.loc.CONT [ hook.ltop #dhand
                  ],
  C-CONT [ RELS <! !>,                     
           HCONS <! !>
         ],
  ARGS <
         [ 
           synsem #c & [
                  loc [ cat.head det-head,
                        CONT [ hook.ltop #dhand

                             ]
                      ]
                  ] 
         ],
         [ synsem.loc [ cat.spr < #c >]
         ]
       >
  ].



np-n1-head-rule-type :=
  det-or-np-n1-head-rule-type & [
    synsem.loc.CONT [hook.ltop #uhand],
   C-CONT [ RELS <! udef_rel &
                          [ PRED "udef_q_rel",
			    ARG0 #noun-ind,
                            LBL #uhand,
                            RSTR #noun-hand],
		           unspec_mod_rel &
                          [PRED "unspec_mod_rel",
			   LBL #noun-hand,
                            ARG1    #noun-ind,
                            ARG2   #measure-ind ] !>,
                       
            HCONS <! !> 
           ],
  ARGS <
         [ synsem complete-ref-comp-noun-synsem & [ 
                  loc [ cat.head.cas #cas,
                        CONT [ hook [INDEX  #measure-ind & [
                                                      mass-unit +,
                                                      png 3-n-g
                                      ]],
                               key    std_nom_rel
				   ]
                      ],
                 phrase +
                 ]
         ],
         [
           synsem.loc [ cat [ HEAD.cas #cas,
                              spr < [] >
                            ],
                        UNIAGR c-s-g,
                        CONT [ hook [INDEX #noun-ind & 
					   [sort mass,
					    png 3-s-g
						 ],
				     ltop #noun-hand]
                             ]
                      ]
         ]
       >
  ].


empty-noun-modifier-rule-type :=
				inher-anc-unary &
                                inher-nonloc-unheaded-unary-rule  &
				self-less-rule-type &
                                adj-noun-sem-rule &                                
                                noun-sign.


rs-proj-rule-type :=
                    inher-nonloc-unheaded-unary-rule  &
                    noun-sign &
                    phrasal-sign &
		    constr-type &
		    [ c-cont [rels <! #key, #quant !>],
		      SYNSEM [ LOC [anc anc-inher & [self <! !>,
					 active <! !>,
					 inert <! !>
							  ],
				    CONT [ hook [INDEX #ind,
						 ltop #ltop],
                                          KEY #key &
                                                abstr_nom_rel &
                                                [ PRED "abstr_nom_rel",
						  ARG0 #ind,
						  LBL #hand ],
                                          RELS [ LIST < #quant & quant-or-wh-rel &
							[pred "udef_q_rel",
							 lbl #ltop,
							 arg0 #ind,
							 rstr #rest], #key . #adjsem >,
						 LAST #adjlast ],
					   HCONS [list <qeq &
							[harg #rest,
                                                         larg #hand] . #adj-hcons>,
						  last #adj-hlast] ]]],
                      ARGS < [ SYNSEM.LOC.CONT [ MODCONT.HOOK [ INDEX #ind,
								ltop #hand ],
                                                 RELS [ LIST #adjsem,
                                                         LAST #adjlast ],
						 HCONS [list #adj-hcons,
							last #adj-hlast] ]] > ].
                    

empty-noun-det-rule-type :=
  inher-nonloc-unheaded-unary-rule  &
  det-noun-sem-rule &
  noun-sign.


price-pp-noun-rule-type :=
  inher-nonloc-unheaded-unary-rule  &
  price-pp-noun-sem-rule &
  complete-ref-comp-noun-sign & [
  synsem.loc [cat.head.cas.morph-case nom-acc-dat-val,
              uniagr nda-n-g]
  ].

empty-det-rule-type :=
		      anc-intro-sign &
		      inher-anc-unary &
		      headed-unary-rule &
		      empty-det-sem-rule & 
		      [synsem saturated-noun-synsem & 
			      [loc [ cat.inflected #inflected,
				     coord -
						   ],
			       nonloc undef-nonlocs & [_slash #_slash,
						       slash #sl,
						       rel #rel],
			       que    #que,
			       lex -,
			       phrase #phrase
				   ],
		       head-dtr #hd,
		       ARGS < #hd &
			      [synsem [ loc [ cat [ head   lpe_-_noun-head,
						    spr    < det-synsem & 
							     [loc.cat.head.infl [UNIAGR #agr,
										 NODEF-AGR #agr,
										 NP-DECL 'st]
										] >,
						    subcat <! !>,
						    inflected #inflected
							   ],
                         coord -
                        ],
                    nonloc undef-nonlocs & [_slash #_slash,
					    slash #sl,
					    rel #rel],
                    que    #que,
                    phrase #phrase
                  ]
           ]
        >
  ].




n-mod-gen-np-rule-type :=
			 self-less-rule-type &
			 inher-anc-binary &
			 head-first-rule      &
			 head-mrs-constr-binary-rule    &
			 inher-nonloc2.


np-to-det-rule-type :=
		      unheaded-unary-rule & 
		      inher-anc-unary &
		      self-less-rule-type & 
		      constr-type &
		      det-sign & 
		      [c-cont [rels <! #key, #poss, #det !>],
		       synsem [loc [ cat.head.spec.loc.cont [hook [index #ind1],
							     key.lbl #hand1],
				     cont    [ hook [index #ind1],
					       KEY #key &
						     quant-rel &
						     [ PRED "def_q_rel",
						       ARG0 #ind1,
						       RSTR #rest1 ],
					       RELS [ LIST < #key,
							     #poss & poss-rel &
							     [ LBL #hand2,
							       ARG1 #ind2,
							       ARG2 #ind1 ],
							     #det &
							     udef_rel & 
							     [ PRED "udef_q_rel",
							       ARG0 #ind2,
							       RSTR #rest2 ] . #nounsem >,
						      LAST #nounlast
							   ],
					       HCONS [ LIST < qeq &
							      [HARG #rest1, 
							       LARG #hand1 ],
							      qeq &
							      [HARG #rest2, 
							       LARG #hand2 ] . #nounh-cons >, 
						       LAST #nounh-cons-last ]
                         ],
				     uniagr #agr,
				     coord -
							    ],
			       
				   nonloc #nonloc,
			       que    #que,
			       lex -,
			       phrase #phrase
				   ],
		       ARGS < [poss-aff +,
			       synsem  noun-synsem & 
					[loc [ cat [ head.cas.morph-case gen-val,
						    spr    < [ LOC.CONT.KEY #det ] >,
						    subcat <! !>
									],
					      cont [ key named_rel & 
							  [LBL #hand2,
							   ARG0 #ind2 ],
						     RELS [ LIST #nounsem,
							    LAST #nounlast ],
						     HCONS [ LIST #nounh-cons,
							     LAST #nounh-cons-last
								  ]
							  ],
					      uniagr #agr & g-n-g
						  ],
					nonloc #nonloc &  undef-nonlocs,
					que    #que,
				   phrase #phrase
						 ]
				       ]
			      >
			      ].

bin-headed-inher-rule-type :=
			     headed-binary-rule &
			     head-liszt-2-rule &
			     inher-nonloc2.



super-general-valence-rule-type :=
			    bin-headed-inher-rule-type & 
				  [synsem [ loc [ _third -,
						  cat [spr    #spr,
						       vcomp  <>,
						       no_adj #no_adj
							      ],
						  coord na_or_-,
						  adjunction #adj
							 ],
					    lex -,
					    phrase +,
					    v2     #v2
						],
				   head-dtr [synsem [loc [cat [spr    #spr,
							       vcomp <>,
							       no_adj #no_adj
								      ],
							  adjunction #adj
							      ],
						     v2  #v2
							 ]						    ],
				   non-head-dtr [
	       vf -
               ]
  ].


				  
general-valence-rule-type :=
			    self-less-rule-type &
			    inher-anc-binary &
			    super-general-valence-rule-type &
			    [head-dtr.key-arg +,
			     non-head-dtr.synsem.loc.cat.head.v1 *undef* ].

non-extraposed-rule-type := bin-headed-inher-rule-type &
                            [head-dtr [synsem.loc.cat.extra-poss x_- & s- ,
                                       key-arg +
                                       ],
			     non-head-dtr.synsem.loc.cat.head.extra na_or_-].

strict-non-extraposed-rule-type :=
				  non-extraposed-rule-type &
				  [non-head-dtr.synsem.loc.cat.head.extra -].


general-h-s-rule-type :=
                        general-valence-rule-type &
                        [synsem.loc [sgf sgf-lor+ & [lor <#sind>],
                                     cat [subj <>,
                                          subcat #sc],
                                     cont.hook.index [--tpc tpc-nonsubj]],
                         head-dtr [synsem.loc [sgf sgf-lor-lee-,
                                               cat [ head fin-verb-head,
                                                     subj <#subj & [loc.cont.hook.index #sind]>,
                                                     subcat #sc]]],
                         non-head-dtr [synsem #subj & 
					      saturated-synsem &
					      [loc [cat.head.v1 *undef*,
						    sgf sgf-lee-,
						    uniagr n-n-g]]]
					      ].
                          


general-h-c-rule-type := 
			 general-valence-rule-type &
			 [synsem.loc [sgf #sgf,
                                        cat [subj #subj,
					     subcat.list #rest]],
			  head-dtr.synsem.loc [sgf #sgf,
                                                 cat [subj #subj,
						      subcat.list <#c . #rest>]],
			  non-head-dtr.synsem #c ].


cf-s-rule-type :=
		 super-general-valence-rule-type &
		 head-first-rule &
		 [synsem [loc [sgf #sgf,
			       anc [self <! !>,
				    active <! !>,
				    inert <! !>],
			       cat [subj <>,
				    subcat [list <>,
					    last #last]]]],
		  head-dtr.synsem [loc [sgf #sgf,
					anc anc-inactive & 
					    [self <! !>,
					     active <! !>,
					     inert <! !>],
					cat [subj <>,
					     subcat [list <#c>,
						     last #last & *null*]]],
				   lex +],
		  non-head-dtr [key-arg +,
				synsem #c ]].



h-sgf-rule-type :=
		  inher-anc-unary &
		  self-less-rule-type &
		  headed-unary-rule-type & 
		  [synsem [loc [cat [subj <>,
				     vcomp <>,
				     subcat.list <>,
				     extra-poss x_-],
				adjunction unmodifiable,
				sgf sgf-lee+ & [lor <>,
						lee <#sind>],
				cont.hook.index.e tensed
				    ],
			   nonloc  undef-nonlocs,
			   phrase +],
		   head-dtr #hd-dtr & [synsem [loc [sgf sgf-lor-lee-,
						    cat [ head initial_+-or-eps-verb-head,
							  vcomp <>,
							  subj <ref-noun-synsem &
								[loc [uniagr n-n-g,
								      cont.hook.index #sind ]]>,
							  subcat.list <>]],
					       nonloc undef-nonlocs]],
		   args <#hd-dtr>].



imp-bin-rule-type :=
		    inher-anc-binary &
		    self-less-rule-type &
		    inher-nonloc2 &
		    collect-constr-2-liszt &
                [synsem verb-synsem &
                        [loc [cat [head initial_+_fin-verb-head &
					[mod #mod,
					 v1 #v1,
					 prd #prd,
					 extra #extra,
					 top #top,
					 aux #aux,
					 flip #flip,
					 log-subj #log-subj,
					 vform #vform,
					 passive #passive,
					 subj <#subj>],
                                   subj <>,
                                   subcat.list #sc,
                                   extra-poss x_-],
			      adjunction unmodifiable,
			      sgf sgf-lor-lee-,
			      cont [message #m,
				    hook [ltop #h0,
					  index #ind ] 
                                  ]],
			 nonloc #nonloc & undef-nonlocs,
			 phrase +],
		 C-CONT [ MESSAGE #m  & 
				  [PRED imp_m_rel,
				   LBL #h0,
				   ARG0 #ind,
				   MARG #h1],
			  RELS <! #m !>,
			  HCONS <! qeq & [HARG #h1,
					  LARG #lbl] !> ],
		 head-dtr #hd-dtr,
		 ARGS <#hd-dtr & [synsem [nonloc #nonloc,
					  loc [sgf sgf-lor-lee-,
				     cat [ head initial_+_fin-verb-head &
						[mod #mod,
						 v1 #v1,
						 prd #prd,
						 extra #extra,
						 top #top,
						 aux #aux,
						 flip #flip,
						 log-subj #log-subj,
						 vform #vform,
						 passive #passive,
						 subj <>],
					   subj <#subj &
						 ref-noun-synsem &
						 [loc [cont  personal-pronoun-sem-type &
							     [hook [index #p_ind & ref-ind ],
							      key [arg0 #p_ind & [png #png]]],
						       uniagr n-n-g & [png 3-p-g & #png]]]>,
					   subcat.list #sc],
				     cont [hook [index #ind & [e prs-sbj],
						 ltop #lbl]
					   ]]]],[synsem #subj]>
			].
		    

imp-rule-type :=
		inher-anc-unary &
		self-less-rule-type &
		headed-phrasal-sign &
                collect-constr-1-liszt &
                inher-nonloc &
                [synsem complete-comp-fin-verb-synsem &
                        [loc [cat [head initial_+_fin-verb-head &
					[mod #mod,
					 v1 #v1,
					 prd #prd,
					 extra #extra,
					 top #top,
					 aux #aux,
					 flip #flip,
					 log-subj #log-subj,
					 vform #vform,
					 passive #passive,
					 subj <#subj>],
                                   subj <>,
                                   subcat.list <>,
                                   extra-poss x_-],
			      adjunction unmodifiable,
			      sgf sgf-lor-lee-,
			      cont [message #m,
				    hook [ltop #h0,
					  index #ind & [e imp]]
                                  ]],
			 phrase +],
		 C-CONT [ MESSAGE #m  & 
				  [PRED imp_m_rel,
				   LBL #h0,
				   ARG0 #ind,
				   MARG #h1],
			  RELS <! #m , #pq, #p  !>,
			  HCONS <! qeq & [HARG #h1,
					  LARG #lbl], #hc !> ],
		 head-dtr #hd-dtr,
		 ARGS <#hd-dtr & [synsem [loc [sgf sgf-lor-lee-,
				     cat [ head initial_+_fin-verb-head &
						[mod #mod,
						 v1 #v1,
						 prd #prd,
						 extra #extra,
						 top #top,
						 aux #aux,
						 flip #flip,
						 log-subj #log-subj,
						 vform #vform,
						 passive #passive,
						 subj <>],
					   subj <#subj &
						 ref-noun-synsem &
						 [loc [cont  personal-pronoun-sem-type &
							     [hook [index #p_ind & ref-ind] ,
							      key #p & [pred "pron_n_rel",
								       arg0 #p_ind & [png #png]],
							      rels <! #p, #pq !>,
							      hcons <! #hc !>],
						       uniagr n-n-g & [png 2-n-g & #png]]]>,
					   subcat.list <>],
				     cont [hook [index #ind,
						 ltop #lbl]
					   ]]]]>
			].

                  

h-s-rule-type :=
                general-h-s-rule-type & 
                non-extraposed-rule-type &
                head-first-rule & 
                [synsem.loc.cat.head initial_+_fin-verb-head].

s-h-rule-type :=
                general-h-s-rule-type & 
                strict-non-extraposed-rule-type &
                head-last-rule &
                [synsem.loc.cat [head initial_-_fin-verb-head]].



h-c-rule-type :=
                  general-h-c-rule-type & 
                  non-extraposed-rule-type &
                  head-first-rule &
                  [synsem.loc [cat.head initial_+_noncomp-head]].




head-non-spr-rule-type := 
  headed-rule & [
  synsem.loc.cat.spr    #spr,
  head-dtr    [ synsem.loc.cat.spr    #spr
              ]
  ]. 

head-non-c-rule-type := 
  headed-rule & [
  synsem.loc.cat [subj #subj,
                  subcat #sc],
  head-dtr    [ synsem.loc.cat [subj #subj,
                                subcat #sc]
              ]
   ].

head-non-cluster-rule-type := 
  headed-rule & [
  synsem.loc.cat.vcomp #vc,
  head-dtr    [ synsem.loc.cat.vcomp #vc
              ]
  ].

head-non-c-non-spr-rule-type :=
  head-non-spr-rule-type &
  head-non-c-rule-type.

head-non-valence-rule-type :=
  head-non-c-non-spr-rule-type &
  head-non-cluster-rule-type.
  
headed-unary-non-valence-rule-type :=
  headed-unary-rule-type &
  head-non-valence-rule-type.


c-h-rule-type :=
                general-h-c-rule-type &
                head-last-rule & 
                strict-non-extraposed-rule-type &
                [head-dtr [ synsem.loc.cat.head initial_-_-head,
                            key-arg +
                                                ],
                 non-head-dtr.synsem saturated-synsem
                          ].







general-h-a-rule-type :=
			self-less-rule-type &
			inher-anc-binary &
			head-mod-liszt-2-rule &
                        bin-headed-inher-rule-type &
                        head-non-valence-rule-type & 
                        [synsem [ loc [_third -,
				       cat 
                                           [
                                           no_adj #no_adj
                                                       ],
                                       adjunction modified & modifiable,
                                       sgf #sgf ],
                                  lex -,
				  phrase #phrase,
                                  v2  #v2 
                                          ],
			 NON-HEAD-DTR [ synsem modifier-synsem & 
                                               [loc [cat [ head.mod #head-synsem,
							   subj <>,
							   vcomp <>,
							   spr <>,
							   subcat.list <>,
                                                          no_adj   #no_adj
                                                                   ],
						     sgf sgf-lee-],
                                                nonloc contains-no-rel
                                                        ],
                                        vf -,
                                        key-arg +
                                               ],
                         head-dtr    
                                [ synsem #head-synsem & 
                                         [loc [adjunction modifiable,
                                               sgf #sgf],
                                          v2  #v2,
					  phrase #phrase
                                                  ]
                                         ]
                                ].

h-a-rule-type :=
		non-extraposed-rule-type &
                head-first-rule &
                general-h-a-rule-type & 
                [synsem.loc.cat.extra-poss #ep,
                 head-dtr.synsem.loc.cat.extra-poss #ep & x_-,
                 NON-HEAD-DTR.synsem.loc.cat [head post-head-modifier-head 
                                                  ]].

a-h-rule-type :=
		strict-non-extraposed-rule-type &
                head-last-rule &
                general-h-a-rule-type & 
                [head-dtr.synsem.loc.cat.extra-poss x_-, 
                 NON-HEAD-DTR.synsem.loc.cat.head pre-head-modifier-head].


no-nonloc-headed-binary-rule-type :=
				    headed-binary-rule & 
				    collect-constr-2-liszt &
				    [ SYNSEM [LOC.CONT [message #mess,
							hook [index #ev,
							      ltop #h0]],
					      QUE <! !>],
				      NON-HEAD-DTR [SYNSEM [loc.cont.hook.index #i,
							    QUE [LIST  #l,
								 LAST  #l & *null* ]]],
				      HEAD-DTR [SYNSEM.LOC.CONT [hook [INDEX #ev,
								       ltop #h2]]],
				      C-CONT [   RELS <! #mess &
						       [PRED prop-or-ques_m_rel,
							LBL #h0,
							ARG0 #ev & event,
							MARG #h1,
							tpc #i] !>,
						   HCONS <! qeq & [HARG #h1,
								    LARG #h2] !> ]].

wh-no-nonloc-headed-binary-rule-type := 
					headed-binary-rule & 
					collect-constr-2-liszt &
					[ SYNSEM.LOC.CONT [message #mess,
							   hook [index #ev,
								 ltop #h0]],
					  NON-HEAD-DTR [SYNSEM [loc.cont.hook [index #i],
								QUE [LIST  < [] , ... >,
								     LAST *null*
								     ]]],
					  HEAD-DTR [SYNSEM.LOC [CONT [hook [INDEX #ev,
									    ltop #h2]]]],
					  C-CONT [ RELS <! #mess 
							    &
							   [PRED int_m_rel,
							    LBL #h0,
							    ARG0 #ev & event,
							    MARG #h1,
							    tpc #i] !>,
						   HCONS <! qeq & [HARG #h1,
								    LARG #h2] !> ]].

rel-or-interrogative-clause-rule-type :=
  unheaded-binary-rule   &
  collect-constr-2-liszt & [
  synsem complete-synsem & [ 
         loc [ cat.head rel-or-int-clause-head,
	       cont.message.tpc #i,
               coord -
             ],
         lex -,
         phrase +,
         v2     -
  ],
  ARGS < [
         key-arg +,
         synsem saturated-synsem & [loc.cont.hook.index #i,
                nonloc contains-no-slash
                ]
         ],
         [
         synsem saturated-comp-fin-verb-synsem & [ 
                loc [cat.head  v-final-head,
		     cont.hook.index event &  [--sub +]],
                lex -,
                v2  -
                ] 
         ]
       >
   ].



rel-clause-rule-type :=
  rel-or-interrogative-clause-rule-type &
  [ SYNSEM complete-noun-modifier-synsem & 
	   [loc [ cat [ head   rel-clause-head & 
			       [mod.loc.cont #modcont & 
					     [hook.index #ind
						    ],
				rp-head #rp-head
					     ],
			no_adj +
			       ],
		  CONT [ hook [ltop #h,
			       INDEX #i],
			 MESSAGE #m,
			 MODCONT #modcont &
				[ hook.ltop #h ],
			 KEY #key 
				],
		  anc anc-inher & [self <! !>,
				   active <! !>,
				   inert <! !>
					]
		      ],
	    que <! !>
		],
    C-CONT [ RELS <! #m  &
                      [ PRED prpstn_m_rel,
			LBL #h,
			ARG0 #i,
                        MARG #marg ] !>,
             HCONS <! qeq &
                       [ HARG #marg,
                         LARG #relc ] !> ],
    ARGS < [ SYNSEM [ LOC [ cat.head #rp-head
                          ],
                      NONLOC  contains-rel & [ 
                              rel.LIST.FIRST #ind & index
                              ]
                    ]
           ],
	   [ SYNSEM.LOC.CONT  [ hook [ltop #relc,
				      INDEX #i],
                                KEY #key] ] > ].


extraction-rel-or-int-clause-rule-type :=
  rel-or-interrogative-clause-rule-type & [
  ARGS < [synsem saturated-synsem & [
                loc #filler-local & [cat.head #filler-head,
				     cont #f-cont
					      ]
                ]
         ],
	 [synsem.nonloc contains-slash & [_slash <! [cat.head #filler-head,
						     cont #f-cont ] !>,
					 slash.LIST.FIRST #filler-local
						]]
       >
   ].


extraction-rel-clause-rule-type :=
  extraction-rel-or-int-clause-rule-type &
  rel-clause-rule-type.



int-clause-rule-type :=
  rel-or-interrogative-clause-rule-type &
  [ SYNSEM int-clause-synsem & [ 
           loc [CONT [ hook [ltop #h0,
			     INDEX #i],
                      MESSAGE #m,
                      KEY #key      
			      ],
		anc anc-inher & [self <! !>,
		     active <! !>,
		     inert <! !>
			  ]
		     ],
           que #que 
           ],
    C-CONT [ RELS <! #m &
		    [ PRED int_m_rel,
		      LBL #h0,
		      ARG0 #i,
		      MARG #marg ] !>,
             HCONS <! qeq &
                       [ HARG #marg,
                         LARG #relc ] !> ],
    ARGS < [ SYNSEM complete-synsem & [ 
		    que #que & singleton-diff-list &
		               [ LIST.FIRST individual,
				 LAST *null*
					    
                               ]
                    ]
           ],
	   [ SYNSEM.LOC.CONT  [ hook [INDEX #i,
				      ltop #relc],
				KEY #key
                                 ] ] > ].

extraction-int-clause-rule-type :=
  extraction-rel-or-int-clause-rule-type &
  int-clause-rule-type.


adjunct-v1-rule-type :=
  headed-binary-rule &
  head-mod-constr-2-rule &
  topic-mrs-marking-princ.



vc-rule-type :=
               headed-binary-rule &
               inher-nonloc2      &
               vc-mrs-binary-rule &
	       inher-anc-binary &
	       self-less-rule-type &
	       [synsem verb-synsem & 
		       [loc [ _third #3rd,
			      cat   [subj #subj,
				     vcomp  #vcomps
				      ],
			      cont [hook [index #i,
					  ltop #l]],
                              coord -,
                              sgf #sgf
                                    ],
                        nonloc #nonloc,
                        que    #que,
                        lex -,
                        phrase -,
                        v2     #v2
                            ],
                head-dtr     [ synsem verb-synsem & 
                                      [loc [cat  [ head final-verb-head,
                                                   subj #subj,
                                                   vcomp < #vc . #vcomps >,
                                                   extra-poss x_-
                                                        ],
                                            sgf #sgf & sgf-lee-,
					    cont [hook [index #i,
							ltop #l]]],
                                       nonloc undef-nonlocs,
                                       que    <! !>,
                                       lex    +,
                                       v2     #v2
                                            ],
                               key-arg +
                                      ],
                non-head-dtr [ synsem #vc & 
				      sp-sep-or-prd-adj-or-non-fin-verb-synsem & 
                                      [ loc [_third #3rd],
					nonloc #nonloc & contains-no-rel ,
                                        que    #que,
                                        phrase -
                                            ]
                                      ]
                       ].


vc-head-rule :=
               vc-rule-type & head-last-rule & [
  non-head-dtr.synsem [loc [cat [head.flip -]]]
  ].


third-construction :=
		     head-first-rule &
		     vc-mrs-binary-rule &
		     self-less-rule-type &
		     [synsem verb-synsem & 
			     [loc [ cat   [ head fin-verb-head,
					    subj #subj,
					    vcomp  <>,
					    subcat #sc],
				    cont.hook.index [--tpc tpc-nonevent],
				    coord -,
				    sgf #sgf,
				    anc #anc,
				    _third -
					  ],
			      nonloc #nonloc,
			      que    #que,
			      lex #lex,
			      phrase -,
			      v2     #v2
				  ],
		      head-dtr     [ synsem verb-synsem & 
					    [loc [adjunction unmodified,
						  _third +,
						  cat  [ head final-verb-head,
							 subj #subj,
							 subcat #sc,
							 vcomp < >,
							 extra-poss x_-
							      ],
						  sgf #sgf,
						  anc #anc],
					     nonloc contains-slash & 
						 [slash singleton-diff-list & 
							[list < #loc . #last>,
							 last #last ]],
					     que    <! !>,
					     phrase -,
					     lex #lex,
					     v2     #v2
						 ],
				     key-arg +
					    ],
		      non-head-dtr [ synsem non-fin-verb-synsem  & 
					    [ loc #loc & [cat [head coherent-inf-verb-head,
							       vcomp <>,
							       subcat.list *cons*]],
					      nonloc #nonloc,
					      que    #que ]
					    ]
			     ].


head-vc-rule :=   
  vc-rule-type & head-first-rule & [
  non-head-dtr [
           synsem non-fin-verb-synsem &
                  [ loc [cat [head.flip +,
                              extra-poss x_-]
                         ]
                  ]
         ]
  ].



headed-unary-rule-type :=
  headed-unary-rule   &
  head-sem-princ.


vc-slash-intro-rule :=
		      self-less-rule-type &
		      inher-anc-slash &
                      headed-unary-rule-type &
		      slash-intro-sign &
		      [synsem verb-synsem & [
           loc [ _third +,
		 cat [ head final-verb-head & [v1 *undef*],
                       subj #subj,
                       extra-poss #ep,
                       vcomp  <>
                     ],
		 cont [hook.index [--tpc tpc]],
                 coord     -
               ],
           nonloc contains-slash & 
	   [_topic-drop -, 
	    slash #slash],
           que    #que,
           lex +,
           phrase -,
           v2  -
           ],
  head-dtr #hd,
  ARGS < #hd & [
           synsem verb-synsem & [
                  loc [ cat [ head [aux -,
				    mod *undef*],
                              subj #subj,
                              extra-poss #ep,
                              vcomp < sp-sep-or-prd-adj-or-non-fin-verb-synsem & [ 
                                        loc #l & [ cat sp-or-prd-adj-or-non-fin-verb-cat &
						       [ head [extra na_or_-],
							 vcomp <>,
                                                         subcat.list *eps-2-list* ],
						   anc [self [list #a1,
							      last #a1],
							active [list #a1,
								last #a2],
							inert [list #a2]]
                                                       ],
                                        nonloc contains-slash & [
                                               slash #slash & [
                                                     LIST.FIRST #l
                                                     ]
                                               ]
                                       ] >
                              ]
                        ],
				 nonloc undef-nonlocs,
				 que    #que,
				 v2     -,
				 lex +,
				 phrase -
                  ]
         ]
       >
  ].





headed-constr-unary-rule-type :=
  headed-unary-rule   &
  head-constr-unary-sem-princ.

coordination-rule-type :=
                         unheaded-binary-rule &
			 coord-mrs-binary-rule &
			 [synsem.loc.anc anc-inher & [self <! !>,
					     active <! !>,
					     inert <! !>]].

temp-coordination-rule-type :=
			      unheaded-binary-rule      &
			      coord-mrs-binary-rule &
			      inher-nonloc2 &
			      [synsem.loc.anc anc-inher & [self <! !>,
						  active <! !>,
						  inert <! !>]].






adj-topic-drop-rule :=
		  headed-unary-rule & 
		  collect-constr-1-liszt  & 
		  [ SYNSEM.LOC.CONT [ modcont #modcont,
				      hook [INDEX #ev],
				      KEY #key
				      ],
		    HEAD-DTR.SYNSEM.LOC.CONT 
				    [
				     MESSAGE #m,
				     KEY #key,
				     MODCONT #modcont ] ] 
		  &
		  [
  synsem complete-comp-fin-verb-synsem & [
         loc [ cat   #mom-cat,
               adjunction unmodifiable,
               coord -,
               sgf #sgf,
	       anc anc-inher & [self <! !>,
				active <! !>,
				inert <! !>
				     ],
	       cont [hook.ltop #top]
             ],
         que <! !>,
         lex -,
         phrase  +,
         v2      +,
         ellipse +
         ],
  C-CONT [ MESSAGE #m  & [PRED prop-or-ques_m_rel,
			  LBL #top,
			  MARG #soa,
			  ARG0 #ev],
	   RELS [LIST < #m . #rlist >,
		 LAST #rlast],
           HCONS [LIST < qeq & [HARG #soa,
			    LARG #handel] . #hlist>,
		  LAST #hlast]],
 HEAD-DTR #hd,
 ARGS < #hd & 
	sign &
        [ synsem saturated-comp-fin-verb-synsem & 
		 [ loc [cat #mom-cat & [ head initial_+_fin-verb-head 
					      ],
			CONT [ hook [INDEX.E tensed,
				     ltop #handel ]],
			sgf #sgf
                            ],
                   nonloc contains-slash & [
			  _topic-drop +,
                          slash *diff-list* &
                                 [ LIST *cons* &
                                        [ FIRST [cat.head.mod synsem,
						 anc [self <! !>,
						      active <! !>,
						      inert <! !>
							   ],
						 cat.drop +,
						 CONT i-sect-adv-sem-type &
							      [
							       KEY [PRED "unspec_a_rel",
								    arg0 event,
								    LBL #l,
								    ARG1 #ev],
							       MODCONT.HOOK [ltop #l,
									     index #ev],
							       RELS [LIST #rlist,
								     LAST #rlast],
							       HCONS [LIST #hlist,
								      LAST #hlast ]]],
                                         REST  #last & *null* 
                                        ],
			           LAST #last 
                                 ]
                          ],
                   que <! !>,
                   v2 -
                  ]
            
        ] >
 ].


topic-drop-rule :=
		  headed-unary-rule & 
		  collect-constr-1-liszt  & 
		  [ SYNSEM.LOC.CONT [ hook [INDEX #i],
				      KEY #key,
				      MODCONT #modcont ],
		    HEAD-DTR.SYNSEM.LOC.CONT 
				    [hook [INDEX #i],
				     MESSAGE #m & [TPC #tpc],
				     KEY #key,
				     MODCONT #modcont ] ] 
		  &
		  [
  synsem complete-comp-fin-verb-synsem & [
         loc [ cat   #mom-cat,
               adjunction unmodifiable,
               coord -,
               sgf sgf-lor-lee-,
	       anc anc-inher & [self <! !>,
				active <! !>,
				inert <! !>
				     ],
	       cont [hook.ltop #top]
             ],
         que <! !>,
         lex -,
         phrase  +,
         v2      +,
         ellipse +
         ],
  C-CONT [ MESSAGE #m & [PRED prop-or-ques_m_rel,
			 LBL #top,
			 MARG #soa],
	   RELS [LIST < #m . #rlist >,
		 LAST #rlast],
           HCONS [LIST < qeq & [HARG #soa,
			    LARG #handel] . #hlist>,
		  LAST #hlast]],
 HEAD-DTR #hd,
 ARGS < #hd & 
	sign &
        [ synsem saturated-comp-fin-verb-synsem & 
		 [ loc [cat #mom-cat & [ head initial_+_fin-verb-head 
					      ],
			CONT [ hook [INDEX.E tensed,
				     ltop #handel] ]
			    
			    ],
                   nonloc contains-slash & [
			  _topic-drop +,
                          slash *diff-list* &
                                 [ LIST *cons* &
                                        [ FIRST [cat.head.mod *undef*,
						anc [self <! !>,
						     active <! !>,
						     inert <! !>
						     ],
                                                cat.drop +,
                                                CONT personal-pronoun-sem-type &
                                                [ hook [INDEX #tpc],
						  KEY [ PRED "unspec_pron_rel" ],
						  RELS [LIST #rlist,
							LAST #rlast],
						  HCONS [LIST #hlist,
							 LAST #hlast ]]
                                                ],
                                         REST  #last & *null* 
                                        ],
			           LAST #last 
                                 ]
                          ],
                   que <! !>,
                   v2 -
                  ]
            
        ] >
 ].

yes-no-q-rule :=
		headed-unary-rule & 
		collect-constr-1-liszt  & 
		[ SYNSEM.LOC.CONT [ hook [INDEX #i],
				    KEY #key,
				    MODCONT #modcont ],
		  HEAD-DTR.SYNSEM.LOC.CONT 
				  [hook [INDEX #i],
				   MESSAGE #m,
				   KEY #key,
				   MODCONT #modcont ] ] 
		&
		  [
  synsem complete-comp-fin-verb-synsem & [
         loc [ cat   #mom-cat,
               adjunction unmodifiable,
               coord -,
               sgf #sgf,
	       anc anc-inher & [self <! !>,
				active <! !>,
				inert <! !>
				     ],
	       cont [hook [ltop #top]]
             ],
         que <! !>,
         lex -,
         phrase  +,
         v2      +,
         ellipse +
         ],
  C-CONT [ MESSAGE #m  & [PRED int_m_rel,
			  ARG0 #i,
			  LBL #top,
			  MARG #soa],
	   RELS <! #m !>,
           HCONS <! qeq & [HARG #soa,
			    LARG #handel]!> ],
 HEAD-DTR #hd,
 ARGS < #hd & 
	[ synsem complete-comp-fin-verb-synsem & 
		 [ loc [cat #mom-cat & [ head initial_+_fin-verb-head 
					      ],
			CONT [ hook [INDEX [--tpc tpc-,
					    E prs-ind+pst],
				     ltop #handel] ],
			sgf #sgf
			    ],
		   que <! !>,
		   v2 -
                  ]
            
        ] >
 ].





topic-drop-adj-rule :=
  headed-unary-rule-type & [
  synsem complete-comp-fin-verb-synsem & [
           loc [ cat   #mom-cat,
                 coord -,
                 CONT  #cont
               ],
           lex -,
           phrase +,
           v2     +,
           ellipse +
          ],
 ARGS < [ synsem complete-comp-fin-verb-synsem & [
                  loc [ cat #mom-cat & [ head initial_+_fin-verb-head 
                                       ],
                        CONT #cont & [hook [INDEX.E tensed]
                             ] 
                      ],
                   v2 -
                  ]
            
        ] >
 ].


interjection-rule-type :=
			 collect-constr-2-liszt &  
			 inher-nonloc2                 &
			 inher-anc-binary &
			 [ C-CONT [ RELS <! !>,
				    HCONS <! !> ] ].


interjection-rule :=
  interjection-rule-type & 
  [ synsem complete-synsem &
           [ loc [ cat.head turn-seq-head,
                   coord -
                 ],
             lex -,
             phrase +,
             v2  #v2 
           ],
  head-dtr #hd,
  NON-HEAD-DTR #non-head,
  ARGS < #non-head &
         [ synsem interjection-synsem-syn &
                  [ 
                    lex +
                  ],
           key-arg +
         ],
         #hd & [
         synsem complete-synsem & [
                v2 #v2
                ]
         ]
       >
   ].



interjection-rule-v-scnd := interjection-rule & 
		       [ SYNSEM.LOC.CONT [ hook [INDEX #i,
						 ltop #h3],
					   MESSAGE #subm,
					   KEY #key,
					   MODCONT #modcont ],
			 NON-HEAD-DTR.SYNSEM.LOC.CONT 
					 [hook [ltop #h3,
						INDEX #i],
					  KEY.ARG1 #h2],
			 HEAD-DTR [c-cont [MESSAGE #subm,
					   RELS.list <#subm, ...>],  
				   SYNSEM.LOC.CONT 
					  [hook [ltop #h2],
					   MESSAGE #subm & [LBL #h2],
					   KEY #key,
					   MODCONT #modcont ]],
			 ARGS < [] , [synsem [loc [ cat.head initial_+_fin-verb-head  ],
					      V2 +
						  ]
					     ] > ].

interjection-rule-v-fst := interjection-rule & 
			   [SYNSEM.LOC.CONT [ hook [ltop #h3,
						    INDEX #i],
					      message #subm,
					      KEY #key,
					      MODCONT #modcont ],
			    NON-HEAD-DTR.SYNSEM.LOC.CONT 
					    [KEY.ARG1 #h2,
					     hook [index #i,
						   ltop #h3]],
			    HEAD-DTR [c-cont [MESSAGE #subm,
					      RELS.list <#subm, ...>],  
				      SYNSEM.LOC.CONT 
					     [hook [ltop #h2],
					      MESSAGE #subm & [LBL #h2],
					      KEY #key,
					      MODCONT #modcont ]],
			    ARGS < [] , [
					 synsem [
	loc [ cat.head initial_+_fin-verb-head
            ],
        V2 -
        ]
 ] > ].


interjection-rule-non-v := interjection-rule & [
  ARGS < [] , [
  synsem.loc [ cat.head non-verbal-root-head,
               CONT [MESSAGE no_msg
                   ]
            ]
  ] > ].

interjection-rule-coord := interjection-rule & [
  ARGS < [] , [
  synsem.loc [ cat.head coord-head & [ 
                       spec complete-synsem,
                       coordform normal-coord
                       ],
               CONT [MESSAGE no_msg
                   ]
            ]
  ] > ].



q-tag-rule :=
	     collect-constr-2-liszt &  
	     non-head-dtr-sign &
	     headed-phrasal-sign &
	     inher-anc-binary &
	     [ synsem complete-synsem &
		      [ loc [ cat.head turn-seq-head,
			      coord -
                 ],
             lex -,
             phrase +,
             v2  #v2 
           ],
	       head-dtr #hd,
	       NON-HEAD-DTR #non-head,
  ARGS < #hd & [
         synsem complete-synsem & [ 
                  v2 #v2
                ]
         ],
         #non-head &
         [ synsem q-tag-synsem-syn &
                  [ 
                    lex +
                  ],
           key-arg +
         ]
	 >
		      ].



q-tag-rule-decl-imp := q-tag-rule & 		
		       [ SYNSEM.LOC.CONT [ hook [ltop #h0,
						 INDEX #i],
					   message #m,
					   KEY #key,
					   MODCONT #modcont ],
			 NON-HEAD-DTR.SYNSEM.LOC.CONT 
					 [hook [ltop #h0],
					  KEY.ARG1 #i 
					      ],
			 HEAD-DTR [c-cont [MESSAGE #subm,
					   RELS.list <#subm, ...>],  
				   SYNSEM.LOC.CONT 
						     [hook [ltop #h2],
						      MESSAGE #subm & 
							   [pred prop_imp_m_rel,
							    LBL #h2],
						      KEY #key,
						      MODCONT #modcont ]],
			 C-CONT [RELS <! #m & [PRED int_m_rel,
							   LBL #h0,
							   arg0 #i,
							   marg #h2]!>,
				 HCONS <! !>],
			 args <[synsem [
	loc.cat.head initial_+_fin-verb-head,
					v2 +
	]
				       ] , []> ].


q-tag-rule-quest := q-tag-rule & 
		    [ SYNSEM.LOC.CONT [ hook[ltop #h0,
					     INDEX #tagi],
					KEY #key,
					message #m,
					MODCONT #modcont ],
		      NON-HEAD-DTR.SYNSEM.LOC.CONT 
				      [hook [index #tagi,
					     ltop #h2]],
		      HEAD-DTR.SYNSEM.LOC.CONT 
				      [hook [ltop #h2,
					     INDEX #i & [e imp+prs-ind+pst]],
				       MESSAGE #m,
				       KEY #key,
				       MODCONT #modcont ],
		      C-CONT [RELS <! #m & [pred  int_m_rel,
					    LBL #h0,
					    ARG0 event & #i,
					    marg #h1]!>,
			      HCONS <! qeq & [harg #h1,
					       larg #h2] !>],
		      args <[synsem [
	loc.cat.head initial_+_fin-verb-head,
				     v2 -
	]
				    ] , []> ].



q-tag-rule-non-v := q-tag-rule & [C-CONT [RELS <! !>,
					   HCONS <! !>],
				  ARGS < [
  synsem.loc [ cat.head non-verbal-root-head,
               CONT [ 
                     MESSAGE no_msg
                   ]
            ]
 ], [] > ].


q-tag-rule-coord := q-tag-rule & [
  ARGS < [
  synsem.loc [ cat.head coord-head & [ 
                        spec complete-synsem,
                        coordform normal-coord
                        ],
               CONT [ MESSAGE no_msg
                   ]
            ]
 ], [] > ].

extraposition-rule-type :=
  bin-headed-inher-rule-type & [
  synsem       verb-synsem & [loc.cat.extra-poss x_+ & s-],
  head-dtr     #hd,
  non-head-dtr #nhd,
  args < #hd & [ 
         synsem verb-synsem & [ 
                loc [cat [ head       final-verb-head,
                           extra-poss x_+ & s-,
                           subcat.last *null* 
                        ]
                         ]
                ]
         ],
         #nhd & [ 
         synsem saturated-synsem & [
                loc [cat [ head  extrapos_head & [
                                extra +
                                ]
                        ],
	             sgf sgf-lee- ] 
                ]
         ]
       >
  ].

h-extra-s-rule-type :=
                      extraposition-rule-type &
                      general-h-s-rule-type &
                      [head-dtr.synsem.loc.cat.extra-poss x_c+].
                      

h-extra-c-rule-type :=
                        extraposition-rule-type &
                        general-h-c-rule-type &
                        [head-dtr.synsem.loc.cat.extra-poss x_c+,
			 non-head-dtr.synsem.loc.uniagr c-n-g ].



h-extra-a-rule-type :=
                      extraposition-rule-type &
                      general-h-a-rule-type & 
                      [synsem.loc.cat.extra-poss #ep,
                       head-dtr.synsem.loc.cat.extra-poss #ep & x_a+].



super-adj-slash-intro-rule :=
			     self-less-rule-type &
			     inher-anc-slash &
                             headed-unary-non-valence-rule-type &
			     slash-intro-sign &
                             [synsem [ loc [_third -,
					    cat [vcomp <>,
                                                 extra-poss s-],
                                            coord     -,
					    cont.message.tpc #i,
                                            adjunction modified,
                                            sgf #sgf ],
                                       v2 -,
				       lex #lex,
				       phrase +,
                                       nonloc contains-slash & 
					   [slash [ LIST.FIRST [cat 
								    [head verb-modifier-head &
									  [mod #head-synsem
                                                                               ],
                                                                     subj <>,
                                                                     spr      <>,
                                                                     subcat   <! !>,
                                                                     vcomp    <>],
                                                                cont [hook.index #i,
								      modcont #cont ]
                                                                    ] 
                                                               ]
                                                  ]
                                           ],
                              ARGS < #hd & 
				     [synsem #head-synsem & verb-synsem &
					     [loc [cat [head [mod *undef*],
							vcomp <> ,
							extra-poss s+ ],
						   cont #cont & [hook [index [--tpc tpc-mod]]],
						   sgf #sgf & sgf-lee-,
						   adjunction modifiable
						       ],
					      nonloc undef-nonlocs,
					      v2     -,
					      lex #lex,
					      phrase  -
						  ]
					     ]
				     >,
			      head-dtr #hd
				     ].







adj-slash-intro-rule-final :=
                             super-adj-slash-intro-rule &
			     [synsem [loc [cat.head final-verb-head,
					   adjunction modified],
				      nonloc contains-slash & 
					  [slash <! [cat.head pre-head-modifier-head] !>  ]],
			      args <[synsem.loc.adjunction unmodified]>].

adj-slash-intro-rule-initial :=
                               super-adj-slash-intro-rule &      
			       [synsem [loc [cat.head initial_+_fin-verb-head],
					nonloc contains-slash &
					    [slash <! [cat.head post-head-modifier-head] !>]],
				args <[synsem.loc.adjunction unmodified]>].






apposition-rule-type :=
 bin-headed-inher-rule-type &
 head-constr-2-rule & 
 head-first-rule & [
 synsem.loc [cat #cat,
	     uniagr #agr,
             adjunction #adj],
 HEAD-DTR #hd,
 ARGS < #hd & 
        [ synsem complete-ref-noun-synsem & [
                 loc [ cat #cat,
		       uniagr #agr,
                       adjunction #adj,
                       cont [hook [index #2]]
                     ]
                 ]
        ],
        [ synsem complete-ref-noun-synsem & [
                 loc [ cat #cat,
		       uniagr #agr,
                       adjunction #adj,
                       cont.hook.index #2
                     ]
                 ]
        ] >
].

  

enge-apposition-rule-type :=
			    self-less-rule-type &
			    inher-anc-binary &
			    inher-nonloc2 &
			    head-first-rule    &
			    head-constr-2-rule & 
			    [synsem.loc [cat #cat,
					 adjunction #adj
					     ],
			     C-CONT [RELS <! [LBL #l,
					      PRED "appos_rel",
					      ARG0 event,
					      ARG1 #1,
					      ARG2 #2] !>,
				     HCONS <! !>],
			     HEAD-DTR #hd,
			     ARGS < #hd & 
				    [ synsem count-noun-synsem & [
                 loc [ cat [ subcat <! !> 
                           ],
                       adjunction #adj,
		       cont.hook [LTOP #l,
				  index #1 & [ sort human
                                       ]]
                     ],
                 phrase -,
                 lex    +
                 ]
        ],
        [ synsem complete-ref-noun-synsem & [
                 loc [ cat #cat,
                       adjunction #adj,
                       cont [ hook [index #2],
			      KEY named_rel
				   ]
			   ]
		 ]
		 ] >
					].


;;; Verb movement


;; changed temporarily to phrase - , see if that will rule out non-intraposed VPs with opt coherence
;; rel   #rel & <! !>, ;; in RS gibt es keine Verbbewegung

; BC 31/7/03: Backporting to syntactic mod attachment: disabling restriction on adjunction feature on DTR    loc.adjunction unmodified 
; See also vc-head


super-eps-rule :=
		 self-less-rule-type &
                 eps-vc-sem-transport-rule & 
                 unheaded-unary-rule & 
                 [synsem fin-verb-synsem & 
                         [loc [cat [subj *eps-1-no-sp-list*,
				    subcat.list *eps-4-no-sp-list*,
				    head eps-verb-head & [_v1-hd #hd,
							  _v1.cat.vcomp <[loc [cat.head #hd,
									       cont [hook [index #e,
											   ltop #h]]]], ...>]],
			       cont [hook [index event & [--sub -],
					   ltop handle] 
					  ],
			       sgf sgf-lor- ],
			       nonloc contains-no-rel,
			  v2 -,
			  phrase -,
			  cat-change +
			      ],
		  ARGS < [ synsem [loc [cat.head #hd,
					cont [hook [index #e & [--sub -],
						    ltop #h]]],
				   phrase -,
				   nonloc contains-no-rel],
			   vf - ] >
			 ].

;; the restriction of the V1 SUBCAT to be of at most length 2 is not appropriate with particles
;; being part of the predicate complex, since `ankaufen' may have four complements

;; the VCOMP of the mother is either the empty list
;; or a zu-inf verb (anfangen in the coherent construction) or an adjective (das sieht gut aus.)


eps-vc-rule-part :=
		   inher-nonloc &
		   inher-anc-unary &
		   super-eps-rule &
                   [synsem [loc [_third -,
				 cat [ head [ aux      #aux,
					      _v1 [cat [subj #subj,
							subcat.list #sc]],
					      v1       fin-verb-local & 
						       [ cat [ head [ aux #aux
									  ],
							       subj #subj,
							       subcat.list #sc,
							       vcomp  < #vcomp . #mom-vcomp >
								    ]
							     ]
						       ],
				       subcat.list #sc & *eps-3-no-sp-no-rel-synsem-list*,
				       subj #subj,
				       vcomp  #mom-vcomp & *vc-eps-list*
					    ]
					]
				],
                    ARGS < [ synsem #vcomp & 
				    sp-or-prd-adj-or-non-fin-verb-synsem & 
                                    particle-sep-or-nonsep-synsem & 
                                    [loc  
                                          [ cat [
						 erg-subtr -,
                                                 vcomp <>,
                                                 subcat.list <>,
                                                 extra-poss x_-]],
                                     phrase -
                                          ]
                                    ]
                           >
                           ].

eps-vc-slash-intro-rule-part :=
			       inher-anc-slash &	       
			       super-eps-rule &
			       slash-intro-sign &
			       [synsem [loc [_third +,
					     cat [head [aux #aux,
							_v1 [cat.subj #subj],
							v1  fin-verb-local & 
							    [cat [head [aux #aux
									    ],
								  subj #subj,
								  subcat.list <>,
								  vcomp  < #vcomp , 
									   [loc #l & 
										[ cat prd-adj-or-non-fin-verb-cat & 
										      [head.extra na_or_-,
										       vcomp <>,
										       subcat.list #sc & 
												  *eps-2-list* ],
										  anc [self [list #a1,
											     last #a1],
										       active [list #a1,
											       last #a2],
										       inert [list #a2]]
										      ],
									    nonloc contains-slash & 
										[slash #slash & 
										       [LIST.FIRST #l
												   ]
										       ]
										]>
								       ]
								 ]
							    ],
						  subcat.list #sc & *eps-3-no-sp-no-rel-synsem-list*,
						  subj #subj,
						  vcomp  <>
						       ],
					     cont [hook [index #ev & 
							       event & 
							       [e [tense present+past,
								   perfective -,
								   stative -],
								--psv -]]],
						   coord -
						   ],
					nonloc contains-slash & 
					    [ _topic-drop -,
					      slash #slash],
					que #que
					    ],
				ARGS < [ synsem #vcomp & 
						sp-or-prd-adj-or-non-fin-verb-synsem & 
						particle-sep-or-nonsep-synsem & 
						[loc  [ cat [head._vc sp-form_+,
							     erg-subtr -,
							     vcomp <>,
							     subcat.list <>,
							     extra-poss x_-],
							cont [hook [index #ev]]],
						 nonloc  undef-nonlocs ,
						 que #que,
						 v2 -,
						 phrase -
						      ]
						]
				       >
				       ].



; Backport to syntactic modifier attachment: relaxing extra-poss x_- to x_c-
restr-eps-vc-rule :=
		    inher-nonloc & 
		    inher-anc-unary &
                    super-eps-rule &
                    [synsem [ loc [ _third #3rd,
				    cat [ head [ aux      #aux,
                                                 v1       fin-verb-local & 
                                                          [cat [ head [ aux #aux],
                                                                 subcat.LIST *eps-1-list*,
                                                                 subj #subj ,
                                                                 vcomp  < #vcomp >
                                                                      ]
                                                               ]
							  ],
                                          subj #subj,
                                          subcat.list *eps-3-no-sp-no-rel-synsem-list*,
                                          vcomp  <>]
                                        ]
                                  ],
		     ARGS < [ synsem #vcomp & 
                                     sp-or-prd-adj-or-non-fin-verb-synsem & 
                                     [loc [_third #3rd,
					   cat [vcomp <>,
                                                extra-poss x_c-
                                                      ]
                                               ],
                                      phrase -                                          
                                          ]
                              
                                     ]
                            >
                            ].


eps-vc-rule-1+ := restr-eps-vc-rule & 
		  [synsem.loc.cat.head [_v1.cat [subj <[loc.cont.hook [index #si,
								       ltop #sl]]>,
						 subcat.list < [loc.cont.hook [index #ci,
									       ltop #cl]]>],
					v1.cat [subj <saturated-noun-synsem & 
						     [loc [uniagr n-n-g,
							   cont.hook [index #si,
								      ltop #sl]]]>,
						subcat.list < [loc [uniagr da-n-g,
								    cont.hook [index #ci,
									       ltop #cl]]]>]],
                  args.FIRST.synsem adj-prd-or-coherent-complement-verb-synsem & 
					     [loc.cat.head adj-or-inf-or-bse-verb-head &
							   [subj <saturated-ref-noun-synsem>]]].

eps-vc-rule-s0-1+ := restr-eps-vc-rule & 
		     [synsem.loc.cat.head [_v1.cat [subcat.list <[loc [uniagr d-n-g,
								       cont.hook [index #ci,
										  ltop #cl]]]>]  ,
					   v1.cat [subj #subj,
						   subcat.list < [loc [uniagr d-n-g,
								       cont.hook [index #ci,
										  ltop #cl]]]>]],
		      args.FIRST.synsem adj-prd-or-coherent-complement-verb-synsem & 
					  [loc.cat.head adj-or-inf-or-bse-verb-head & 
							[subj #subj & *empty-or-expl-synsem-list*]]].

inher-anc-slash := *rule* &
		  [synsem [loc.anc anc-inher & 
				   [active [list #a1 ,
					    last #a5],
				    inert [list #in1,
					   last #in3]],		 
			   nonloc contains-slash &
				   [slash [list <[anc [self [list #a2 ,
							     last #a3],
						       active [list #a3,
							       last #a4],
						       inert [list #a4,
							      last #a5]]] . #last>,
					   last #last]
					  ]],
		   args <[synsem.loc.anc anc-inher &
					 [self [list #in2,
						last #in3],
					  active [list #a1,
						  last #a2],
					  inert [list #in1,
						 last #in2]]]> 
			  ].



		  
slash-intro-rule-type :=
			self-less-rule-type &
			inher-anc-slash &
			headed-unary-rule-type & 
			slash-intro-sign &
			[synsem [loc [cont.message [tpc #i],
				      cat [vcomp  <>
						   ],
					coord     -],
				  nonloc contains-slash & 
				     [slash <! [cont.hook.index #i] !>],
				  lex -,
				  phrase +, 
				  v2  -
				      ],
			 head-dtr #hd,
			 ARGS < #hd & 
				[synsem [loc [cat [ head fin-verb-head & 
							  non-mod-non-coord-head,
						    vcomp <>,
						    extra-poss s+ & x_-
							  ],
					       adjunction unmodified
						   ],
					  nonloc undef-nonlocs,
					  v2     -,
					  phrase -
					      ]
				 
					]
				>
				].



;; BC: UNified version of SGF and subj extraction
subj-slash-intro-rule := 
			 slash-intro-rule-type &
			 [synsem [loc [cont.hook.index  [--tpc tpc-subj],
				       sgf sgf-lee+ & [LEE <#sind>],
				       cat [subj <>,
					    subcat #sc & 
						 [list *eps-no-sp-undef-nonlocs-synsem-list* ]]],
				  nonloc.slash #slash],
			  head-dtr.synsem [loc [cat [subj <[ loc #l & 
								 [cont.hook.index #sind,
								  cat.head no-eps-head & 
									   [top  +]
									   
									   ],
							   nonloc contains-slash & 
							   [slash #slash & 
								  [LIST.FIRST #l
									      ]
								  ]
								 ]>,
					   
							 subcat #sc]]]].


comp-slash-intro-rule := 
			 slash-intro-rule-type &
			 [synsem [loc [sgf #sgf & sgf-lee-,
				       cont.hook.index [--tpc tpc-comp],
				       cat [
					    subj #subj & *eps-1-no-sp-undef-nonlocs-synsem-list*,
					    subcat.list #sc &  *eps-no-sp-undef-nonlocs-synsem-list*]],
				  nonloc.slash #slash],
			  head-dtr.synsem [loc [sgf #sgf,
						cat [subcat.list <[ loc #l & 
							       [cat.head no-eps-head & 
									 [top +]
									 ],
							   nonloc contains-slash & 
							       [slash #slash & 
								      [LIST.FIRST #l
										  ]
								      ]
							       ] . #sc>,
					   
							 subj #subj]]]].



inher-anc-pvp-rule :=
		     self-less-rule-type &
		     inher-anc-slash &
		     headed-unary-rule-type & 
		     
		     [synsem fin-verb-synsem & 
			     [loc [ cat [ vcomp <>,
					  subj #subj,
					  subcat.list  *eps-undef-nonlocs-synsem-list*
						]
					],
			      nonloc contains-slash & [rel #rel,
						       slash singleton-diff-list & 
							   [LIST.FIRST #vcomp & [cat [drop -, 
										      head [extra na_or_-,
											    top +]
											   ]
									    ]
								       ]
							   ],
			      v2 #v2,
			      lex +,
			      phrase -
			],
		      ARGS <   [synsem verb-synsem
				       & 
				       [loc [ cat [ head  initial_+_fin-verb-head,
						    vcomp <  
							     [loc #vcomp & 
								  [cat [vcomp <>,
									subcat.list  *eps-2-list* 
									      ]]]>,
						    subj #subj
							  ]
						  ],
					nonloc undef-nonlocs & 
				  [rel #rel
				       ],
					v2 #v2
					    ]
				       ]
			       > 
			     ].


pos-es :=
	 headed-binary-rule & 
	 collect-constr-2-liszt &
	 [ SYNSEM [LOC.CONT [message #mess,
			     hook [index #ev,
				   ltop #h0]],
		   QUE <! !>],
	   NON-HEAD-DTR [SYNSEM [QUE [LIST  #l,
				      LAST  #l & *null* ]]],
	   HEAD-DTR [SYNSEM.LOC.CONT.hook [INDEX #ev,
					   ltop #h2]],
	   C-CONT [   RELS <! #mess &
			    [PRED prop-or-ques_m_rel,
			     LBL #h0,
			     ARG0 #ev & event,
			     MARG #h1 ] !>,
		      HCONS <! qeq & [HARG #h1,
				      LARG #h2] !> ]] &
	 [synsem complete-synsem & [ 
	 loc [ sgf #sgf & sgf-lee-,
	       cat.extra-poss x_-,
	       coord -,
	       adjunction unmodifiable,
	       anc anc-inher & [self <! !>,
				active <! !>,
				inert <! !>
				     ]
		   ],
				     lex -,
				     phrase +,
				     v2     +],
	  head-dtr #hd,
	  non-head-dtr #nhd,
	  ARGS < #nhd & 
		 [
	   key-arg +,             
		  synsem expl-noun-synsem
	   ],
		 #hd &  [
	   synsem s-v1-synsem & 
	   [ 
		  loc [sgf #sgf,
		       cont.hook.index.--tpc tpc-,
		       cat.head.extra na_or_- ]
                  ]
	   ]
		 >
		 ].




left-dislocation-rule :=
			headed-binary-rule &
			head-constr-2-rule &
			inher-nonloc2 &
			inher-anc-binary & 
			[c-cont [hcons <! !>,
				 rels <! [pred "appos_rel",
					  lbl #l,
					  arg1 #1,
					  arg2 #2] !>],
			 synsem complete-ref-comp-noun-synsem & 
				[loc [ uniagr #agr,
				       cat   #cat,
				       adjunction #adj,
				       coord -,
				       CONT [ hook [ltop #l,
						    index #1],    
					      key   #key
						   ]
					      ],
				 lex -,
				 phrase +
				     ],

				vf +,
			 
				ARGS < [ synsem complete-ref-comp-noun-synsem & 
						[loc [ uniagr #agr,
						       cat   #cat,
						       adjunction #adj,
						       cont [ hook [index #2],
							      key  #key & 
								   reg-nom-rel
								   ]
							      ]
						     ],
					 vf -,
					 key-arg +
						],
				       [ synsem d-pron-synsem & 
						[loc [ uniagr #agr,
						       cat   #cat & 
							      [head.top + ],
						       adjunction #adj,
						       cont.hook [ltop #l,
								  index #1
							      ]]
						     ]
						]
				       >
				].


rc-left-dislocation-rule :=
  inher-anc-binary &
  bin-headed-inher-rule-type & [
  synsem complete-ref-comp-noun-synsem & [
         loc [ uniagr #agr,
	       cat   #cat,
               adjunction #adj,
               coord -,
	       CONT [ hook [index #ind],    
                      key   #key
                    ]
             ],
         lex -,
         phrase +
         ],
 vf +,

 ARGS < extraction-rel-clause-rule-type & 
	[synsem  [loc [uniagr #agr,
		       adjunction #adj,
		       cont.modcont [hook [ index #ind],
				     key   #key & reg-nom-rel
                            ]
                     ]
                 ],
           vf -,
           key-arg +
        ],
        [ synsem d-pron-synsem & [
                 loc [ uniagr #agr,
		       cat   #cat & [ head.top + ],
                       adjunction #adj,
                       cont.hook.index #ind
                     ]
                 ]
        ]
      >
 ].