;;; -*- Mode: tdl; Coding: utf-8; -*-
;;;
;;;  Copyright (c) 1994-2013
;;;    Dan Flickinger, Rob Malouf, Emily M. Bender
;;;    see LICENSE for conditions
;;;
;;;  letypes.tdl
;;;
;;;  Lexical entry types (yield of lextypes hierarchy)
;;;
;;;  Created by Dan Flickinger, 15-June-1996
;;;
;;;  $Id: letypes.tdl 7479 2010-02-21 23:11:30Z danf $


; In the following type names, "mv" stands for "main_verb".  Complements
; marked with "*" in the type names are optional. 

; <type val="v_-_it_le">
; <description>It-subj
; <ex>It rains.
; <nex>
; <todo>
; </type>
v_-_it_le := main_verb & 
  [ SYNSEM atrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM atrans_verb_min ] ].

; <type val="v_vp_it_le">
; <description>It-subj, Comps: VP (inf)         
; <ex>It sufficed to wait.
; <nex>
; <todo>
; </type>
v_vp_it_le := main_verb & 
  [ SYNSEM atrans_inf_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM atrans_verb_min,
			 VAL.COMPS < [ OPT - ] > ] ] ].

; <type val="v_cp_le">
; <description>Cmps S (fin, +/-Q, opt cmplzr)   
; <ex>B proved (that) C won.
; <nex>
; <todo>
; </type>
v_cp_le := main_verb & 
  [ SYNSEM cp_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_intrans_verb_min ] ].

; <type val="v_cp_comp_le">
; <description>Cmps S (fin, +/-Q, obl cmplzr)   
; <ex>B didn't mind that C won.
; <nex>
; <todo>
; </type>
v_cp_comp_le := main_verb & 
  [ SYNSEM cp_intrans_verb_comp & 
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_intrans_verb_comp_min ] ].

#|
; 'warn' - can appear in quoted inversion
; <type val="v_cp_invable_le">
; <description>Cmps S (fin, invertable)         
; <ex>B would win, C warned.
; <nex>
; <todo>
; </type>
v_cp_invable_le := main_verb & 
  [ SYNSEM cp_intrans_invable_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_intrans_invable_verb_min ] ].
|#

; <type val="v_cp_fin-inf_le">
; <description>Cmps S (fin/inf, +/-Q)           
; <ex>B forgot whether to jump.
; <nex>
; <todo>
; </type>
v_cp_fin-inf_le := main_verb & 
  [ SYNSEM cp_fin_inf_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_fin_inf_intrans_verb_min ] ].

; <type val="v_cp_fin-inf-q_le">
; <description>Cmps S (fin/inf, +Q)             
; <ex>B wonders whether to jump.
; <nex>
; <todo>
; </type>
v_cp_fin-inf-q_le := main_verb & 
  [ SYNSEM cp_ques_fin_inf_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_ques_fin_inf_intrans_verb_min ] ].

; <type val="v_cp_fin-inf-q_le">
; <description>Cmps S (fin/inf, +Q), allows main clause question complements
; <ex>B asks, why is the sky blue?
; <nex>
; <todo>
; </type>
v_cp_fin-inf-q-mc_le := main_verb & 
  [ SYNSEM basic_cp_ques_fin_inf_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM basic_cp_ques_fin_inf_intrans_verb_min ] ].

; <type val="v_cp_prop_le">
; <description>Cmps S (fin/inf, -Q, opt cmplzr) 
; <ex>B hoped (that) C won. 
; <nex>
; <todo>
; </type>
v_cp_prop_le := main_verb & 
  [ SYNSEM cp_prop_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_intrans_verb_min ] ].

; <type val="v_cp_nfin_le">
; <description>Cmps S (head nonfin)             
; <ex>Beware that C doesn't win.
; <nex>
; <todo>
; </type>
v_cp_nfin_le := main_verb & 
  [ SYNSEM cp_prop_intrans_nfin_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_intrans_nfin_verb_min ] ].

; "find": "I find that Kim has left" but "*I find Kim has left"
; <type val="v_cp_comp-prop_le">
; <description>Cmps S (fin, -Q, obl cmplzr)     
; <ex>B resented that C won.
; <nex>
; <todo>
; </type>
v_cp_comp-prop_le := main_verb & 
  [ SYNSEM cp_only_prop_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_only_prop_intrans_verb_min ] ].

; look/seem like
; <type val="v_cp_like_le">
; <description>Cmps S (fin, -!, 'like' cmplzr)  
; <ex>B looked like she won.
; <nex>
; <todo>
; </type>
v_cp_like_le := main_verb & 
  [ SYNSEM cp_like_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_like_intrans_verb_min ] ].

;; inform
; <type val="v_np-cp_le">
; <description>Cmps NP,S (fin, +/-Q)            
; <ex>B informed C that D won.
; <nex>
; <todo>
; </type>
v_np-cp_le := main_verb & 
  [ SYNSEM np_trans_cp_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_cp_verb_min,
			 VAL.COMPS.FIRST.OPT - ] ] ].

; ask
; <type val="v_np-cp_q_le">
; <description>Cmps NP,S (fin, +Q)              
; <ex>B asked C whether D won.
; <nex>
; <todo>
; </type>
v_np-cp_q_le := main_verb & 
  [ SYNSEM np_trans_cp_ques_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_cp_ques_verb_min,
			 VAL.COMPS.FIRST.OPT - ] ] ].

; persuade
; <type val="v_np-cp_prop_le">
; <description>Cmps NP,S (fin, -Q)              
; <ex>B persuaded C that D won.
; <nex>
; <todo>
; </type>
v_np-cp_prop_le := main_verb & 
  [ SYNSEM np_trans_cp_prop_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_cp_prop_verb_min,
			 VAL.COMPS.FIRST.OPT - ] ] ].

; tell: tell me whether to stay
; <type val="v_np-cp_fin-inf_le">
; <description>Cmps NP,S (fin/inf, +/-Q)        
; <ex>B told C whether to jump.
; <nex>
; <todo>
; </type>
v_np-cp_fin-inf_le := main_verb & 
  [ SYNSEM np_trans_cp_fin_or_inf_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_cp_fin_or_inf_verb_min,
			 VAL.COMPS.FIRST.OPT - ] ] ].

; ask, prefer 'ask that he be released'
; <type val="v_cp_sbjnct_le">
; <description>Cmps S (bse, subjunctive mood)   
; <ex>B required that C be here.
; <nex>
; <todo>
; </type>
v_cp_sbjnct_le := main_verb & 
  [ SYNSEM cp_bse_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_bse_intrans_verb_min ] ].

; ask, prefer 'ask that he be released'
; <type val="v_cp_sbjnct-fin_le">
; <description>Cmps S (fin, subjunctive mood)   
; <ex>B required that C be here.
; <nex>
; <todo>
; </type>
v_cp_sbjnct-fin_le := main_verb & 
  [ SYNSEM cp_sbjnct_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_sbjnct_intrans_verb_min ] ]. 

; wait
; <type val="v_cp_inf-only_le">
; <description>Cmps S (inf, +/-Q)               
; <ex>B waited for C to arrive.
; <nex>
; <todo>
; </type>
v_cp_inf-only_le := main_verb & 
  [ SYNSEM for_to_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM for_to_verb_min ] ].

; try
; <type val="v_vp_seq_le">
; <description>Cmps VP, s-equi                  
; <ex>B intended to win.
; <nex>
; <todo>
; </type>
v_vp_seq_le := main_verb & 
  [ SYNSEM subj_equi_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_verb_min ] ].

; refrain from
; <type val="v_vp_seq-from_le">
; <description>Cmps VP, s-equi, from-VP         
; <ex>B refrained from smoking.
; <nex>
; <todo>
; </type>
v_vp_seq-from_le := main_verb & 
  [ SYNSEM subj_equi_from_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_from_verb_min ] ].

; <type val="v_prd_seq_le">
; <description>Cmps Pred-phr, s-equi            
; <ex>B remained doubtful.
; <nex>
; <todo>
; </type>
v_prd_seq_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_prd_verb_min ] ].

; <type val="v_prd_seq-idm_le">
; <description>Cmps Pred-phr, s-equi, idiom     
; <ex>B made sure that C won.
; <nex>
; <todo>
; </type>
v_prd_seq-idm_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_prd_adj_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_prd_adj_verb_min ],
    IDIOM + ].

; run low (on X)
; <type val="v_prd_seq-va_le">
; <description>Cmps VP or AP, s-equi             
; <ex>B became frustrated.
; <nex>
; <todo>
; </type>
v_prd_seq-va_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_prd_v_a_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_prd_v_a_verb_min ] ].

; run low (on X)
; <type val="v_ap_seq_le">
; <description>Cmps Adj-phr, s-equi             
; <ex>B proved competent.
; <nex>
; <todo>
; </type>
v_ap_seq_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_prd_adj_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_prd_adj_verb_min ] ].

; want into
; <type val="v_pp_seq_le">
; <description>Cmps PP, s-equi                  
; <ex>B wanted into the game.
; <nex>
; <todo>
; </type>
v_pp_seq_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_prd_prep_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_prd_prep_verb_min ] ].

; <type val="v_pp_seq-e_le">
; <description>Cmps PP (sem empty), s-equi      
; <ex>My battery shows as empty.
; <nex>
; <todo>
; </type>
v_pp_seq-e_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_empty_prep_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_empty_prep_verb_min &
				    [ LKEYS.--COMPKEY #ckey ],
	     LKEYS.--COMPKEY #ckey ] ].

; stop working
; go shopping
; <type val="v_vp_seq-prp_le">
; <description>Cmps VP (pres prtcpl), s-equi    
; <ex>B loves playing chess.
; <nex>
; <todo>
; </type>
v_vp_seq-prp_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_prp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_prp_verb_min ] ].

; help
; <type val="v_vp_seq-bse_le">
; <description>Cmps VP (base form), s-equi      
; <ex>B helped finish the paper.
; <nex>
; <todo>
; </type>
v_vp_seq-bse_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_bse_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_bse_verb_min ] ].

; 'I will go read', 'Go read' '*He went read'
; <type val="v_vp_seq-go_le">
; <description>Base form, Cmps VP (base) s-equi 
; <ex>B will go play chess.
; <nex>
; <todo>
; </type>
v_vp_seq-go_le := main_verb_mliszt & 
  [ SYNSEM subj_equi_bse__or_n3sg_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_bse__or_n3sg_verb_min ] ].

; 'We need not stay' but "*He needs not stay", "*We will need not stay"
; cf. "He need not stay" (irreg)
; <type val="v_vp_seq-n3sg_le">
; <description>Non-3sg, Cmps VP (base) s-equi   
; <ex>We need not wait here.
; <nex>
; <todo>
; </type>
v_vp_seq-n3sg_le := main_verb_newltop &
  [ SYNSEM subj_equi_bse_n3sg_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_bse_n3sg_verb_min ] ].

; have yet to
; <type val="v_p-vp_ssr_le">
; <description>Cmps Prtcl, VP (inf), s-raising  
; <ex>B has yet to win.
; <nex>
; <todo>
; </type>
v_p-vp_ssr_le := ssr_particle_v_lexent &
  [ SYNSEM.LKEYS [ --COMPKEY #cmin,
                   --+COMPKEY #cmin ] ].

; they try and find it
; <type val="v_vp_seq-and_le">
; <description>Pres n3sg, Cmps VP (and), s-equi 
; <ex>They try and find it.
; <nex>
; <todo>
; </type>
v_vp_seq-and_le := main_verb & 
  [ SYNSEM subj_equi_and_fin_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_and_fin_verb_min ] ].

; he will try and find it
; <type val="v_vp_seq-and-bse_le">
; <description>Base form, Cmps VP (and), s-equi 
; <ex>B will try and find it.
; <nex>
; <todo>
; </type>
v_vp_seq-and-bse_le := main_verb & 
  [ SYNSEM subj_equi_and_bse_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_and_bse_verb_min ] ].

; couldn't help but notice
; <type val="v_vp_seq-but_le">
; <description>Base form, Cmps VP (but), s-equi 
; <ex>B couldn't help but win.
; <nex>
; <todo>
; </type>
v_vp_seq-but_le := main_verb & 
  [ SYNSEM subj_equi_but_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM subj_equi_but_verb_min ] ].

; <type val="v_np-vp_oeq_le">
; <description>Cmps NP,VP (inf), o-equi         
; <ex>B invited C to stay.
; <nex>
; <todo>
; </type>
v_np-vp_oeq_le := main_verb & 
  [ SYNSEM obj_equi_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_verb_min ] ].

; <type val="v_np-vp_oeq-ntr_le">
; <description>Cmps NP,VP (inf), o-equi, no passive
; <ex>B got C to stay.
; <nex>
; <todo>
; </type>
v_np-vp_oeq-ntr_le := main_verb & 
  [ SYNSEM obj_equi_non_trans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_non_trans_verb_min ] ].

; help
; <type val="v_np-vp_oeq-bse_le">
; <description>Cmps NP,VP (base), o-equi        
; <ex>B helped C win.
; <nex>
; <todo>
; </type>
v_np-vp_oeq-bse_le := main_verb_mliszt & 
  [ SYNSEM obj_equi_bse_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_bse_verb_min ] ].

; <type val="v_np-prd_oeq_le">
; <description>Cmps NP,Pred-phr, o-equi         
; <ex>B proved C wrong.
; <nex>
; <todo>
; </type>
v_np-prd_oeq_le := main_verb_mliszt & 
  [ SYNSEM obj_equi_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_prd_verb_min ] ].

; <type val="v_np-ap_oeq_le">
; <description>Cmps NP,Adj-phr, o-equi          
; <ex>B imagined C taller.
; <nex>
; <todo>
; </type>
v_np-ap_oeq_le := main_verb_mliszt & 
  [ SYNSEM obj_equi_prd_adj_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_prd_adj_verb_min ] ].

; have x ready
; have x in stock
; I want x confirmed
; get x ready
; <type val="v_np-prd_oeq-ntr_le">
; <description>Cmps NP,Prd-phr, o-equi, no psv  
; <ex>B wanted C ready.
; <nex>
; <todo>
; </type>
v_np-prd_oeq-ntr_le := main_verb_mliszt & 
  [ SYNSEM obj_equi_non_trans_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_non_trans_prd_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; I have X to get rid of
; <type val="v_np-vpslnp_oeq_le">
; <description>Cmps NP and VP/NP, o-equi        
; <ex>B had C to talk to.
; <nex>
; <todo>
; </type>
v_np-vpslnp_oeq_le := main_verb & 
  [ SYNSEM obj_equi_vpslash_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_vpslash_prd_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; prevent X from Ving
; <type val="v_np-vp_oeq-from_le">
; <description>Cmps NP,VP (prprt, from), o-equi 
; <ex>B excused C from playing.
; <nex>
; <todo>
; </type>
v_np-vp_oeq-from_le := main_verb & 
  [ SYNSEM obj_equi_from_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM obj_equi_from_verb_min ] ].


; promise
; <type val="v_np-vp_aeq-ntr_le">
; <description>Cmps NP,VP (inf), a-equi, no psv 
; <ex>B promised C to win.
; <nex>
; <todo>
; </type>
v_np-vp_aeq-ntr_le := main_verb & 
  [ SYNSEM anom_equi_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM anom_equi_verb_min,
			 VAL.COMPS.FIRST.OPT + ] ] ].

; use X to do Y
; <type val="v_np-vp_aeq_le">
; <description>Cmps NP,VP (inf), a-equi         
; <ex>B used C to reach D.
; <nex>
; <todo>
; </type>
v_np-vp_aeq_le := main_verb & 
  [ SYNSEM anom_equi_trans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM anom_equi_trans_verb_min ] ].

; kim took too long to arrive
; <type val="v_np-vp_aeq-noel_le">
; <description>Cmps NP,VP (inf), a-equi, no ell 
; <ex>B took an hour to win.
; <nex>
; <todo>
; </type>
v_np-vp_aeq-noel_le := main_verb & 
  [ SYNSEM anom_equi_oblig_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM anom_equi_oblig_verb_min ] ].

; have trouble sleeping
; <type val="v_np-vp_aeq-prp_le">
; <description>Cmps NP,VP (prprt), a-equi       
; <ex>B had trouble sleeping.
; <nex>
; <todo>
; </type>
v_np-vp_aeq-prp_le := main_verb_mliszt & 
  [ SYNSEM anom_equi_prp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM anom_equi_prp_verb_min ] ].

; turn out to
; <type val="v_p-vp_seq_le">
; <description>Cmps Prtcl,VP, s-equi            
; <ex>B turned out to be wrong.
; <nex>
; <todo>
; </type>
v_p-vp_seq_le := main_verb & 
  [ SYNSEM particle_inf_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_inf_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                      --+COMPKEY #cmin ] ] ].

; keep on driving
; <type val="v_p-vp_prp_le">
; <description>Cmps Prtcl,VP                    
; <ex>B kept on winning.
; <nex>
; <todo>
; </type>
v_p-vp_prp_le := main_verb_mliszt & 
  [ SYNSEM particle_prp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_prp_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                      --+COMPKEY #cmin ] ] ].

; <type val="v_p-cp_le">
; <description>Cmps Prtcl,S(fin, +/-Q, opt cmp) 
; <ex>B found out (that) C won.
; <nex>
; <todo>
; </type>
v_p-cp_le := main_verb & 
  [ SYNSEM particle_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_cp_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                      --+COMPKEY #cmin ] ] ].

; <type val="v_p-pp*-cp_le">
; <description>Cmps Prtcl,PP(opt,sel),Scomp     
; <ex>B pointed out to C that S.
; <nex>
; <todo>
; </type>
v_p-pp*-cp_le := main_verb & 
  [ SYNSEM particle_pp_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_pp_cp_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                      --+COMPKEY #cmin ] ] ].

; <type val="v_p-vp_oeq_le">
; <description>Cmps Prtcl,VP, o-equi            
; <ex>B geared up C to win.
; <nex>
; <todo>
; </type>
v_p-vp_oeq_le := main_verb & 
  [ SYNSEM particle_oeq_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_oeq_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                      --+COMPKEY #cmin ] ] ].

; <type val="v_pp-vp_oeq_le">
; <description>Cmps PP(sel),VP, o-equi          
; <ex>B appealed to C to win.
; <nex>
; <todo>
; </type>
v_pp-vp_oeq_le := main_verb & 
  [ SYNSEM oeq_pp_inf_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM oeq_pp_inf_verb_min,
			 VAL.COMPS.FIRST.OPT - ],
	     LKEYS [ --COMPKEY #cmin,
                      --+COMPKEY #cmin ] ] ].

; <type val="v_pp-vp_oeq-bse_le">
; <description>Cmps PP(sel),VP, o-equi          
; <ex>B listened to C sing.
; <nex>
; <todo>
; </type>
v_pp-vp_oeq-bse_le := main_verb & 
  [ SYNSEM oeq_pp_bse_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM oeq_pp_bse_verb_min,
			 VAL.COMPS.FIRST.OPT - ],
	     LKEYS [ --COMPKEY #cmin,
		     --+COMPKEY #cmin ] ] ].

;; leave it to kim to arrange the meeting
; <type val="v_it-pp-vp_oeq_le">
; <description>Cmps Expl-it,PP,VP, o-equi       
; <ex>B left it to C to hire D.
; <nex>
; <todo>
; </type>
v_it-pp-vp_oeq_le := main_verb & 
  [ SYNSEM expl_pp_inf_oeq_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_pp_inf_oeq_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

;; arrange (with kim) to meet her
; <type val="v_pp-vp_seq_le">
; <description>Cmps PP,VP, s-equi               
; <ex>B arranged with C to stay.
; <nex>
; <todo>
; </type>
v_pp-vp_seq_le := main_verb & 
  [ SYNSEM pp_inf_seq_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM pp_inf_seq_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT - ] > ] ] ].

;; arrange it with kim to meet her
; <type val="v_it-pp-vp_seq_le">
; <description>Cmps Expl-it,PP,VP s-equi        
; <ex>B arranged it with C to X.
; <nex>
; <todo>
; </type>
v_it-pp-vp_seq_le := main_verb & 
  [ SYNSEM expl_pp_inf_seq_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_pp_inf_seq_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

;; it bothers kim that sally left; it bothers kim to leave
; <type val="v_np-cp_it-s_le">
; <description>It-subj, Cmps NP,S(fin/inf)      
; <ex>It bothered B that C won.
; <nex>
; <todo>
; </type>
v_np-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_np_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_np_cp_verb_min ] ].

;; That Kim lost suggests that Sandy won. 
;; It suggests that Sandy won that Kim lost.
; <type val="v_cp-cp_it-s_le">
; <description>It-subj, S ,S 
; <ex>That B lost suggests that C won.
; <nex>
; <todo>
; </type>
v_cp-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_cp_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_cp_cp_verb_min ] ].

; cost
; <type val="v_np-np-cp_it-s_le">
; <description>It-subj, Cmps NP,NP,S(fin/inf)   
; <ex>It cost B $5 for C to go.
; <nex>
; <todo>
; </type>
v_np-np-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_np_np_cp_inf_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_np_np_cp_inf_verb_min ] ].

; make (?)
; <type val="v_np-np-cp_it-ob_le">
; <description>It-subj, Cmps NP,NP,S(fin/inf)   
; <ex>It makes Kim the winner that the horse died.
; <nex>
; <todo>
; </type>
v_np-np-cp_it-ob_le := main_verb & 
  [ SYNSEM expl_it_subj_np_np_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_np_np_cp_verb_min ] ].

; matter
; <type val="v_np-pp*-cp_it-s_le">
; <description>It-subj, Cmps NP,PP,S(fin)   
; <ex>It matters a lot to Kim that S.
; <nex>
; <todo>
; </type>
v_np-pp*-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_np_pp_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_np_pp_cp_verb_min ] ].

; take: 'took him ten minutes to leave'
; <type val="v_np*-np-vp_it-s_le">
; <description>It-subj, Cmps NP,NP,VP           
; <ex>It took B an hour to go.
; <nex>
; <todo>
; </type>
v_np*-np-vp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_np_np_vp_inf_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM expl_it_subj_np_np_vp_inf_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT - ], [ ] > ] ] ].

; 'it advances our cause (a lot) to take this step"
; "it will cost us (a lot) to win"
; <type val="v_np-np*-vp_it-s_le">
; <description>It-subj, Cmps NP,(NP),VP         
; <ex>It cost B ($5) to go.
; <nex>
; <todo>
; </type>
v_np-np*-vp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_np_np_vp_inf_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM expl_it_subj_np_np_vp_inf_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT + ], [ ] > ] ] ].

; make
; <type val="v_np-prd-cp_it-s_le">
; <description>It-subj, Cmps NP,PrdP ,S(fin/inf)   
; <ex>It cost B $5 for C to go.
; <nex>
; <todo>
; </type>
v_np-prd-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_np_prdp_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_np_prdp_cp_verb_min ] ].

;; it seems (to kim) that sandy left
; <type val="v_pp*-cp_it-s_le">
; <description>It-subj, Cmps (PP),S(fin)        
; <ex>It seems to B that K won.
; <nex>
; <todo>
; </type>
v_pp*-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_pp*_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_pp*_cp_verb_min ] ].

;; it occurred *(to me) that Sandy left
; <type val="v_pp-cp_it-s_le">
; <description>It-subj, Cmps PP,S(fin)          
; <ex>It occurred to B to look.
; <nex>
; <todo>
; </type>
v_pp-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_pp_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_pp_cp_verb_min ] ].

;; it looks (to kim) like Sandy left
; <type val="v_pp*-cp_like_le">
; <description>It-subj, Cmps (PP),S(like)       
; <ex>It felt (to B) like K won.
; <nex>
; <todo>
; </type>
v_pp*-cp_like_le := main_verb & 
  [ SYNSEM expl_it_subj_pp_cp_like_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_pp_cp_like_verb_min ] ].

;; It doesn't matter who stays
; <type val="v_pp*-cp_it-unsp_le">
; <description>It-subj, Cmps (PP),S(+/-Q)       
; <ex>It mattered whether S won.
; <nex>
; <todo>
; </type>
v_pp*-cp_it-unsp_le := main_verb & 
  [ SYNSEM expl_it_subj_pp_cp_unsp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_pp_cp_unsp_verb_min ] ].

;; It dawned on Kim that ...
; <type val="v_pp-cp_it-s-e_le">
; <description>It-subj, Cmps PP,S(fin, no to)   
; <ex>It dawned on B that K won.
; <nex>
; <todo>
; </type>
v_pp-cp_it-s-e_le := main_verb & 
  [ SYNSEM expl_it_subj_ppnoto_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_ppnoto_cp_verb_min ] ].

; it turns out that kim arrived
; <type val="v_p-cp_it-s_le">
; <description>It-subj, Cmps Prtcl,S            
; <ex>It turned out that S won.
; <nex>
; <todo>
; </type>
v_p-cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_prtcl_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_prtcl_cp_verb_min ] ].

; It follows that ...
; <type val="v_cp_it-s_le">
; <description>It-subj, Cmps S                  
; <ex>It followed that S won.
; <nex>
; <todo>
; </type>
v_cp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_cp_verb_min ] ].

; it would help/wouldn't hurt to know ...
; <type val="v_vp_it-s_le">
; <description>It-subj, Cmps VP                 
; <ex>It doesn't pay to grumble.
; <nex>
; <todo>
; </type>
v_vp_it-s_le := main_verb & 
  [ SYNSEM expl_it_subj_vp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_it_subj_vp_verb_min ] ].

; bet
; <type val="v_np-np-cp_le">
; <description>Cmps NP,NP,S                     
; <ex>B bet C $5 that S won.
; <nex>
; <todo>
; </type>
v_np-np-cp_le := main_verb & 
  [ SYNSEM np_np_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_np_cp_verb_min ] ].

; say
; <type val="v_pp*-cp_le">
; <description>Cmps PP(sel, opt),S(fin/inf)     
; <ex>B said to C that D won.
; <nex>
; <todo>
; </type>
v_pp*-cp_le := norm_basic_main_verb & 
  [ INFLECTD -,
    SYNSEM pp_cp_fin_prop_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM pp_cp_fin_prop_verb_min ] ].

; say
; <type val="v_pp*-cp_fin-imp_le">
; <description>Cmps PP(sel, opt),S(fin/inf), allow imperatives
; <ex>B said to C that D won.
; <nex>
; <todo>
; </type>
v_pp*-cp_fin-imp_le := norm_basic_main_verb & 
  [ INFLECTD -,
    SYNSEM pp_cp_fin_unspec_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM pp_cp_fin_unspec_verb_min ] ].


; predict
; <type val="v_pp*-cp-unsp_le">
; <description>Cmps PP(sel, opt),S(fin/inf, +/-Q),
; <ex>B predicted whether C would win.
; <nex>
; <todo>
; </type>
v_pp*-cp_unsp_le := main_verb & 
  [ SYNSEM pp_cp_fin_pq_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM pp_cp_fin_pq_verb_min ] ].

; <type val="v_pp*-cp_fin_le">
; <description>Cmps PP(sel, opt),S(fin)         
; <ex>B joked to C that D won.
; <nex>
; <todo>
; </type>
v_pp*-cp_fin_le := main_verb & 
  [ SYNSEM pp*_cp_fin_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM pp*_cp_fin_verb_min ] ].

; <type val="v_pp-cp_fin_le">
; <description>Cmps PP(sel, oblig),S(fin)         
; <ex>B impressed on C that D won.
; <nex>
; <todo>
; </type>
v_pp-cp_fin_le := main_verb & 
  [ SYNSEM pp_cp_fin_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM pp_cp_fin_verb_min ] ].

; 'see to it that X'
; <type val="v_pp-it-cp_le">
; <description>Cmps PP(sel,expl-it),S(fin)      
; <ex>B saw to it that C won.
; <nex>
; <todo>
; </type>
v_pp-it-cp_le := main_verb & 
  [ SYNSEM pp_expl_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM pp_expl_cp_verb_min ] ].

; would like
; <type val="v_np-vp_sor-ntr_le">
; <description>Cmps NP,VP, s-o-raising, no psv  
; <ex>B wanted it to rain.
; <nex>
; <todo>
; </type>
v_np-vp_sor-ntr_le := main_verb_mliszt & 
  [ SYNSEM sor_non_trans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM sor_non_trans_verb_min ] ].

; <type val="v_np-vp_sor_le">
; <description>Cmps NP,VP, s-o-raising          
; <ex>B expected it to rain.
; <nex>
; <todo>
; </type>
v_np-vp_sor_le := main_verb_mliszt & 
  [ SYNSEM sor_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM sor_verb_min ] ].

; <type val="v_np-vp_bse_le">
; <description>Cmps NP,VP(bse), s-o-raising     
; <ex>B heard it rain.
; <nex>
; <todo>
; </type>
v_np-vp_bse_le := main_verb_mliszt & 
  [ SYNSEM sorb_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM sorb_verb_min ] ].

; make: 'kim made it clear that sandy arrived'
; <type val="v_np-prd_sor_le">
; <description>Cmps NP,Adj, s-o-raising         
; <ex>The smog made it cloudy.
; <nex>
; <todo>
; </type>
v_np-prd_sor_le := main_verb_mliszt & 
  [ SYNSEM sor_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM sor_prd_verb_min ] ].

; <type val="v_np-np_le">
; <description>Cmps NP(obl),NP(obl), dative alt 
; <ex>B gave C the book.
; <nex>
; <todo>
; </type>
v_np-np_le := main_verb & 
  [ SYNSEM ditrans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM ditrans_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT - ] > ],
	     LKEYS [ --OCOMPKEY #ocmin,
		     --+OCOMPKEY #ocmin ] ] ].

; 'leave (bequeath)'
; <type val="v_np-np*_le">
; <description>Cmps NP(obl),NP(opt), dative alt 
; <ex>B left the book to C.
; <nex>
; <todo>
; </type>
v_np-np*_le := main_verb & 
  [ SYNSEM ditrans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM ditrans_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT + ] > ] ] ].

; <type val="v_np*-np_le">
; <description>Cmps NP(opt),NP(oblig), dative alt 
; <ex>B paid C the money.
; <nex>
; <todo>
; </type>
v_np*-np_le := main_verb & 
  [ SYNSEM ditrans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM ditrans_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT + ] > ] ] ].

; <type val="v_np-np_only_le">
; <description>Cmps NP(obl),NP(obl), no dat alt 
; <ex>B declared C the winner.
; <nex>
; <todo>
; </type>
v_np-np_only_le := main_verb & 
  [ ALTS.DATIVE -,
    SYNSEM ditrans_only_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM ditrans_only_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np*-np*_only_le">
; <description>Cmps NP(opt),NP(opt), no dat alt 
; <ex>B asked C the question.
; <nex>
; <todo>
; </type>
v_np*-np*_only_le := main_verb & 
  [ ALTS.DATIVE -,
    SYNSEM ditrans_only_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM ditrans_only_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT + ] > ] ] ].

; <type val="v_np-np_idm_le">
; <description>Cmps NP(obl),NP(obl), idiom      
; <ex>B called it quits.
; <nex>
; <todo>
; </type>
v_np-np_idm_le := main_verb & 
  [ ALTS.DATIVE -,
    SYNSEM ditrans_only_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM ditrans_only_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ],
    IDIOM + ].

;; talk
; <type val="v_pp*-pp*_le">
; <description>Cmps PP(opt),PP(opt)             
; <ex>B lied to C about D.
; <nex>
; <todo>
; </type>
v_pp*-pp*_le := main_verb & 
  [ SYNSEM double_pp_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM double_pp_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT + ] > ] ] ].
; <type val="v_pp-pp_le">
; <description>Cmps PP(obl),PP(obl)             
; <ex>B ranged from C to D.
; <nex>
; <todo>
; </type>
v_pp-pp_le := main_verb & 
  [ SYNSEM double_pp_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM double_pp_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT - ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_pp-pp_e_le">
; <description>Cmps PP(obl),PP(sel,obl)         
; <ex>B reported on C to D.
; <nex>
; <todo>
; </type>
v_pp-pp_e_le := main_verb & 
  [ SYNSEM double_pp_empty_pp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM double_pp_empty_pp_verb_min &
				    [ LKEYS [ --COMPKEY #cmin,
					      --OCOMPKEY #ocmin ] ],
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np*-pp*-ppto_le">
; <description>Cmps NP(opt),PP(sel,opt),PP(to)  
; <ex>B changed C from D to E.
; <nex>
; <todo>
; </type>
v_np*-pp*-ppto_le := main_verb & 
  [ SYNSEM np_trans_double_ppto_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_double_ppto_verb_min,
			 VAL.COMPS.FIRST.OPT + ] ] ].

; <type val="v_np-pp*-ppto_le">
; <description>Cmps NP(obl),PP(sel,opt),PP(to)  
; <ex>B converted C from D to E.
; <nex>
; <todo>
; </type>
v_np-pp*-ppto_le := main_verb & 
  [ SYNSEM np_trans_double_ppto_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_double_ppto_verb_min,
			 VAL.COMPS.FIRST.OPT - ] ] ].

; <type val="v_np*-pp*-ppfor_le">
; <description>Cmps NP(opt),PP(sel,opt),PP(for) 
; <ex>B paid money to C for D.
; <nex>
; <todo>
; </type>
v_np*-pp*-ppfor_le := main_verb & 
  [ SYNSEM np_trans_double_ppfor_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_trans_double_ppfor_verb_min ] ].

; <type val="v_pp_e_le">
; <description>Cmps PP(sel,obl)                 
; <ex>B looked after C.
; <nex>
; <todo>
; </type>
v_pp_e_le := main_verb & 
  [ SYNSEM empty_prep_intrans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM empty_prep_intrans_verb_min &
				    [ LKEYS.--COMPKEY #cmin ],
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <type val="v_pp_e3_le">
; <description>Cmps PP(sel,obl)                 
; <ex>B gave to worthy causes
; <nex>
; <todo>
; </type>
v_pp_e3_le := main_verb & 
  [ SYNSEM empty_prep_intrans_arg3_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_prep_intrans_arg3_verb_min &
				      [ LKEYS.--COMPKEY #cmin ],
			 VAL.COMPS < [ OPT - ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <type val="v_np-pp_e_le">
; <description>Cmps NP(obl),PP(sel.obl)         
; <ex>B compared C with D.
; <nex>
; <todo>
; </type>
v_np-pp_e_le := main_verb & 
  [ SYNSEM empty_prep_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_prep_trans_verb_min &
				    [ LKEYS.--OCOMPKEY #ocmin ],
			 VAL.COMPS < [ OPT - ], [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np*-pp_e_le">
; <description>Cmps NP(opt),PP(sel,obl)         
; <ex>B separated C from D.
; <nex>
; <todo>
; </type>
v_np*-pp_e_le := main_verb & 
  [ SYNSEM empty_prep_trans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_prep_trans_verb_min &
				    [ LKEYS.--OCOMPKEY #ocmin ],
			 VAL.COMPS < [ OPT + ], [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np-pp*_e-imp_le">
; <description>Cmps NP(obl),PP(sel,opt), hd_imp_c  
; <ex>Thank you for D.
; <nex>
; <todo>
; </type>
v_np-pp*_e-imp_le := main_verb & 
  [ SYNSEM empty_prep_trans_verb & 
	   [ LOCAL [ CAT [ HEAD [ VFORM fin,
				  LSYNSEM empty_prep_trans_verb_min &
					[ LKEYS.--OCOMPKEY #ockey ] ],
                           VAL [ SUBJ < [ LOCAL.CONT.HOOK.INDEX #ind ] >,
                                 COMPS < [ OPT - ], [ OPT + ] > ] ],
                     AGR #ind ],
             LKEYS [ KEYREL.ARG1 #ind & [ PNG.PN 1 ],
		     --OCOMPKEY #ockey ] ] ].
; <type val="v_np-pp_e-idm_le">
; <description>Cmps NP(obl),PP(sel,obl), idiom  
; <ex>B took care of C.
; <nex>
; <todo>
; </type>
v_np-pp_e-idm_le := main_verb & 
  [ SYNSEM empty_prep_trans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_prep_trans_verb_min &
				      [ LKEYS.--OCOMPKEY #ocmin ],
			 VAL.COMPS < [ OPT -, 
				       LOCAL.CAT.HEAD noun &
					   [ MINORS.MIN bare_nom_rel ] ], 
				     [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ],
    IDIOM + ].

; take Kim for granted
; take into account
; <type val="v_np-pp_idm_le">
; <description>Cmps NP(obl),PP(sel,obl), idiom  
; <ex>B took C for granted.
; <nex>
; <todo>
; </type>
v_np-pp_idm_le := main_verb & 
  [ SYNSEM empty_prep_trans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_prep_trans_verb_min &
				      [ LKEYS.--OCOMPKEY #ocmin ],
			 VAL.COMPS < [ OPT -, 
				       LOCAL.CAT.HEAD noun ], 
				     [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ],
    IDIOM + ].

; came into being
; <type val="v_pp_e-idm_le">
; <description>Cmps NP(obl), idiom              
; <ex>B came into being.
; <nex>
; <todo>
; </type>
v_pp_e-idm_le := main_verb & 
  [ SYNSEM empty_prep_intrans_verb & 
	   [ LOCAL.CAT.HEAD.LSYNSEM empty_prep_intrans_verb_min &
				    [ LKEYS.--COMPKEY #cmin ],
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ],
    IDIOM + ].

; 'interest kim in'
; <type val="v_np-pp_e-ntr_le">
; <description>Cmps NP(obl),PP(sel,obl), no psv 
; <ex>B interested C in D.
; <nex>
; <todo>
; </type>
v_np-pp_e-ntr_le := main_verb & 
  [ SYNSEM empty_prep_non_trans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM empty_prep_non_trans_verb_min &
				    [ LKEYS.--OCOMPKEY #ockey ],
	     LKEYS.--OCOMPKEY #ockey ] ].

;; 'prefer it if ...'
; <type val="v_it-cp_le">
; <description>Cmps Expl-it,S(fin,+/-Q)         
; <ex>B prefers it if C wins.
; <nex>
; <todo>
; </type>
v_it-cp_le := main_verb &
  [ SYNSEM expl_obj_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_obj_cp_verb_min ] ].

;; 'hate it that ...'
; <type val="v_it-cp_prop-c_le">
; <description>Cmps Expl-it,S(fin,-Q),obl cplzr 
; <ex>B hates it that C won.
; <nex>
; <todo>
; </type>
v_it-cp_prop-c_le := main_verb &
  [ SYNSEM expl_obj_cpcmp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_obj_cpcmp_verb_min ] ].

;; 'take it (that) ...'
; <type val="v_it-cp_prop_le">
; <description>Cmps Expl-it,S(fin,-Q)           
; <ex>B took it (that) C won.
; <nex>
; <todo>
; </type>
v_it-cp_prop_le := main_verb &
  [ SYNSEM expl_obj_cpprop_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_obj_cpprop_verb_min ] ].

; 'make it clear that ...'
; <type val="v_it-prd_le">
; <description>Cmps Expl-it,Pred-phr            
; <ex>B made it clear that C won
; <nex>
; <todo>
; </type>
v_it-prd_le := main_verb_mliszt &
  [ SYNSEM expl_obj_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM expl_obj_prd_verb_min ] ].

; <type val="v_np_le">
; <description>Cmps NP(obl)                     
; <ex>B chased C.
; <nex>
; <todo>
; </type>
v_np_le := main_verb & 
  [ SYNSEM np_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_verb_min &
				      [ LOCAL.CAT.VAL.COMPS.FIRST.OPT - ],
		         VAL.COMPS < [ OPT - ] > ] ] ].

; <type val="v_np*_le">
; <description>Cmps NP(opt)                     
; <ex>B cleaned the room.
; <nex>
; <todo>
; </type>
v_np*_le := main_verb & 
  [ SYNSEM np_trans_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_trans_verb_min ] ].

; <type val="v_np_noger_le">
; <description>Cmps NP(obl,nongerund)           
; <ex>B continued the tour.
; <nex>
; <todo>
; </type>
v_np_noger_le := main_verb & 
  [ ALTS [ VADJ -,
           NGER - ],
    SYNSEM np_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_verb_min &
				      [ LOCAL.CAT.VAL.COMPS.FIRST.OPT - ],
			 VAL.COMPS < [ OPT - ] > ] ] ].

; Temporary patch for e.g. 'take' which has an optional ARG3 role, which
; needs to be present so generator won't spuriously fill it.
; <type val="v_np_noarg3_le">
; <description>Cmps NP(obl), only two args      
; <ex>B took the book.
; <nex>
; <todo>
; </type>
v_np_noarg3_le := main_verb & 
  [ SYNSEM np_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_trans_verb_min &
				      [ LOCAL.CAT.VAL.COMPS.FIRST.OPT - ],
			 VAL.COMPS < [ OPT - ] > ],
             LKEYS.KEYREL.ARG3 semarg ] ].

; <type val="v_np_do-be_le">
; <description>Cmps NP(gap), only for do (but not doing) in do-be construction
; <ex>The first thing B did was hire C.
; <nex>
; <todo>
; </type>
v_np_do-be_le := basic_main_verb_sans_key &
  [ SYNSEM do_be_verb &
	   [ LOCAL.CAT.HEAD [ LSYNSEM do_be_verb_min,
			      VFORM non_prespart ],
	     LKEYS.KEYREL.ARG2.IFORM non_prespart ],
    INFLECTD - ].


; <type val="v_np_do-ing-be_le">
; <description>Cmps NP(gap), only for doing in do-be construction
; <ex>The thing B was doing was hiring C.
; <nex>
; <todo>
; </type>
v_np_do-ing-be_le := basic_main_verb_sans_key &
  [ INFLECTD -,
    SYNSEM do_be_verb &
	   [ LOCAL.CAT.HEAD [ LSYNSEM do_be_verb_min,
			      VFORM prp ],
	     LKEYS.KEYREL.ARG2.IFORM prp ] ].

; <type val="v_np_done-be_le">
; <description>Cmps NP(gap), only for do (but not doing) in do-be construction
; <ex>The first thing that must be done is hire C.
; <nex>
; <todo>
; </type>
v_np_done-be_le := basic_main_verb_sans_key &
  [ SYNSEM do_be_verb_passive &
	   [ LOCAL.CAT.HEAD.LSYNSEM do_be_verb_passive_min,
	     LKEYS.KEYREL.ARG2.IFORM non_prespart ],
    INFLECTD + ].

; <type val="v_np*_nfin_le">
; <description>Cmps NP(opt), nonfin             
; <ex>B should beware C.
; <nex>
; <todo>
; </type>
v_np*_nfin_le := main_verb & 
  [ SYNSEM np_trans_nfin_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_trans_nfin_verb_min ] ].

; <type val="v_np_refl-idm_le">
; <description>Cmps reflexive NP, idiom                   
; <ex>We racked our brains.
; <nex>
; <todo>
; </type>
v_np_refl-idm_le := main_verb_mliszt & 
  [ SYNSEM np_trans_refl_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_trans_refl_verb_min ],
    IDIOM + ].

; <type val="v_np_sg-idm_le">
; <description>Cmps non-reflexive NP, singular, idiom                   
; <ex>He kicked the bucket.
; <nex>
; <todo>
; </type>
v_np_sg-idm_le := v_np_idm_lexent &
  [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.AGR.PNG.PN 3s ] > ].

; <type val="v_np_pl-idm_le">
; <description>Cmps non-reflexive NP, plural, idiom                   
; <ex>He sucked eggs.
; <nex>
; <todo>
; </type>
v_np_pl-idm_le := v_np_idm_lexent &
  [ SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.AGR.PNG.PN 3p ] > ].

; 'elected him president'
; <type val="v_np-nb_le">
; <description>Cmps NP(obl),Nbar(obl)           
; <ex>We elected B president.
; <nex>
; <todo>
; </type>
v_np-nb_le := main_verb_mliszt & 
  [ SYNSEM ditrans_np_nbar_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ditrans_np_nbar_verb_min ] ].

; 'see picture, page 2'
; <type val="v_nb-np*_imp_le">
; <description>Cmps Nbar(obl), NP(opt), hd_imp_c   
; <ex>See pamphlet, page 2.
; <nex>
; <todo>
; </type>
v_nb-np*_imp_le := main_verb_mliszt & 
  [ SYNSEM ditrans_nbar_np_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ditrans_nbar_np_verb_min ] ].

; <type val="v_pp_e-nfin_le">
; <description>Cmps NP(obl), nonfin             
; <ex>B should beware of C.
; <nex>
; <todo>
; </type>
v_pp_e-nfin_le := main_verb & 
  [ SYNSEM empty_prep_intrans_bse_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM empty_prep_intrans_bse_verb_min &
				    [ LKEYS.--COMPKEY #cmin ],
	     LKEYS.--COMPKEY #cmin ] ].

; <type val="v_np-pp_le">
; <description>Cmps NP(obl),PP(obl)             
; <ex>B named C after D.
; <nex>
; <todo>
; </type>
v_np-pp_le := main_verb_mliszt & 
  [ SYNSEM prep_trans_verb & 
	   [ LOCAL.CAT.HEAD.LSYNSEM prep_trans_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

;; takes dir_state_modable_rel oblique complement.
;; put (takes variety of PP complements, so avoid chart dependency filter)
; <type val="v_np-pp_prop_le">
; <description>Cmps NP(obl),PP(obl), state rslt 
; <ex>B put C on D.
; <nex>
; <todo>
; </type>
v_np-pp_prop_le := main_verb_mliszt & 
  [ SYNSEM prep_trans_dir_verb & 
	   [ LOCAL.CAT.HEAD.LSYNSEM prep_trans_dir_verb_min ] ].

;; change one's mind about
; <type val="v_np-pp_nmod_le">
; <description>Cmps NP(obl),PP(obl, nmodifier)  
; <ex>We change our mind about C
; <nex>
; <todo>
; </type>
v_np-pp_nmod_le := main_verb_mliszt &
  [ SYNSEM prep_trans_verb_nmod &
	   [ LOCAL.CAT.HEAD.LSYNSEM prep_trans_verb_nmod_min,
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np-pp_dir_le">
; <description>Cmps NP(obl),PP(dir, obl)
; <ex>B raced C into D.
; <nex>
; <todo>
; </type>
v_np-pp_dir_le := main_verb_mliszt & 
  [ SYNSEM prep_trans_dir_noprop_verb & 
	   [ LOCAL.CAT.HEAD.LSYNSEM prep_trans_dir_noprop_verb_min ] ].

; <type val="v_np-pp_oeq-as_le">
; <description>Cmps NP(obl),PP(obl,as), o-equi  
; <ex>B classifies C as D.
; <nex>
; <todo>
; </type>
v_np-pp_oeq-as_le := main_verb &
  [ SYNSEM np_as_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_as_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np_ntr_le">
; <description>Cmps NP(obl), no psv             
; <ex>B remains C.
; <nex>
; <todo>
; </type>
v_np_ntr_le := main_verb & 
  [ SYNSEM np_non_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_non_trans_verb_min,
			 VAL.COMPS < [ OPT - ] > ] ] ].

; <type val="v_np*_ntr_le">
; <description>Cmps NP(opt), no psv             
; <ex>B promised C.
; <nex>
; <todo>
; </type>
v_np*_ntr_le := main_verb & 
  [ SYNSEM np_non_trans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_non_trans_verb_min,
			 VAL.COMPS < [ OPT + ] > ] ] ].

; 'become'
; <type val="v_np_id_le">
; <description>Cmps NP, become                  
; <ex>B became C.
; <nex>
; <todo>
; </type>
v_np_id_le := main_verb & 
  [ SYNSEM np_non_trans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM np_non_trans_verb_min,
			 VAL.COMPS < [ OPT - ] > ],
             LKEYS.KEYREL [ ARG1.SORT #sort,
                            ARG2.SORT #sort ] ] ].

; 'become president'
; <type val="v_nb_le">
; <description>Cmps Nbar(obl,pred nom)          
; <ex>B became president.
; <nex>
; <todo>
; </type>
v_nb_le := main_verb_mliszt & 
  [ SYNSEM nbar_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM nbar_verb_min ] ].

; 'become obvious that Kim arrived.'
; <type val="v_prd_ssr-va_le">
; <description>Cmps VP or AP, subj-raising, expl-it subj
; <ex>It became obvious that Kim arrived.
; <nex>
; <todo>
; </type>
v_prd_ssr-va_le := main_verb_mliszt & 
  [ SYNSEM ssr_prdp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ssr_prdp_verb_min ] ].

; 'stood guard'
; <type val="v_nb_idm_le">
; <description>Cmps Nbar(obl), idiom            
; <ex>B stood guard.
; <nex>
; <todo>
; </type>
v_nb_idm_le := main_verb & 
  [ SYNSEM np_non_trans_nb_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_non_trans_nb_verb_min ],
    IDIOM + ].

; <type val="v_np-pp_seq-as_le">
; <description>Cmps NP(obl),PP(obl,as), s-equi  
; <ex>B struck C as without D.
; <nex>
; <todo>
; </type>
v_np-pp_seq-as_le := main_verb_mliszt & 
  [ SYNSEM np_as_seq_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_as_seq_verb_min,
	     LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_p_le">
; <description>Cmps Prtcl                       
; <ex>B turned up.
; <nex>
; <todo>
; </type>
v_p_le := main_verb & 
  [ SYNSEM particle_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <type val="v_p_3only_le">
; <description>Cmps Prtcl, subj 3per            
; <ex>Something is going on.
; <nex>
; <todo>
; </type>
v_p_3only_le := main_verb & 
  [ SYNSEM particle_3only_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_3only_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].
; <type val="v_p-np_le">
; <description>Cmps Prtcl,NP(obl), order alt    
; <ex>B picked up the book.
; <nex>
; <todo>
; </type>
v_p-np_le := main_verb & 
  [ SYNSEM np_particle_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].
; <type val="v_np-p_le">
; <description>Cmps NP(obl),Prtcl, no order alt 
; <ex>We will see you around.
; <nex>
; <todo>
; </type>
v_np-p_le := main_verb & 
  [ SYNSEM np_particle_noalt_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_noalt_verb_min,
	     LKEYS [ --COMPKEY #ocmin,
                     --+COMPKEY #ocmin ] ],
    ALTS.NPPART - ].

; <type val="v_p-prd_le">
; <description>Cmps Prtcl,Pred-phr              
; <ex>B ended up sick.
; <nex>
; <todo>
; </type>
v_p-prd_le := main_verb & 
  [ SYNSEM particle_prd_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_prd_verb_min,
	     LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].
; <type val="v_p-pp_le">
; <description>Cmps Prtcl,PP(obl)               
; <ex>B caught up on C.
; <nex>
; <todo>
; </type>
v_p-pp_le := main_verb & 
  [ SYNSEM particle_pp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM particle_pp_verb_min ] ].

; <type val="v_p-pp_e_le">
; <description>Cmps Prtcl,PP(obl,sel)           
; <ex>B ran out of C.
; <nex>
; <todo>
; </type>
v_p-pp_e_le := main_verb & 
  [ SYNSEM particle_empty_pp_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM particle_empty_pp_verb_min,
			 VAL.COMPS < synsem, [ OPT - ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_p-pp*_e_le">
; <description>Cmps Prtcl,PP(opt,sel)           
; <ex>B heard back from C.
; <nex>
; <todo>
; </type>
v_p-pp*_e_le := main_verb & 
  [ SYNSEM particle_empty_pp_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM particle_empty_pp_verb_min,
			 VAL.COMPS < synsem, [ OPT + ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; 'boils it down to'
; <type val="v_p-np-pp_to_le">
; <description>Cmps Prtcl,NP(obl),PP(obl,to)    
; <ex>B made out the check to C.
; <nex>
; <todo>
; </type>
v_p-np-pp_to_le := main_verb & 
  [ SYNSEM np_particle_ppto_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_ppto_verb_min ] ].

; 'made up of'
; <type val="v_p-np-pp_of_le">
; <description>Cmps Prtcl,NP(obl),PP(obl,of)    
; <ex>This is made up of bricks.
; <nex>
; <todo>
; </type>
v_p-np-pp_of_le := main_verb & 
  [ SYNSEM np_particle_ppof_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_ppof_verb_min ] ].

; <type val="v_p-np-pp_for_le">
; <description>Cmps Prtcl,NP(obl),PP(obl,for)   
; <ex>B traded in B for C.
; <nex>
; <todo>
; </type>
v_p-np-pp_for_le := main_verb & 
  [ SYNSEM np_particle_ppfor_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_ppfor_verb_min ] ].

; <type val="v_p-np-pp_from_le">
; <description>Cmps Prtcl,NP(obl),PP(obl,from)  
; <ex>B separated out C from D.
; <nex>
; <todo>
; </type>
v_p-np-pp_from_le := main_verb & 
  [ SYNSEM np_particle_ppfrom_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_ppfrom_verb_min ] ].

; <type val="v_np-p-np_le">
; <description>Cmps NP,Prtcl,NP                 
; <ex>B gave C back the book.
; <nex>
; <todo>
; </type>
v_np-p-np_le := main_verb & 
  [ SYNSEM np_particle_np_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_np_verb_min,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <type val="v_np-p-cp_idm_le">
; <description>Cmps NP,Prtcl,CP, maybe only for idioms
; <ex>B made up her mind that S.
; <nex>
; <todo>
; </type>
v_np-p-cp_idm_le := main_verb & 
  [ SYNSEM np_particle_cp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_particle_cp_verb_min,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ],
    IDIOM + ].

; <type val="v_pp_arg_le">
; <description>Cmps PP, argmt coercion          
; <ex>B suggested on Monday.
; <nex>
; <todo>
; </type>
v_pp_arg_le := main_verb  & 
  [ SYNSEM prep_intrans_event_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM prep_intrans_event_verb_min ] ].

; <type val="v_pp_le">
; <description>Cmps PP(obl)                     
; <ex>The cat felt like a dog.
; <nex>
; <todo>
; </type>
v_pp_le := main_verb  & 
  [ SYNSEM prep_intrans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM prep_intrans_verb_min,
			 VAL.COMPS < [ OPT - ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <type val="v_pp*_dir_le">
; <description>Cmps PP(opt,dir)                 
; <ex>B crept into the room.
; <nex>
; <todo>
; </type>
v_pp*_dir_le := main_verb  & 
  [ SYNSEM prep_intrans_dir_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM prep_intrans_dir_verb_min,
			 VAL.COMPS < [ OPT + ] > ] ] ].

; <type val="v_pp_dir_le">
; <description>Cmps PP(obl,dir)                 
; <ex>B slipped into the room.
; <nex>
; <todo>
; </type>
v_pp_dir_le := main_verb  & 
  [ SYNSEM prep_intrans_dir_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM prep_intrans_dir_verb_min,
			 VAL.COMPS < [ OPT - ] > ] ] ].

; <type val="v_pp*_le">
; <description>Cmps PP(opt)                     
; <ex>B starred in C
; <nex>
; <todo>
; </type>
v_pp*_le := main_verb & 
  [ SYNSEM prep_intrans_verb & 
	   [ LOCAL.CAT [ HEAD.LSYNSEM prep_intrans_verb_min,
			 VAL.COMPS < [ OPT + ] > ] ] ].

; <type val="v_pp_unacc_le">
; <description>Cmps PP(opt), unacc              
; <ex>The seed grew into a tree.
; <nex>
; <todo>
; </type>
v_pp_unacc_le := main_verb  & 
  [ SYNSEM prep_intrans_unacc_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM prep_intrans_unacc_verb_min ] ].

; <type val="v_vp_ssr_le">
; <description>Cmps VP(inf), s-s-rais           
; <ex>There failed to be a link.
; <nex>
; <todo>
; </type>
v_vp_ssr_le := main_verb & 
  [ SYNSEM ssr_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ssr_verb_min ] ].

; <type val="v_vp_ssr-prp_le">
; <description>Cmps VP(prp), s-s-rais           
; <ex>It finished raining.
; <nex>
; <todo>
; </type>
v_vp_ssr-prp_le := main_verb & 
  [ SYNSEM ssr_prp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ssr_prp_verb_min ] ].

; 'have to': no imperative "*Have to leave!"
; <type val="v_vp_ssr-nimp_le">
; <description>Cmps VP(inf), s-s-rais, no hd_imp_c 
; <ex>There tend to be problems.
; <nex>
; <todo>
; </type>
v_vp_ssr-nimp_le := main_verb & 
  [ SYNSEM ssr_noimp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ssr_noimp_verb_min ] ].

; <type val="v_pp-vp_ssr_le">
; <description>Cmps PP(opt),VP(inf), s-s-rais   
; <ex>It seems to B to be windy.
; <nex>
; <todo>
; </type>
v_pp-vp_ssr_le := main_verb_mliszt & 
  [ SYNSEM ssr_pp_inf_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM ssr_pp_inf_verb_min ] ].

; DPF 29-aug-07 - These verbs like "become" supposedly don't combine with
; predicative VPs, but stative passives often seem to be fine, 
; as in ; "This picture became damaged/associated with Picasso" or
; "We became inspired by the music."  Rather than adding a lexical rule to
; convert them to predicative adjs, consider a HEAD supertype of basic_adj
; and passive-verb.  FIX.

; <type val="v_ap-pp_seq_le">
; <description>Cmps AP,PP(opt), s-equi          
; <ex>B sounded good to C.
; <nex>
; <todo>
; </type>
v_ap-pp_seq_le := main_verb_mliszt & 
  [ SYNSEM seq_ap_pp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM seq_ap_pp_verb_min ] ].

; <type val="v_pp-pp_seq_le">
; <description>Cmps PP(like),PP(opt), s-equi    
; <ex>B sounded like C to D.
; <nex>
; <todo>
; </type>
v_pp-pp_seq_le := main_verb_mliszt & 
  [ SYNSEM seq_pp_pp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM seq_pp_pp_verb_min ] ].

; <type val="v_prd-pp_seq_le">
; <description>Cmps Pred-phr,PP(opt), s-equi    
; <ex>B seemed good to C.
; <nex>
; <todo>
; </type>
v_prd-pp_seq_le := main_verb_mliszt & 
  [ SYNSEM seq_aorp_pp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM seq_aorp_pp_verb_min ] ].

; feel good about
; <type val="v_ap-pp_about_le">
; <description>Cmps AP,PP(about, sel), s-equi   
; <ex>B felt good about C.
; <nex>
; <todo>
; </type>
v_ap-pp_about_le := main_verb_mliszt & 
  [ SYNSEM seq_prdp_pp_about_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM seq_prdp_pp_about_verb_min ] ].

; <type val="v_np-pp_to_le">
; <description>Cmps NP(obl),PP(obl,to,sel)      
; <ex>B attributed C to D.
; <nex>
; <todo>
; </type>
v_np-pp_to_le := main_verb & 
  [ SYNSEM empty_to_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_to_trans_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT - ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np-pp*_to_le">
; <description>Cmps NP(obl),PP(opt,to,sel)      
; <ex>B converted C to D.
; <nex>
; <todo>
; </type>
v_np-pp*_to_le := main_verb & 
  [ SYNSEM empty_to_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_to_trans_verb_min,
			 VAL.COMPS < [ OPT - ], [ OPT + ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <type val="v_np*-pp_to_le">
; <description>Cmps NP(opt),PP(obl,to,sel)      
; <ex>B added C to D.
; <nex>
; <todo>
; </type>
v_np*-pp_to_le := main_verb & 
  [ SYNSEM empty_to_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_to_trans_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT - ] > ],
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np*-pp*_to_le">
; <description>Cmps NP(opt),PP(opt,to,sel)      
; <ex>B explained C to D.
; <nex>
; <todo>
; </type>
v_np*-pp*_to_le := main_verb & 
  [ SYNSEM empty_to_trans_verb &
	   [ LOCAL.CAT [ HEAD.LSYNSEM empty_to_trans_verb_min,
			 VAL.COMPS < [ OPT + ], [ OPT + ] > ] ] ].

; <type val="v_-_unacc_le">
; <description>No cmps, unaccusative            
; <ex>The plate gleamed.
; <nex>
; <todo>
; </type>
v_-_unacc_le := main_verb & 
  [ SYNSEM unacc_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM unacc_verb_min ] ].

; <type val="v_-_le">
; <description>No cmps, unergative              
; <ex>B arose.
; <nex>
; <todo>
; </type>
v_-_le := main_verb & 
  [ SYNSEM unerg_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM unerg_verb_min ] ].

; <type val="v_-_imp_le">
; <description>No cmps, unergative, hd_imp_c only  
; <ex>Begone!
; <nex>
; <todo>
; </type>
v_-_imp_le := main_verb & 
  [ SYNSEM unerg_imp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM unerg_imp_verb_min ] ].

; <type val="v_-_bse_le">
; <description>No cmps, base form only          
; <ex>That will do.
; <nex>
; <todo>
; </type>
v_-_bse_le := main_verb & 
  [ SYNSEM unerg_bse_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM unerg_bse_verb_min ] ].

; <type val="v_np_poss_le">
; <description>Cmps NP, only have               
; <ex>B has C.
; <nex>
; <todo>
; </type>
v_np_poss_le := main_verb & 
  [ SYNSEM poss_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM poss_verb_min ] ].

;; DPF 19-feb-10 - Prevent "got there" via COMPS..NORM no_rel.
;; DPF 07-apr-10 - No longer remember why we have this, given the ordinary
;; NP-complement get_v2.  It does not appear in any of the treebanked data,
;; so let's try living without it, to avoid spurious ambiguity for e.g.
;; "he has got cats"

; <type val="v_np_got_le">
; <description>Cmps NP, only got                
; <ex>B got C.
; <nex>
; <todo>
; </type>
v_np_got_le := norm_nonconj_word &
  [ SYNSEM poss_got_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM poss_got_verb_min ] ].
			  
; <type val="v_cp_rkey-bse_le">
; <description>Cmps S, embedded subj tag, base  
; <ex>I'll suppose C can, can he
; <nex>
; <todo>
; </type>
v_cp_rkey-bse_le := v_cp_prop_raise_key_lexent &
  [ SYNSEM.LOCAL bse_verb &
		 [ CAT.HEAD.LSYNSEM cp_prop_raise_key_verb_min ] ].

; <type val="v_cp_rkey-3sg_le">
; <description>Cmps S, embedded subj tag, 3sing 
; <ex>B supposes C can, can't he
; <nex>
; <todo>
; </type>
v_cp_rkey-3sg_le := v_cp_prop_raise_key_lexent &
  [ SYNSEM cp_prop_raise_key_3sg_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_raise_key_3sg_verb_min ] ].

; <type val="v_cp_rkey-n3sg_le">
; <description>Cmps S, embedded subj tag, non3s 
; <ex>We suppose C can, can't he
; <nex>
; <todo>
; </type>
v_cp_rkey-n3sg_le := v_cp_prop_raise_key_lexent &
  [ SYNSEM cp_prop_raise_key_n3sg_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_raise_key_n3sg_verb_min ] ].

; <type val="v_cp_rkey-pst_le">
; <description>Cmps S, embedded subj tag, past  
; <ex>I supposed C is, isn't he
; <nex>
; <todo>
; </type>
v_cp_rkey-pst_le := v_cp_prop_raise_key_lexent &
  [ SYNSEM cp_prop_raise_key_pst_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_raise_key_pst_verb_min ] ].

; <type val="v_cp_rkey-prp_le">
; <description>Cmps S, embedded subj tag, prp   
; <ex>I'm supposing C is, is he
; <nex>
; <todo>
; </type>
v_cp_rkey-prp_le := v_cp_prop_raise_key_lexent &
  [ SYNSEM cp_prop_raise_key_prp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_raise_key_prp_verb_min ] ].

; <type val="v_cp_rkey-psp_le">
; <description>Cmps S, embedded subj tag, psp   
; <ex>I've supposed C is, is he
; <nex>
; <todo>
; </type>
v_cp_rkey-psp_le := v_cp_prop_raise_key_lexent &
  [ SYNSEM cp_prop_raise_key_psp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM cp_prop_raise_key_psp_verb_min ] ].

; <type val="v_adv_le">
; <description>Cmps Adv-phr                     
; <ex>B did badly.
; <nex>
; <todo>
; </type>
v_adv_le := norm_basic_main_verb &
  [ SYNSEM adv_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM adv_verb_min ] ,
    INFLECTD - ].

; <type val="v_np-adv_le">
; <description>Cmps NP, Adv-phr                     
; <ex>B put it badly.
; <nex>
; <todo>
; </type>
v_np-adv_le := norm_basic_main_verb &
  [ SYNSEM np_adv_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM np_adv_verb_min ] ,
    INFLECTD - ].

; 'made': "Kim made sandy arrive' but "Sandy was made TO arrive'
; <type val="v_vp_sorb-psv_le">
; <description>Cmps VP(inf), psv, s-o-rais      
; <ex>B was made to arrive.
; <nex>
; <todo>
; </type>
v_vp_sorb-psv_le := norm_basic_main_verb &
  [ SYNSEM sor_psv_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM sor_psv_verb_min ] ,
    INFLECTD - ].

; 'faded'
; <type val="v_-_psv_le">
; <description>No cmps, psv                     
; <ex>B was faded.
; <nex>
; <todo>
; </type>
v_-_psv_le := norm_basic_main_verb &
  [ SYNSEM passive_unerg_synsem &
	   [ LOCAL.CAT.HEAD.LSYNSEM passive_unerg_synsem_min ],
    INFLECTD + ].

; 'born'
; <type val="v_-_psv-prd_le">
; <description>No cmps, psv, predicative only
; <ex>B was born.
; <nex>*The born child cried.
; <todo>
; </type>
v_-_psv-prd_le := norm_basic_main_verb &
  [ INFLECTD +,
    SYNSEM passive_unerg_synsem &
	   [ LOCAL.CAT.HEAD.LSYNSEM passive_unerg_synsem_min ],
    ALTS.ATTRJ - ].

; 'faded'
; <type val="v_-_psv-att_le">
; <description>No cmps, psv, attributive only
; <ex>The flopped issue disappeared.
; <nex>
; <todo>
; </type>
v_-_psv-att_le := norm_basic_main_verb &
  [ SYNSEM passive_unerg_synsem &
	   [ LOCAL.CAT [ HEAD [ LSYNSEM passive_unerg_synsem_min,
				MINORS.NORM norm_rel ],
			 VAL.SUBJ < canonical_synsem >,
			 POSTHD - ],
	     NONLOC.SLASH 0-dlist ],
    INFLECTD + ].

; 'horseback riding'
; <type val="v_-_prp_le">
; <description>No cmps, prp only
; <ex>B went horseback riding
; <nex>
; <todo>
; </type>
v_-_prp_le := norm_basic_main_verb &
  [ SYNSEM unerg_prp_verb &
	   [ LOCAL.CAT.HEAD.LSYNSEM unerg_prp_verb_min ] ,
    INFLECTD + ].

;; 'put' - "That was well put", but block in n-v compounds like "*idea-put"
;; Also block depictives via OPT -
;;
; <type val="v_-_psv-ncnh_le">
; <description>No cmps, psv, no n-v-ed cmpnd    
; <ex>That was put clearly.
; <nex>
; <todo>
; </type>
v_-_psv-ncnh_le := norm_basic_main_verb &
  [ INFLECTD +,
    SYNSEM passive_unerg_synsem &
	   [ LOCAL.CAT.HEAD [ LSYNSEM passive_unerg_synsem_min,
			      MINORS.NORM norm_rel ],
	     OPT - ] ].

; 'unevaluated (by Abrams)'
; <type val="v_-_psv-neg_le">
; <description>No cmps, psv, neg semantics      
; <ex>B was unevaluated.
; <nex>
; <todo>
; </type>
v_-_psv-neg_le := main_verb_newltop &
  [ SYNSEM passive_unerg_neg_synsem &
	   [ LOCAL.CAT.HEAD.LSYNSEM passive_unerg_neg_synsem_min ] ,
    INFLECTD + ].

; <type val="v_np_thr-s_le">
; <description>Cmps NP, expl-there subj         
; <ex>There existed many dogs.
; <nex>
; <todo>
; </type>
v_np_thr-s_le := main_verb & 
  [ SYNSEM there_verb_nohc_synsem &
	   [ LOCAL.CAT.HEAD.LSYNSEM there_verb_nohc_synsem_min ] ].

; <type val="v_np_locinv-mv_le">
; <description>Cmps NP, loc inversion           
; <ex>In the room stood a clock.
; <nex>
; <todo>
; </type>
v_np_locinv-mv_le := loc_inv_mv_word.

; <type val="v_np_locinv-is_le">
; <description>Cmps NP, loc inversion, aux is   
; <ex>In the room is a clock.
; <nex>
; <todo>
; </type>
v_np_locinv-is_le := loc_inv_be_word &
  [ SYNSEM.LOCAL [ CAT.HEAD.TAM.TENSE present,
                   AGR.PNG.PN 3s ] ].

; <type val="v_np_locinv-are_le">
; <description>Cmps NP, loc inversion, aux are  
; <ex>In the room are clocks.
; <nex>
; <todo>
; </type>
v_np_locinv-are_le := loc_inv_be_word &
  [ SYNSEM.LOCAL [ CAT.HEAD.TAM.TENSE present,
                   AGR.PNG.PN 3p ] ].

; <type val="v_np_locinv-was_le">
; <description>Cmps NP, loc inversion, aux was  
; <ex>In the room was a clock.
; <nex>
; <todo>
; </type>
v_np_locinv-was_le := loc_inv_be_word &
  [ SYNSEM.LOCAL [ CAT.HEAD.TAM.TENSE past,
                   AGR.PNG.PN 3s ] ].

; <type val="v_np_locinv-were_le">
; <description>Cmps NP, loc inversion, aux were 
; <ex>In the room were clocks.
; <nex>
; <todo>
; </type>
v_np_locinv-were_le := loc_inv_be_word &
  [ SYNSEM.LOCAL [ CAT.HEAD.TAM.TENSE past,
                   AGR.PNG.PN 3p ] ].

; <type val="v_np_locinv-be_le">
; <description>Cmps NP, loc inversion, aux be 
; <ex>In the room will be clocks.
; <nex>
; <todo>
; </type>
v_np_locinv-be_le := basic_loc_inv_be_word &
  [ SYNSEM.LOCAL.CAT.HEAD [ VFORM bse,
			    TAM.TENSE no_tense ] ].