TFL/usyntax.sml

+structure USyntax : USyntax_sig =
+struct
+
+structure Utils = Utils;
+open Utils;
+open Mask;
+
+infix 7 |->;
+infix 4 ##;
+
+fun ERR{func,mesg} = Utils.ERR{module = "USyntax", func = func, mesg = mesg};
+
+type Type = typ
+type Term = cterm
+type Preterm = term
+
+
+(*---------------------------------------------------------------------------
+ *
+ *                            Types 
+ *
+ *---------------------------------------------------------------------------*)
+fun mk_type{Tyop, Args} = Type(Tyop,Args);
+val mk_prim_vartype = TVar;
+fun mk_vartype s = mk_prim_vartype((s,0),["term"]);
+
+fun dest_type(Type(ty,args)) = {Tyop = ty, Args = args}
+  | dest_type _ = raise ERR{func = "dest_type", mesg = "Not a compound type"};
+
+
+(* But internally, it's useful *)
+fun dest_vtype (TVar x) = x
+  | dest_vtype _ = raise ERR{func = "dest_vtype", 
+                             mesg = "not a flexible type variable"};
+
+val is_vartype = Utils.can dest_vtype;
+
+val type_vars  = map mk_prim_vartype o typ_tvars
+fun type_varsl L = Utils.mk_set (Utils.curry op=)
+                      (Utils.rev_itlist (Utils.curry op @ o type_vars) L []);
+
+val alpha  = mk_vartype "'a"
+val beta   = mk_vartype "'b"
+
+val bool = Type("bool",[]);
+
+fun match_type ty1 ty2 = raise ERR{func="match_type",mesg="not implemented"};
+
+
+(* What nonsense *)
+nonfix -->; 
+val --> = -->;
+infixr 3 -->;
+
+(* hol_type -> hol_type list * hol_type *)
+fun strip_type ty =
+   let val {Tyop = "fun", Args = [ty1,ty2]} = dest_type ty
+       val (D,r) = strip_type ty2
+   in (ty1::D, r)
+   end
+   handle _ => ([],ty);
+
+(* hol_type -> hol_type list *)
+fun strip_prod_type ty =
+   let val {Tyop = "*", Args = [ty1,ty2]} = dest_type ty
+   in strip_prod_type ty1 @ strip_prod_type ty2
+   end handle _ => [ty];
+
+
+
+(*---------------------------------------------------------------------------
+ *
+ *                              Terms 
+ *
+ *---------------------------------------------------------------------------*)
+nonfix aconv;
+val aconv = Utils.curry (op aconv);
+
+fun free_vars tm = add_term_frees(tm,[]);
+
+
+(* Free variables, in order of occurrence, from left to right in the 
+ * syntax tree. *)
+fun free_vars_lr tm = 
+  let fun memb x = let fun m[] = false | m(y::rst) = (x=y)orelse m rst in m end
+      fun add (t, frees) = case t of
+            Free   _ => if (memb t frees) then frees else t::frees
+          | Abs (_,_,body) => add(body,frees)
+          | f$t =>  add(t, add(f, frees))
+          | _ => frees
+  in rev(add(tm,[]))
+  end;
+
+
+
+fun free_varsl L = Utils.mk_set aconv
+                      (Utils.rev_itlist (Utils.curry op @ o free_vars) L []);
+
+val type_of =  type_of;
+val type_vars_in_term = map mk_prim_vartype o term_tvars;
+
+(* Can't really be very exact in Isabelle *)
+fun all_vars tm = 
+  let fun memb x = let fun m[] = false | m(y::rst) = (x=y)orelse m rst in m end
+      fun add (t, A) = case t of
+            Free   _ => if (memb t A) then A else t::A
+          | Abs (s,ty,body) => add(body, add(Free(s,ty),A))
+          | f$t =>  add(t, add(f, A))
+          | _ => A
+  in rev(add(tm,[]))
+  end;
+fun all_varsl L = Utils.mk_set aconv
+                      (Utils.rev_itlist (Utils.curry op @ o all_vars) L []);
+
+
+(* Prelogic *)
+val subst = subst_free o map (fn (a |-> b) => (a,b));
+
+fun dest_tybinding (v |-> ty) = (#1(dest_vtype v),ty)
+fun inst theta = subst_vars (map dest_tybinding theta,[])
+
+fun beta_conv((t1 as Abs _ ) $ t2) = betapply(t1,t2)
+  | beta_conv _ = raise ERR{func = "beta_conv", mesg = "Not a beta-redex"};
+
+
+(* Construction routines *)
+(* fun mk_var{Name,Ty} = Var((Name,0),Ty); *)
+fun mk_var{Name,Ty} = Free(Name,Ty);
+val mk_prim_var = Var;
+
+val string_variant = variant;
+
+local fun var_name(Var((Name,_),_)) = Name
+        | var_name(Free(s,_)) = s
+        | var_name _ = raise ERR{func = "variant",
+                                 mesg = "list elem. is not a variable"}
+in
+fun variant [] v = v
+  | variant vlist (Var((Name,i),ty)) = 
+       Var((string_variant (map var_name vlist) Name,i),ty)
+  | variant vlist (Free(Name,ty)) =
+       Free(string_variant (map var_name vlist) Name,ty)
+  | variant _ _ = raise ERR{func = "variant",
+                            mesg = "2nd arg. should be a variable"}
+end;
+
+fun mk_const{Name,Ty} = Const(Name,Ty)
+fun mk_comb{Rator,Rand} = Rator $ Rand;
+
+fun mk_abs{Bvar as Var((s,_),ty),Body}  = Abs(s,ty,abstract_over(Bvar,Body))
+  | mk_abs{Bvar as Free(s,ty),Body}  = Abs(s,ty,abstract_over(Bvar,Body))
+  | mk_abs _ = raise ERR{func = "mk_abs", mesg = "Bvar is not a variable"};
+
+fun list_mk_comb (h,[]) = h
+  | list_mk_comb (h,L) =
+      rev_itlist (fn t1 => fn t2 => mk_comb{Rator = t2, Rand = t1}) L h;
+
+
+fun mk_eq{lhs,rhs} = 
+   let val ty = type_of lhs
+       val c = mk_const{Name = "op =", Ty = ty --> ty --> bool}
+   in list_mk_comb(c,[lhs,rhs])
+   end
+
+fun mk_imp{ant,conseq} = 
+   let val c = mk_const{Name = "op -->", Ty = bool --> bool --> bool}
+   in list_mk_comb(c,[ant,conseq])
+   end;
+
+fun mk_select (r as {Bvar,Body}) = 
+  let val ty = type_of Bvar
+      val c = mk_const{Name = "Eps", Ty = (ty --> bool) --> ty}
+  in list_mk_comb(c,[mk_abs r])
+  end;
+
+fun mk_forall (r as {Bvar,Body}) = 
+  let val ty = type_of Bvar
+      val c = mk_const{Name = "All", Ty = (ty --> bool) --> bool}
+  in list_mk_comb(c,[mk_abs r])
+  end;
+
+fun mk_exists (r as {Bvar,Body}) = 
+  let val ty = type_of Bvar 
+      val c = mk_const{Name = "Ex", Ty = (ty --> bool) --> bool}
+  in list_mk_comb(c,[mk_abs r])
+  end;
+
+
+fun mk_conj{conj1,conj2} =
+   let val c = mk_const{Name = "op &", Ty = bool --> bool --> bool}
+   in list_mk_comb(c,[conj1,conj2])
+   end;
+
+fun mk_disj{disj1,disj2} =
+   let val c = mk_const{Name = "op |", Ty = bool --> bool --> bool}
+   in list_mk_comb(c,[disj1,disj2])
+   end;
+
+fun prod_ty ty1 ty2 = mk_type{Tyop = "*", Args = [ty1,ty2]};
+
+local
+fun mk_uncurry(xt,yt,zt) =
+    mk_const{Name = "split", Ty = (xt --> yt --> zt) --> prod_ty xt yt --> zt}
+fun dest_pair(Const("Pair",_) $ M $ N) = {fst=M, snd=N}
+  | dest_pair _ = raise ERR{func = "dest_pair", mesg = "not a pair"}
+fun is_var(Var(_)) = true | is_var (Free _) = true | is_var _ = false
+in
+fun mk_pabs{varstruct,body} = 
+ let fun mpa(varstruct,body) =
+       if (is_var varstruct)
+       then mk_abs{Bvar = varstruct, Body = body}
+       else let val {fst,snd} = dest_pair varstruct
+            in mk_comb{Rator= mk_uncurry(type_of fst,type_of snd,type_of body),
+                       Rand = mpa(fst,mpa(snd,body))}
+            end
+ in mpa(varstruct,body)
+ end
+ handle _ => raise ERR{func = "mk_pabs", mesg = ""};
+end;
+
+(* Destruction routines *)
+
+datatype lambda = VAR   of {Name : string, Ty : Type}
+                | CONST of {Name : string, Ty : Type}
+                | COMB  of {Rator: Preterm, Rand : Preterm}
+                | LAMB  of {Bvar : Preterm, Body : Preterm};
+
+
+fun dest_term(Var((s,i),ty)) = VAR{Name = s, Ty = ty}
+  | dest_term(Free(s,ty))    = VAR{Name = s, Ty = ty}
+  | dest_term(Const(s,ty))   = CONST{Name = s, Ty = ty}
+  | dest_term(M$N)           = COMB{Rator=M,Rand=N}
+  | dest_term(Abs(s,ty,M))   = let  val v = mk_var{Name = s, Ty = ty}
+                               in LAMB{Bvar = v, Body = betapply (M,v)}
+                               end
+  | dest_term(Bound _)       = raise ERR{func = "dest_term",mesg = "Bound"};
+
+fun dest_var(Var((s,i),ty)) = {Name = s, Ty = ty}
+  | dest_var(Free(s,ty))    = {Name = s, Ty = ty}
+  | dest_var _ = raise ERR{func = "dest_var", mesg = "not a variable"};
+
+fun dest_const(Const(s,ty)) = {Name = s, Ty = ty}
+  | dest_const _ = raise ERR{func = "dest_const", mesg = "not a constant"};
+
+fun dest_comb(t1 $ t2) = {Rator = t1, Rand = t2}
+  | dest_comb _ =  raise ERR{func = "dest_comb", mesg = "not a comb"};
+
+fun dest_abs(a as Abs(s,ty,M)) = 
+     let val v = mk_var{Name = s, Ty = ty}
+     in {Bvar = v, Body = betapply (a,v)}
+     end
+  | dest_abs _ =  raise ERR{func = "dest_abs", mesg = "not an abstraction"};
+
+fun dest_eq(Const("op =",_) $ M $ N) = {lhs=M, rhs=N}
+  | dest_eq _ = raise ERR{func = "dest_eq", mesg = "not an equality"};
+
+fun dest_imp(Const("op -->",_) $ M $ N) = {ant=M, conseq=N}
+  | dest_imp _ = raise ERR{func = "dest_imp", mesg = "not an implication"};
+
+fun dest_select(Const("Eps",_) $ (a as Abs _)) = dest_abs a
+  | dest_select _ = raise ERR{func = "dest_select", mesg = "not a select"};
+
+fun dest_forall(Const("All",_) $ (a as Abs _)) = dest_abs a
+  | dest_forall _ = raise ERR{func = "dest_forall", mesg = "not a forall"};
+
+fun dest_exists(Const("Ex",_) $ (a as Abs _)) = dest_abs a
+  | dest_exists _ = raise ERR{func = "dest_exists", mesg="not an existential"};
+
+fun dest_neg(Const("not",_) $ M) = M
+  | dest_neg _ = raise ERR{func = "dest_neg", mesg = "not a negation"};
+
+fun dest_conj(Const("op &",_) $ M $ N) = {conj1=M, conj2=N}
+  | dest_conj _ = raise ERR{func = "dest_conj", mesg = "not a conjunction"};
+
+fun dest_disj(Const("op |",_) $ M $ N) = {disj1=M, disj2=N}
+  | dest_disj _ = raise ERR{func = "dest_disj", mesg = "not a disjunction"};
+
+fun mk_pair{fst,snd} = 
+   let val ty1 = type_of fst
+       val ty2 = type_of snd
+       val c = mk_const{Name = "Pair", Ty = ty1 --> ty2 --> prod_ty ty1 ty2}
+   in list_mk_comb(c,[fst,snd])
+   end;
+
+fun dest_pair(Const("Pair",_) $ M $ N) = {fst=M, snd=N}
+  | dest_pair _ = raise ERR{func = "dest_pair", mesg = "not a pair"};
+
+
+local  val ucheck = Utils.assert (curry (op =) "split" o #Name o dest_const)
+in
+fun dest_pabs tm =
+   let val {Bvar,Body} = dest_abs tm
+   in {varstruct = Bvar, body = Body}
+   end handle _ 
+   => let val {Rator,Rand} = dest_comb tm
+          val _ = ucheck Rator
+          val {varstruct = lv,body} = dest_pabs Rand
+          val {varstruct = rv,body} = dest_pabs body
+      in {varstruct = mk_pair{fst = lv, snd = rv}, body = body}
+      end
+end;
+
+
+(* Garbage - ought to be dropped *)
+val lhs   = #lhs o dest_eq
+val rhs   = #rhs o dest_eq
+val rator = #Rator o dest_comb
+val rand  = #Rand o dest_comb
+val bvar  = #Bvar o dest_abs
+val body  = #Body o dest_abs
+  
+
+(* Query routines *)
+val is_var    = can dest_var
+val is_const  = can dest_const
+val is_comb   = can dest_comb
+val is_abs    = can dest_abs
+val is_eq     = can dest_eq
+val is_imp    = can dest_imp
+val is_forall = can dest_forall
+val is_exists = can dest_exists
+val is_neg    = can dest_neg
+val is_conj   = can dest_conj
+val is_disj   = can dest_disj
+val is_pair   = can dest_pair
+val is_pabs   = can dest_pabs
+
+
+(* Construction of a Term from a list of Terms *)
+
+fun list_mk_abs(L,tm) = itlist (fn v => fn M => mk_abs{Bvar=v, Body=M}) L tm;
+
+(* These others are almost never used *)
+fun list_mk_imp(A,c) = itlist(fn a => fn tm => mk_imp{ant=a,conseq=tm}) A c;
+fun list_mk_exists(V,t) = itlist(fn v => fn b => mk_exists{Bvar=v, Body=b})V t;
+fun list_mk_forall(V,t) = itlist(fn v => fn b => mk_forall{Bvar=v, Body=b})V t;
+val list_mk_conj = end_itlist(fn c1 => fn tm => mk_conj{conj1=c1, conj2=tm})
+val list_mk_disj = end_itlist(fn d1 => fn tm => mk_disj{disj1=d1, disj2=tm})
+
+
+(* Need to reverse? *)
+fun gen_all tm = list_mk_forall(free_vars tm, tm);
+
+(* Destructing a Term to a list of Terms *)
+fun strip_comb tm = 
+   let fun dest(M$N, A) = dest(M, N::A)
+         | dest x = x
+   in dest(tm,[])
+   end;
+
+fun strip_abs(tm as Abs _) =
+       let val {Bvar,Body} = dest_abs tm
+           val (bvs, core) = strip_abs Body
+       in (Bvar::bvs, core)
+       end
+  | strip_abs M = ([],M);
+
+
+fun strip_imp fm =
+   if (is_imp fm)
+   then let val {ant,conseq} = dest_imp fm
+	    val (was,wb) = strip_imp conseq
+        in ((ant::was), wb)
+        end
+   else ([],fm);
+
+fun strip_forall fm =
+   if (is_forall fm)
+   then let val {Bvar,Body} = dest_forall fm
+            val (bvs,core) = strip_forall Body
+        in ((Bvar::bvs), core)
+        end
+   else ([],fm);
+
+
+fun strip_exists fm =
+   if (is_exists fm)
+   then let val {Bvar, Body} = dest_exists fm 
+            val (bvs,core) = strip_exists Body
+        in (Bvar::bvs, core)
+        end
+   else ([],fm);
+
+fun strip_conj w = 
+   if (is_conj w)
+   then let val {conj1,conj2} = dest_conj w
+        in (strip_conj conj1@strip_conj conj2)
+        end
+   else [w];
+
+fun strip_disj w =
+   if (is_disj w)
+   then let val {disj1,disj2} = dest_disj w 
+        in (strip_disj disj1@strip_disj disj2)
+        end
+   else [w];
+
+fun strip_pair tm = 
+   if (is_pair tm) 
+   then let val {fst,snd} = dest_pair tm
+            fun dtuple t =
+               if (is_pair t)
+               then let val{fst,snd} = dest_pair t
+                    in (fst :: dtuple snd)
+                    end
+               else [t]
+        in fst::dtuple snd
+        end
+   else [tm];
+
+
+fun mk_preterm tm = #t(rep_cterm tm);
+
+fun mk_prop (tm as Const("Trueprop",_) $ _) = tm
+  | mk_prop tm = mk_comb{Rator=mk_const{Name = "Trueprop", 
+                           Ty = bool --> mk_type{Tyop = "prop",Args=[]}},
+                         Rand = tm};
+
+fun drop_Trueprop (Const("Trueprop",_) $ X) = X
+  | drop_Trueprop X = X;
+
+(* Miscellaneous *)
+
+fun mk_vstruct ty V =
+  let fun follow_prod_type ty vs =
+      let val {Tyop = "*", Args = [ty1,ty2]} = dest_type ty
+          val (ltm,vs1) = follow_prod_type ty1 vs
+          val (rtm,vs2) = follow_prod_type ty2 vs1
+      in (mk_pair{fst=ltm, snd=rtm}, vs2)
+      end handle _ => (hd vs, tl vs)
+ in fst(follow_prod_type ty V)
+ end;
+
+
+(* Search a term for a sub-term satisfying the predicate p. *)
+fun find_term p =
+   let fun find tm =
+      if (p tm)
+      then tm 
+      else if (is_abs tm)
+           then find (#Body(dest_abs tm))
+           else let val {Rator,Rand} = dest_comb tm
+                in find Rator handle _ => find Rand
+                end handle _ => raise ERR{func = "find_term",mesg = ""}
+   in find
+   end;
+
+(*******************************************************************
+ * find_terms: (term -> bool) -> term -> term list
+ * 
+ *  Find all subterms in a term that satisfy a given predicate p.
+ *
+ *******************************************************************)
+fun find_terms p =
+   let fun accum tl tm =
+      let val tl' = if (p tm) then (tm::tl) else tl 
+      in if (is_abs tm)
+         then accum tl' (#Body(dest_abs tm))
+         else let val {Rator,Rand} = dest_comb tm
+              in accum (accum tl' Rator) Rand
+              end handle _ => tl'
+      end
+   in accum []
+   end;
+
+
+val Term_to_string = string_of_cterm;
+
+fun dest_relation tm =
+   if (type_of tm = bool)
+   then let val (Const("op :",_) $ (Const("Pair",_)$y$x) $ R) = tm
+        in (R,y,x)
+        end handle _ => raise ERR{func="dest_relation",
+                                  mesg="unexpected term structure"}
+   else raise ERR{func="dest_relation",mesg="not a boolean term"};
+
+fun is_WFR tm = (#Name(dest_const(rator tm)) = "wf") handle _ => false;
+
+fun ARB ty = mk_select{Bvar=mk_var{Name="v",Ty=ty},
+                       Body=mk_const{Name="True",Ty=bool}};
+
+end; (* Syntax *)