;;; -*- Mode: tdl; Coding: utf-8; -*-
;;;
;;;  Copyright (c) 1994-2005
;;;    Dan Flickinger, Rob Malouf, Emily M. Bender
;;;    see erg/licence.txt for conditions
;;;
;;;  letypes.tdl
;;;
;;;  Lexical entry types (yield of lextypes hierarchy)
;;;
;;;  Created by Dan Flickinger, 15-June-1996
;;;
;;;  $Id$


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

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

; <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 & 
            [ LOCAL.CAT.VAL.COMPS < [ LOCAL.CAT.HEAD comp ] > ] ].

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

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

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

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

; <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_verb &
	   [ LOCAL.CAT.HEAD [ VFORM bse,
			      TAM [ TENSE present,
				    MOOD indicative ] ] ] ].

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

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

;; 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.VAL.COMPS.FIRST.OPT - ] ].
;; answer
; <type val="v_np*-cp_le">
; <description>Cmps NP,S (fin, +/-Q)            
; <ex>B warned (C) that D won.
; <nex>
; <todo>
; </type>
v_np*-cp_le := main_verb & 
  [ SYNSEM np_trans_cp_verb &
	   [ LOCAL.CAT.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.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.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.VAL.COMPS.FIRST.OPT - ] ].

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

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

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

; Robust type for grammar-checking, e.g. for "This device allows to see."
; <type val="v_vp_seq-rbst_le">
; <description>Cmps VP, s-equi, robust          
; <ex>*B enables to win.
; <nex>
; <todo>
; </type>
v_vp_seq-rbst_le := main_verb & 
  [ SYNSEM subj_equi_verb,
    GENRE robust ].

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

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

; <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_nogap_verb,
    IDIOM + ].

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

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

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

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

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

; '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_verb &
	   [ LOCAL.CAT.HEAD.VFORM bse ] ].

; '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 pres_verb & [ CAT.HEAD.VFORM fin ] ] ].

; 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_verb &
           [ LOCAL [ CAT.HEAD.VFORM fin,
                     AGR.PNG.PN -3s ] ] ].

; 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_verb &
           [ LOCAL.CAT.HEAD.VFORM bse ] ].

; 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.VFORM bse ] ].

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

; "*This lets the cat to enter"
; <type val="v_np-vp_oeq-rbst_le">
; <description>Cmps NP,VP (base), o-equi        
; <ex>*B let C to win.
; <nex>
; <todo>
; </type>
v_np-vp_oeq-rbst_le := main_verb & 
  [ SYNSEM obj_equi_verb,
    GENRE robust ].

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

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

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

; 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 &
	   [ 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 &
	   [ 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 ].


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

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

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

; 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 &
            [ 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 &
            [ 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 &
            [ 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 &
            [ 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 &
            [ 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.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 &
	   [ 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.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 &
	   [ 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 ].

; 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.VAL.COMPS < [ OPT + ], 
                                   [ OPT + ],
				   [ LOCAL.CONT.HOOK.INDEX.SF prop ] > ] ].

; 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.VAL.COMPS < [ OPT + ], 
                                   [ OPT - ],
				   [ LOCAL.CONT.HOOK.INDEX.SF prop ] > ] ].

; '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.VAL.COMPS < [ OPT - ], 
                                   [ OPT + ],
				   [ LOCAL.CONT.HOOK.INDEX.SF prop ] > ] ].

;; 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.VAL.COMPS
                            < [ OPT + ], 
                              [ LOCAL.CONT.HOOK.INDEX.SF prop-or-like ] >,
             LKEYS.--COMPKEY _to_p_sel_rel ] ].

;; 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.VAL.COMPS 
                            < [ OPT - ], 
                              [ LOCAL.CONT.HOOK.INDEX.SF prop-or-like ] >,
             LKEYS.--COMPKEY _to_p_sel_rel ] ].

;; 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_verb &
	   [ LOCAL.CAT.VAL.COMPS 
                       < [ OPT + ], 
                         [ LOCAL [ CAT.HEAD comp,
                                   CONT.HOOK.INDEX.SF like-iforce ] ] >,
             LKEYS.--COMPKEY _to_p_sel_rel ] ].


;; It doesn't matter who stays
; <type val="v_pp*-cp_unsp_le">
; <description>It-subj, Cmps (PP),S(+/-Q)       
; <ex>It mattered whether S won.
; <nex>
; <todo>
; </type>
v_pp*-cp_unsp_le := main_verb & 
  [ SYNSEM expl_it_subj_pp_cp_verb &
	   [ LOCAL.CAT.VAL.COMPS 
                            < [ OPT + ], 
                              [ LOCAL.CONT.HOOK.INDEX.SF prop-or-ques ] >,
             LKEYS.--COMPKEY _to_p_sel_rel ] ].

;; 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_pp_cp_verb &
	   [ LOCAL.CAT.VAL.COMPS 
                            < [ OPT - ], 
                              [ LOCAL.CONT.HOOK.INDEX.SF prop-or-like ] > ] ].


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

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

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

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

; suggest
; <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 := main_verb & 
  [ SYNSEM pp_cp_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ OPT + ],
				   [ --SIND.SF prop ] > ] ].

; mean by X that Y
; <type val="v_pp-cp_le">
; <description>Cmps PP(sel, obl),S(fin/inf)     
; <ex>B meant by C that D won.
; <nex>
; <todo>
; </type>
v_pp-cp_le := main_verb & 
  [ SYNSEM pp_cp_verb &
	   [ LOCAL.CAT.VAL.COMPS.FIRST.OPT - ] ].

; <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.VAL.COMPS.FIRST.OPT + ] ].

; '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.VAL.COMPS.FIRST.OPT - ] ].

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

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

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

; 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.VAL.COMPS.FIRST.OPT - ] ].

; <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.VAL.COMPS < [ OPT - ], [ OPT - ] > ] ].

; '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.VAL.COMPS < [ OPT - ], [ OPT + ] > ] ].

; <type val="v_np*-np*_le">
; <description>Cmps NP(opt),NP(opt), dative alt 
; <ex>B paid C the money.
; <nex>
; <todo>
; </type>
v_np*-np*_le := main_verb & 
  [ SYNSEM ditrans_verb & 
	   [ LOCAL.CAT.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 & 
  [ SYNSEM ditrans_only_verb & 
	   [ LOCAL.CAT.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 & 
  [ SYNSEM ditrans_only_verb & 
	   [ LOCAL.CAT.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 & 
  [ SYNSEM ditrans_only_verb & 
	   [ LOCAL.CAT.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.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.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.VAL.COMPS < [ OPT - ], [ OPT - ] >,
             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_pp_verb & 
	   [ LOCAL.CAT.VAL.COMPS < [ OPT + ], [ OPT + ], 
                                   [ OPT -,
                                     LOCAL.CAT.HEAD.MINORS.MIN #ocmin &
                                         _to_p_sel_rel ] >,
             LKEYS.--+OCOMPKEY #ocmin ] ].

; <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_pp_verb & 
	   [ LOCAL.CAT.VAL.COMPS < [ OPT - ], [ OPT + ], 
                                   [ OPT -,
                                     LOCAL.CAT.HEAD.MINORS.MIN #ocmin &
                                         _to_p_sel_rel ] >,
             LKEYS.--+OCOMPKEY #ocmin ] ].

; <type val="v_np*-pp*-ppfor_le">
; <description>Cmps NP(opt),PP(sel,opt),PP(for) 
; <ex>B converted C from D to E.
; <nex>
; <todo>
; </type>
v_np*-pp*-ppfor_le := main_verb & 
  [ SYNSEM np_trans_double_pp_verb & 
  	   [ LOCAL.CAT.VAL.COMPS < [ OPT + ], [ OPT + ], 
                                   [ OPT -,
                                     LOCAL.CAT.HEAD.MINORS.MIN #ocmin &
                                         _for_p_sel_rel ] >,
             LKEYS.--+OCOMPKEY #ocmin ] ].

; <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.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.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.VAL.COMPS < [ OPT + ], [ OPT - ] >,
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <type val="v_np-pp*_e-imp_le">
; <description>Cmps NP(obl),PP(sel,opt), imper  
; <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,
                           VAL [ SUBJ < [ LOCAL.CONT.HOOK.INDEX #ind ] >,
                                 COMPS < [ OPT - ], [ OPT + ] > ] ],
                     AGR #ind ],
             LKEYS.KEYREL.ARG1 #ind & [ PNG.PN 1 ] ] ].
; take into account
; <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.VAL.COMPS < [ OPT - ], [ OPT - ] >,
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ],
    IDIOM + ].

; <type val="v_np-pp*_e-idm_le">
; <description>Cmps NP(obl),PP(sel,opt), idiom  
; <ex>B lost sight of C.
; <nex>
; <todo>
; </type>
v_np-pp*_e-idm_le := main_verb & 
  [ SYNSEM empty_prep_trans_verb & 
	   [ LOCAL.CAT.VAL.COMPS < [ OPT - ], [ OPT + ] > ],
    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.VAL.COMPS < [ OPT - ] >,
             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.VAL.COMPS < [ OPT - ], [ OPT - ] >,
             LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

;; '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.VAL.COMPS.FIRST.OPT - ] ].

;; '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_cp_verb &
	 [ LOCAL.CAT.VAL.COMPS < [ OPT - ], 
                                 [ LOCAL [ CAT.HEAD comp,
                                           CONT.HOOK.INDEX.SF prop ] ] >,
           LKEYS [ --COMPKEY #cmin,
                   --+COMPKEY #cmin ] ] ].

;; '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_cp_verb &
	 [ LOCAL.CAT.VAL.COMPS < [ OPT - ], 
                                 [ LOCAL.CONT.HOOK.INDEX.SF prop ] >]].
; '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 ].

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

; <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.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.VAL.COMPS < [ OPT - ] >,
             LKEYS.KEYREL.ARG3 semarg ] ].

; <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_verb &
	   [ LOCAL.CAT [ HEAD [ VFORM bse,
                                TAM [ TENSE present,
                                      MOOD indicative ] ],
                         VAL.COMPS < [ OPT + ] > ] ] ].

; <type val="v_np_idm_le">
; <description>Cmps NP, idiom                   
; <ex>We racked our brains.
; <nex>
; <todo>
; </type>
v_np_idm_le := main_verb_mliszt & 
  [ SYNSEM np_trans_refl_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ OPT - ] > ],
    IDIOM + ].

; For e.g. "recieve"
; <type val="v_np_rbst_le">
; <description>Cmps NP, robust (eg misspelled)  
; <ex>*We recieved the book.
; <nex>
; <todo>
; </type>
v_np_rbst_le := main_verb & 
  [ SYNSEM np_trans_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ OPT - ] > ],
    GENRE robust ].

; '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.VAL.COMPS < [ OPT - ], [ OPT - ] > ] ].

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

; <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_verb & 
	   [ LOCAL.CAT [ HEAD [ VFORM non_fin,
                                TAM [ TENSE present,
                                      MOOD indicative ] ],
                         VAL.COMPS < [ OPT - ] > ],
             LKEYS [ --COMPKEY #cmin,
                     --+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 & 
	   [ 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_verb & 
	   [ LOCAL.CAT.VAL.COMPS < synsem,
                                   [ LOCAL.CAT.HEAD.MINORS
                                       [ MIN dir_or_state_nontemp_rel ] ] > ]].
;; 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 &
           [ LKEYS [ --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <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 &
	   [ 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.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.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.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.VAL.COMPS < [ OPT - ] > ] ].

; '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_verb & 
	   [ LOCAL.CAT.VAL.COMPS < canonical_synsem &
				   [ OPT -,
				     LOCAL.CAT.VAL.SPEC < > ] > ],
    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 &
	   [ 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 &
	   [ 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 &
	   [ 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 &
	   [ 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 &
	   [ 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 &
	   [ 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.VAL.COMPS < synsem, [ OPT - ] >,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <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.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.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_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < synsem, synsem,
                                   [ LOCAL.CAT.HEAD.MINORS.MIN _to_p_sel_rel ]>,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; '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_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < synsem, synsem,
                                   [ LOCAL.CAT.HEAD.MINORS.MIN _of_p_sel_rel ]>,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].


; <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_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < synsem, synsem,
                                   [ LOCAL.CAT.HEAD.MINORS.MIN _for_p_sel_rel]>,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <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_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < synsem, synsem, 
                                   [ LOCAL.CAT.HEAD.MINORS.MIN _from_p_sel_rel]>,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin,
                     --OCOMPKEY #ocmin,
                     --+OCOMPKEY #ocmin ] ] ].

; <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 &
           [ LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].

; <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.VAL.COMPS < [ OPT - ] > ] ].
; <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.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.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.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.VAL.COMPS < [ OPT + ] > ] ].

; <type val="v_pp_unacc_le">
; <description>Cmps PP(obl), unacc              
; <ex>The seed grew into a tree.
; <nex>
; <todo>
; </type>
v_pp_unacc_le := main_verb  & 
  [ SYNSEM prep_intrans_unacc_verb & 
	   [ LOCAL.CAT.VAL.COMPS < [ OPT + ] > ] ].

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

; <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 ].
; 'have to': no imperative "*Have to leave!"
; <type val="v_vp_ssr-nimp_le">
; <description>Cmps VP(inf), s-s-rais, no imper 
; <ex>There tend to be problems.
; <nex>
; <todo>
; </type>
v_vp_ssr-nimp_le := main_verb & 
  [ SYNSEM ssr_noimp_verb ].

; DPF 26-aug-07 - Merged with v_ap_seq_le
;v_ap_ssr_le := main_verb_mliszt & 
;  [ SYNSEM subj_equi_prd_adj_verb &
;	   [ LOCAL.CAT.VAL.COMPS < [ LOCAL.CAT.HEAD basic_adj ] > ] ].

; <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.VAL.COMPS.FIRST.OPT + ] ].

; 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_prdp_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ LOCAL.CAT.HEAD basic_adj ], 
                                   [ OPT + ] > ] ].
; <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_prdp_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ LOCAL.CAT.HEAD prep ], 
                                   [ OPT + ] >,
             LKEYS [ --COMPKEY #cmin,
                     --+COMPKEY #cmin ] ] ].
; <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_prdp_pp_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ LOCAL.CAT.HEAD a_or_p ],
                                   [ OPT + ] > ] ].
; 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.VAL.COMPS < [ LOCAL.CAT.HEAD v_or_a ], 
                                   [ OPT + ] > ] ].

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

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

; <type val="v_-_imp_le">
; <description>No cmps, unergative, imper only  
; <ex>Begone!
; <nex>
; <todo>
; </type>
v_-_imp_le := main_verb & 
  [ SYNSEM unerg_verb &
           [ LOCAL.CAT.HEAD.VFORM imp_vform ] ].
; <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_verb &
           [ LOCAL.CAT.HEAD.VFORM bse_only ] ].

; <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.VAL.COMPS < [ OPT - ] > ] ].

; <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_verb & 
	   [ LOCAL non_fin_verb &
	         [ CAT [ HEAD [ VFORM psp,
				PRD - ],
			 VAL.COMPS < [ OPT - ] > ],
		   CONT.RELS <! relation !> ] ] ].
			  
; <type val="v_prd_got_le">
; <description>Cmps Pred-phr, only got          
; <ex>B got ready.
; <nex>
; <todo>
; </type>
v_prd_got_le := norm_nonconj_word &
  [ SYNSEM obj_equi_non_trans_prd_verb &
	   [ LOCAL non_fin_verb &
	         [ CAT.HEAD [ VFORM psp,
                              PRD - ] ] ] ].

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

; <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.LOCAL fin_verb & [ CAT [ HEAD.TAM indic_tam & 
                                             [ TENSE nonpast,
                                               ASPECT no_aspect ],
                                    VAL.SUBJ < [ LOCAL.AGR.PNG.PN 3s ] > ] ] ].

; <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.LOCAL fin_verb & [ CAT [ HEAD.TAM indic_tam & 
                                             [ TENSE nonpast,
                                               ASPECT no_aspect ],
                                    VAL.SUBJ < [ LOCAL.AGR.PNG.PN -3s ] > ] ]].

; <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.LOCAL past_or_subj_verb ].

; <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.LOCAL prp_verb ].

; <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.LOCAL psp_verb ].

; <type val="v_adv_le">
; <description>Cmps Adv-phr                     
; <ex>B did badly.
; <nex>
; <todo>
; </type>
v_adv_le := basic_main_verb & 
  [ INFLECTD -,
    SYNSEM adv_verb &
	   [ LOCAL.CAT.VAL.COMPS < [ OPT - ] > ] ].

; '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 := basic_main_verb & 
  [ INFLECTD -,
    SYNSEM sor_verb &
            [ LOCAL verb_participle_affix &
                    [ CAT [ HEAD.VFORM pas,
			    VAL [ SUBJ < [ OPT - ] >,
				  COMPS < [ OPT - ], ... > ] ],
		      CONT psoa & [ RELS <! relation !> ] ] ] ].

; 'born'
; <type val="v_-_psv_le">
; <description>No cmps, psv                     
; <ex>B was born.
; <nex>
; <todo>
; </type>
v_-_psv_le := basic_main_verb & 
  [ INFLECTD +,
    SYNSEM passive_unerg_synsem &
           [ LOCAL.CONT.HCONS <! !> ] ].

; 'put' - "That was well put", but block in n-v compounds like "*idea-put"
; <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 := basic_main_verb & 
  [ INFLECTD +,
    SYNSEM passive_unerg_synsem &
           [ LOCAL [ CAT.POSTHD +,
		     CONT.HCONS <! !> ] ] ].

; '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 &
  [ INFLECTD +,
    SYNSEM passive_unerg_neg_synsem ].

; <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_synsem &
           [ LOCAL.CONT.HCONS <! !> ] ].

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