* http://cs.unibo.it/helm/.
*)
+let _profiler = <:profiler<_profiler>>;;
+
(* $Id: inference.ml 6245 2006-04-05 12:07:51Z tassi $ *)
type rule = SuperpositionRight | SuperpositionLeft | Demodulation
| Exact of Cic.term
| Step of Subst.substitution * (rule * int*(Utils.pos*int)* Cic.term)
(* subst, (rule,eq1, eq2,predicate) *)
-and goal_proof = (Utils.pos * int * Subst.substitution * Cic.term) list
+and goal_proof = (rule * Utils.pos * int * Subst.substitution * Cic.term) list
;;
+type goal = goal_proof * Cic.metasenv * Cic.term
+
(* globals *)
let maxid = ref 0;;
let id_to_eq = Hashtbl.create 1024;;
let id = freshid () in
let eq = (uncomparable,weight,p,(ty,l,r,o),m,id) in
Hashtbl.add id_to_eq id eq;
+
eq
;;
let open_equality (_,weight,proof,(ty,l,r,o),m,id) =
(weight,proof,(ty,l,r,o),m,id)
+let string_of_rule = function
+ | SuperpositionRight -> "SupR"
+ | SuperpositionLeft -> "SupL"
+ | Demodulation -> "Demod"
+;;
+
let string_of_equality ?env eq =
match env with
| None ->
id w (CicPp.ppterm ty)
(CicPp.ppterm left)
(Utils.string_of_comparison o) (CicPp.ppterm right)
- (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
+ (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
| Some (_, context, _) ->
let names = Utils.names_of_context context in
let w, _, (ty, left, right, o), m , id = open_equality eq in
id w (CicPp.pp ty names)
(CicPp.pp left names) (Utils.string_of_comparison o)
(CicPp.pp right names)
- (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
+ (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
;;
let compare (_,_,_,s1,_,_) (_,_,_,s2,_,_) =
Pervasives.compare s1 s2
;;
+let rec max_weight_in_proof current =
+ function
+ | Exact _ -> current
+ | Step (_, (_,id1,(_,id2),_)) ->
+ let eq1 = Hashtbl.find id_to_eq id1 in
+ let eq2 = Hashtbl.find id_to_eq id2 in
+ let (w1,p1,(_,_,_,_),_,_) = open_equality eq1 in
+ let (w2,p2,(_,_,_,_),_,_) = open_equality eq2 in
+ let current = max current w1 in
+ let current = max_weight_in_proof current p1 in
+ let current = max current w2 in
+ max_weight_in_proof current p2
+
+let max_weight_in_goal_proof =
+ List.fold_left
+ (fun current (_,_,id,_,_) ->
+ let eq = Hashtbl.find id_to_eq id in
+ let (w,p,(_,_,_,_),_,_) = open_equality eq in
+ let current = max current w in
+ max_weight_in_proof current p)
+
+let max_weight goal_proof proof =
+ let current = max_weight_in_proof 0 proof in
+ max_weight_in_goal_proof current goal_proof
+
let proof_of_id id =
try
let (_,p,(_,l,r,_),_,_) = open_equality (Hashtbl.find id_to_eq id) in
let string_of_proof ?(names=[]) p gp =
- let str_of_rule = function
- | SuperpositionRight -> "SupR"
- | SuperpositionLeft -> "SupL"
- | Demodulation -> "Demod"
- in
let str_of_pos = function
| Utils.Left -> "left"
| Utils.Right -> "right"
prefix (CicPp.pp t names)
| Step (subst,(rule,eq1,(pos,eq2),pred)) ->
Printf.sprintf "%s%s(%s|%d with %d dir %s pred %s))\n"
- prefix (str_of_rule rule) (Subst.ppsubst ~names subst) eq1 eq2 (str_of_pos pos)
+ prefix (string_of_rule rule) (Subst.ppsubst ~names subst) eq1 eq2 (str_of_pos pos)
(CicPp.pp pred names)^
aux (margin+1) (Printf.sprintf "%d" eq1) (fst3 (proof_of_id eq1)) ^
aux (margin+1) (Printf.sprintf "%d" eq2) (fst3 (proof_of_id eq2))
aux 0 "" p ^
String.concat "\n"
(List.map
- (fun (pos,i,s,t) ->
+ (fun (r,pos,i,s,t) ->
(Printf.sprintf
- "GOAL: %s %d %s %s\n"
+ "GOAL: %s %s %d %s %s\n" (string_of_rule r)
(str_of_pos pos) i (Subst.ppsubst ~names s) (CicPp.pp t names)) ^
aux 1 (Printf.sprintf "%d " i) (fst3 (proof_of_id i)))
gp)
;;
-let rec depend eq id =
+let rec depend eq id seen =
let (_,p,(_,_,_,_),_,ideq) = open_equality eq in
- if id = ideq then true else
- match p with
- Exact _ -> false
- | Step (_,(_,id1,(_,id2),_)) ->
- let eq1 = Hashtbl.find id_to_eq id1 in
- let eq2 = Hashtbl.find id_to_eq id2 in
- depend eq1 id || depend eq2 id
+ if List.mem ideq seen then
+ false,seen
+ else
+ if id = ideq then
+ true,seen
+ else
+ match p with
+ | Exact _ -> false,seen
+ | Step (_,(_,id1,(_,id2),_)) ->
+ let seen = ideq::seen in
+ let eq1 = Hashtbl.find id_to_eq id1 in
+ let eq2 = Hashtbl.find id_to_eq id2 in
+ let b1,seen = depend eq1 id seen in
+ if b1 then b1,seen else depend eq2 id seen
;;
+let depend eq id = fst (depend eq id []);;
+
let ppsubst = Subst.ppsubst ~names:[];;
(* returns an explicit named subst and a list of arguments for sym_eq_URI *)
| _ -> assert false
;;
+let open_sym ens tl =
+ let args = List.map snd ens @ tl in
+ match args with
+ | [ty;l;r;p] -> ty,l,r,p
+ | _ -> assert false
+;;
+
let open_eq_ind args =
match args with
| [ty;l;pred;pl;r;pleqr] -> ty,l,pred,pl,r,pleqr
let open_pred pred =
match pred with
- | Cic.Lambda (_,ty,(Cic.Appl [Cic.MutInd (uri, 0,_);_;l;r]))
+ | Cic.Lambda (_,_,(Cic.Appl [Cic.MutInd (uri, 0,_);ty;l;r]))
when LibraryObjects.is_eq_URI uri -> ty,uri,l,r
| _ -> prerr_endline (CicPp.ppterm pred); assert false
;;
CicSubstitution.subst (Cic.Rel 1) t
;;
+let head_of_apply = function | Cic.Appl (hd::_) -> hd | t -> t;;
+let tail_of_apply = function | Cic.Appl (_::tl) -> tl | t -> [];;
+let count_args t = List.length (tail_of_apply t);;
+let rec build_nat =
+ let u = UriManager.uri_of_string "cic:/matita/nat/nat/nat.ind" in
+ function
+ | 0 -> Cic.MutConstruct(u,0,1,[])
+ | n ->
+ Cic.Appl [Cic.MutConstruct(u,0,2,[]);build_nat (n-1)]
+;;
+let tyof context menv t =
+ try
+ fst(CicTypeChecker.type_of_aux' menv context t CicUniv.empty_ugraph)
+ with
+ | CicTypeChecker.TypeCheckerFailure _
+ | CicTypeChecker.AssertFailure _ -> assert false
+;;
+let rec lambdaof left context = function
+ | Cic.Prod (n,s,t) ->
+ Cic.Lambda (n,s,lambdaof left context t)
+ | Cic.Appl [Cic.MutInd (uri, 0,_);ty;l;r]
+ when LibraryObjects.is_eq_URI uri -> if left then l else r
+ | t ->
+ let names = Utils.names_of_context context in
+ prerr_endline ("lambdaof: " ^ (CicPp.pp t names));
+ assert false
+;;
-let canonical t =
+let canonical t context menv =
let rec remove_refl t =
match t with
| Cic.Appl (((Cic.Const(uri_trans,ens))::tl) as args)
Cic.LetIn (name,remove_refl bo,remove_refl rest)
| _ -> t
in
- let rec canonical t =
+ let rec canonical context t =
match t with
- | Cic.LetIn(name,bo,rest) -> Cic.LetIn(name,canonical bo,canonical rest)
+ | Cic.LetIn(name,bo,rest) ->
+ let context' = (Some (name,Cic.Def (bo,None)))::context in
+ Cic.LetIn(name,canonical context bo,canonical context' rest)
| Cic.Appl (((Cic.Const(uri_sym,ens))::tl) as args)
when LibraryObjects.is_sym_eq_URI uri_sym ->
(match p_of_sym ens tl with
| Cic.Appl ((Cic.Const(uri,ens))::tl)
when LibraryObjects.is_sym_eq_URI uri ->
- canonical (p_of_sym ens tl)
+ canonical context (p_of_sym ens tl)
| Cic.Appl ((Cic.Const(uri_trans,ens))::tl)
when LibraryObjects.is_trans_eq_URI uri_trans ->
let ty,l,m,r,p1,p2 = open_trans ens tl in
mk_trans uri_trans ty r m l
- (canonical (mk_sym uri_sym ty m r p2))
- (canonical (mk_sym uri_sym ty l m p1))
+ (canonical context (mk_sym uri_sym ty m r p2))
+ (canonical context (mk_sym uri_sym ty l m p1))
+ | Cic.Appl (([Cic.Const(uri_feq,ens);ty1;ty2;f;x;y;p])) ->
+
+ let eq_f_sym =
+ Cic.Const (UriManager.uri_of_string
+ "cic:/matita/logic/equality/eq_f1.con",[])
+ in
+ Cic.Appl (([eq_f_sym;ty1;ty2;f;x;y;p]))
+
+(*
+ let sym_eq = Cic.Const(uri_sym,ens) in
+ let eq_f = Cic.Const(uri_feq,[]) in
+ let b = Cic.MutConstruct (UriManager.uri_of_string
+ "cic:/matita/datatypes/bool/bool.ind",0,1,[])
+ in
+ let u = ty1 in
+ let ctx = f in
+ let n = build_nat (count_args p) in
+ let h = head_of_apply p in
+ let predl = lambdaof true context (tyof context menv h) in
+ let predr = lambdaof false context (tyof context menv h) in
+ let args = tail_of_apply p in
+ let appl =
+ Cic.Appl
+ ([Cic.Const(UriManager.uri_of_string
+ "cic:/matita/paramodulation/rewrite.con",[]);
+ eq; sym_eq; eq_f; b; u; ctx; n; predl; predr; h] @
+ args)
+ in
+ appl
+*)
+(*
| Cic.Appl (((Cic.Const(uri_ind,ens)) as he)::tl)
when LibraryObjects.is_eq_ind_URI uri_ind ||
LibraryObjects.is_eq_ind_r_URI uri_ind ->
Cic.Appl
[he;ty;what;pred;
canonical (mk_sym uri_sym ty l r p1);other;canonical p2]
+*)
| Cic.Appl [Cic.MutConstruct (uri, 0, 1,_);_;_] as t
when LibraryObjects.is_eq_URI uri -> t
- | _ -> Cic.Appl (List.map canonical args))
- | Cic.Appl l -> Cic.Appl (List.map canonical l)
+ | _ -> Cic.Appl (List.map (canonical context) args))
+ | Cic.Appl l -> Cic.Appl (List.map (canonical context) l)
| _ -> t
in
- remove_refl (canonical t)
+ remove_refl (canonical context t)
;;
let ty_of_lambda = function
let compose_contexts ctx1 ctx2 =
ProofEngineReduction.replace_lifting
- ~equality:(=) ~what:[Cic.Rel 1] ~with_what:[ctx2] ~where:ctx1
+ ~equality:(=) ~what:[Cic.Implicit(Some `Hole)] ~with_what:[ctx2] ~where:ctx1
;;
let put_in_ctx ctx t =
ProofEngineReduction.replace_lifting
- ~equality:(=) ~what:[Cic.Rel 1] ~with_what:[t] ~where:ctx
+ ~equality:(=) ~what:[Cic.Implicit (Some `Hole)] ~with_what:[t] ~where:ctx
;;
let mk_eq uri ty l r =
| _ -> assert false
;;
+let mk_feq uri_feq ty ty1 left pred right t =
+ Cic.Appl [Cic.Const(uri_feq,[]);ty;ty1;pred;left;right;t]
+;;
+
let contextualize uri ty left right t =
+ let hole = Cic.Implicit (Some `Hole) in
(* aux [uri] [ty] [left] [right] [ctx] [t]
*
* the parameters validate this invariant
* t: eq(uri) ty left right
* that is used only by the base case
*
- * ctx is a term with an open (Rel 1). (Rel 1) is the empty context
+ * ctx is a term with an hole. Cic.Implicit(Some `Hole) is the empty context
+ * ty_ctx is the type of ctx_d
*)
- let rec aux uri ty left right ctx_d = function
+ let rec aux uri ty left right ctx_d ctx_ty = function
+ | Cic.Appl ((Cic.Const(uri_sym,ens))::tl)
+ when LibraryObjects.is_sym_eq_URI uri_sym ->
+ let ty,l,r,p = open_sym ens tl in
+ mk_sym uri_sym ty l r (aux uri ty l r ctx_d ctx_ty p)
| Cic.LetIn (name,body,rest) ->
(* we should go in body *)
- Cic.LetIn (name,body,aux uri ty left right ctx_d rest)
+ Cic.LetIn (name,body,aux uri ty left right ctx_d ctx_ty rest)
| Cic.Appl ((Cic.Const(uri_ind,ens))::tl)
when LibraryObjects.is_eq_ind_URI uri_ind ||
LibraryObjects.is_eq_ind_r_URI uri_ind ->
let is_not_fixed_lp = is_not_fixed lp in
let avoid_eq_ind = LibraryObjects.is_eq_ind_URI uri_ind in
(* extract the context and the fixed term from the predicate *)
- let m, ctx_c =
+ let m, ctx_c, ty2 =
let m, ctx_c = if is_not_fixed_lp then rp,lp else lp,rp in
(* they were under a lambda *)
- let m = CicSubstitution.subst (Cic.Implicit None) m in
- let ctx_c = CicSubstitution.subst (Cic.Rel 1) ctx_c in
- m, ctx_c
+ let m = CicSubstitution.subst hole m in
+ let ctx_c = CicSubstitution.subst hole ctx_c in
+ let ty2 = CicSubstitution.subst hole ty2 in
+ m, ctx_c, ty2
in
(* create the compound context and put the terms under it *)
let ctx_dc = compose_contexts ctx_d ctx_c in
(* now put the proofs in the compound context *)
let p1 = (* p1: dc_what = d_m *)
if is_not_fixed_lp then
- aux uri ty1 c_what m ctx_d p1
+ aux uri ty2 c_what m ctx_d ctx_ty p1
else
- mk_sym uri_sym ty d_m dc_what
- (aux uri ty1 m c_what ctx_d p1)
+ mk_sym uri_sym ctx_ty d_m dc_what
+ (aux uri ty2 m c_what ctx_d ctx_ty p1)
in
let p2 = (* p2: dc_other = dc_what *)
if avoid_eq_ind then
- mk_sym uri_sym ty dc_what dc_other
- (aux uri ty1 what other ctx_dc p2)
+ mk_sym uri_sym ctx_ty dc_what dc_other
+ (aux uri ty1 what other ctx_dc ctx_ty p2)
else
- aux uri ty1 other what ctx_dc p2
+ aux uri ty1 other what ctx_dc ctx_ty p2
in
(* if pred = \x.C[x]=m --> t : C[other]=m --> trans other what m
if pred = \x.m=C[x] --> t : m=C[other] --> trans m what other *)
dc_other,dc_what,d_m,p2,p1
else
d_m,dc_what,dc_other,
- (mk_sym uri_sym ty dc_what d_m p1),
- (mk_sym uri_sym ty dc_other dc_what p2)
+ (mk_sym uri_sym ctx_ty dc_what d_m p1),
+ (mk_sym uri_sym ctx_ty dc_other dc_what p2)
in
- mk_trans uri_trans ty a b c paeqb pbeqc
+ mk_trans uri_trans ctx_ty a b c paeqb pbeqc
+ | t when ctx_d = hole -> t
| t ->
- let uri_sym = LibraryObjects.sym_eq_URI ~eq:uri in
- let uri_ind = LibraryObjects.eq_ind_URI ~eq:uri in
+(* let uri_sym = LibraryObjects.sym_eq_URI ~eq:uri in *)
+(* let uri_ind = LibraryObjects.eq_ind_URI ~eq:uri in *)
+ let uri_feq =
+ UriManager.uri_of_string "cic:/matita/logic/equality/eq_f.con"
+ in
let pred =
- (* ctx_d will go under a lambda, but put_in_ctx substitutes Rel 1 *)
- let ctx_d = CicSubstitution.lift_from 2 1 ctx_d in (* bleah *)
- let r = put_in_ctx ctx_d (CicSubstitution.lift 1 left) in
- let l = ctx_d in
- let lty = CicSubstitution.lift 1 ty in
- Cic.Lambda (Cic.Name "foo",ty,(mk_eq uri lty l r))
+(* let r = CicSubstitution.lift 1 (put_in_ctx ctx_d left) in *)
+ let l =
+ let ctx_d = CicSubstitution.lift 1 ctx_d in
+ put_in_ctx ctx_d (Cic.Rel 1)
+ in
+(* let lty = CicSubstitution.lift 1 ctx_ty in *)
+(* Cic.Lambda (Cic.Name "foo",ty,(mk_eq uri lty l r)) *)
+ Cic.Lambda (Cic.Name "foo",ty,l)
in
- let d_left = put_in_ctx ctx_d left in
- let d_right = put_in_ctx ctx_d right in
- let refl_eq = mk_refl uri ty d_left in
- mk_sym uri_sym ty d_right d_left
- (mk_eq_ind uri_ind ty left pred refl_eq right t)
+(* let d_left = put_in_ctx ctx_d left in *)
+(* let d_right = put_in_ctx ctx_d right in *)
+(* let refl_eq = mk_refl uri ctx_ty d_left in *)
+(* mk_sym uri_sym ctx_ty d_right d_left *)
+(* (mk_eq_ind uri_ind ty left pred refl_eq right t) *)
+ (mk_feq uri_feq ty ctx_ty left pred right t)
in
- let empty_context = Cic.Rel 1 in
- aux uri ty left right empty_context t
+ aux uri ty left right hole ty t
;;
let contextualize_rewrites t ty =
let eq,ty,l,r = open_eq ty in
contextualize eq ty l r t
;;
-
-let build_proof_step lift subst p1 p2 pos l r pred =
+
+let add_subst subst =
+ function
+ | Exact t -> Exact (Subst.apply_subst subst t)
+ | Step (s,(rule, id1, (pos,id2), pred)) ->
+ Step (Subst.concat subst s,(rule, id1, (pos,id2), pred))
+;;
+
+let build_proof_step eq lift subst p1 p2 pos l r pred =
let p1 = Subst.apply_subst_lift lift subst p1 in
let p2 = Subst.apply_subst_lift lift subst p2 in
let l = CicSubstitution.lift lift l in
let what, other =
if pos = Utils.Left then l,r else r,l
in
+ let p =
match pos with
| Utils.Left ->
- mk_eq_ind (Utils.eq_ind_URI ()) ty what pred p1 other p2
+ mk_eq_ind (LibraryObjects.eq_ind_URI ~eq) ty what pred p1 other p2
| Utils.Right ->
- mk_eq_ind (Utils.eq_ind_r_URI ()) ty what pred p1 other p2
+ mk_eq_ind (LibraryObjects.eq_ind_r_URI ~eq) ty what pred p1 other p2
+ in
+ p
;;
let parametrize_proof p l r ty =
- let parameters = CicUtil.metas_of_term p
-@ CicUtil.metas_of_term l
-@ CicUtil.metas_of_term r
-in (* ?if they are under a lambda? *)
+ let uniq l = HExtlib.list_uniq (List.sort Pervasives.compare l) in
+ let mot = CicUtil.metas_of_term_set in
+ let parameters = uniq (mot p @ mot l @ mot r) in
+ (* ?if they are under a lambda? *)
let parameters =
HExtlib.list_uniq (List.sort Pervasives.compare parameters)
in
let p = CicSubstitution.lift (lift_no-1) p in
let p =
ProofEngineReduction.replace_lifting
- ~equality:(fun t1 t2 -> match t1,t2 with Cic.Meta (i,_),Cic.Meta(j,_) -> i=j | _ -> false) ~what ~with_what ~where:p
+ ~equality:(fun t1 t2 ->
+ match t1,t2 with Cic.Meta (i,_),Cic.Meta(j,_) -> i=j | _ -> false)
+ ~what ~with_what ~where:p
in
let ty_of_m _ = ty (*function
| Cic.Meta (i,_) -> List.assoc i menv
proof, instance
;;
-let wfo goalproof proof =
+let wfo goalproof proof id =
let rec aux acc id =
let p,_,_ = proof_of_id id in
match p with
in
let acc =
match proof with
- | Exact _ -> []
- | Step (_,(_,id1, (_,id2), _)) -> aux (aux [] id1) id2
+ | Exact _ -> [id]
+ | Step (_,(_,id1, (_,id2), _)) -> aux (aux [id] id1) id2
in
- List.fold_left (fun acc (_,id,_,_) -> aux acc id) acc goalproof
+ List.fold_left (fun acc (_,_,id,_,_) -> aux acc id) acc goalproof
;;
let string_of_id names id =
+ if id = 0 then "" else
try
let (_,p,(_,l,r,_),m,_) = open_equality (Hashtbl.find id_to_eq id) in
match p with
| Exact t ->
Printf.sprintf "%d = %s: %s = %s [%s]" id
(CicPp.pp t names) (CicPp.pp l names) (CicPp.pp r names)
- (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
+ (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
| Step (_,(step,id1, (_,id2), _) ) ->
Printf.sprintf "%6d: %s %6d %6d %s = %s [%s]" id
- (if step = SuperpositionRight then "SupR" else "Demo")
+ (string_of_rule step)
id1 id2 (CicPp.pp l names) (CicPp.pp r names)
- (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
+ (String.concat ", " (List.map (fun (i,_,_) -> string_of_int i) m))
with
Not_found -> assert false
-let pp_proof names goalproof proof =
- String.concat "\n" (List.map (string_of_id names) (wfo goalproof proof)) ^
- "\ngoal is demodulated with " ^
- (String.concat " "
- ((List.map (fun (_,i,_,_) -> string_of_int i) goalproof)))
+let pp_proof names goalproof proof subst id initial_goal =
+ String.concat "\n" (List.map (string_of_id names) (wfo goalproof proof id)) ^
+ "\ngoal:\n " ^
+ (String.concat "\n "
+ (fst (List.fold_right
+ (fun (r,pos,i,s,pred) (acc,g) ->
+ let _,_,left,right = open_eq g in
+ let ty =
+ match pos with
+ | Utils.Left -> CicReduction.head_beta_reduce (Cic.Appl[pred;right])
+ | Utils.Right -> CicReduction.head_beta_reduce (Cic.Appl[pred;left])
+ in
+ let ty = Subst.apply_subst s ty in
+ ("("^ string_of_rule r ^ " " ^ string_of_int i^") -> "
+ ^ CicPp.pp ty names) :: acc,ty) goalproof ([],initial_goal)))) ^
+ "\nand then subsumed by " ^ string_of_int id ^ " when " ^ Subst.ppsubst subst
+;;
+
+module OT =
+ struct
+ type t = int
+ let compare = Pervasives.compare
+ end
+
+module M = Map.Make(OT)
+
+let rec find_deps m i =
+ if M.mem i m then m
+ else
+ let p,_,_ = proof_of_id i in
+ match p with
+ | Exact _ -> M.add i [] m
+ | Step (_,(_,id1,(_,id2),_)) ->
+ let m = find_deps m id1 in
+ let m = find_deps m id2 in
+ (* without the uniq there is a stack overflow doing concatenation *)
+ let xxx = [id1;id2] @ M.find id1 m @ M.find id2 m in
+ let xxx = HExtlib.list_uniq (List.sort Pervasives.compare xxx) in
+ M.add i xxx m
;;
+let topological_sort l =
+ (* build the partial order relation *)
+ let m = List.fold_left (fun m i -> find_deps m i) M.empty l in
+ let m = (* keep only deps inside l *)
+ List.fold_left
+ (fun m' i ->
+ M.add i (List.filter (fun x -> List.mem x l) (M.find i m)) m')
+ M.empty l
+ in
+ let m = M.map (fun x -> Some x) m in
+ (* utils *)
+ let keys m = M.fold (fun i _ acc -> i::acc) m [] in
+ let split l m = List.filter (fun i -> M.find i m = Some []) l in
+ let purge l m =
+ M.mapi
+ (fun k v -> if List.mem k l then None else
+ match v with
+ | None -> None
+ | Some ll -> Some (List.filter (fun i -> not (List.mem i l)) ll))
+ m
+ in
+ let rec aux m res =
+ let keys = keys m in
+ let ok = split keys m in
+ let m = purge ok m in
+ let res = ok @ res in
+ if ok = [] then res else aux m res
+ in
+ let rc = List.rev (aux m []) in
+ rc
+;;
+
+
(* returns the list of ids that should be factorized *)
let get_duplicate_step_in_wfo l p =
let ol = List.rev l in
(* NOTE: here the n parameter is an approximation of the dependency
between equations. To do things seriously we should maintain a
dependency graph. This approximation is not perfect. *)
- let add i n =
+ let add i =
let p,_,_ = proof_of_id i in
match p with
| Exact _ -> true
| _ ->
- try let (pos,no) = Hashtbl.find h i in Hashtbl.replace h i (pos,no+1);false
- with Not_found -> Hashtbl.add h i (n,1);true
+ try
+ let no = Hashtbl.find h i in
+ Hashtbl.replace h i (no+1);
+ false
+ with Not_found -> Hashtbl.add h i 1;true
in
- let rec aux n = function
- | Exact _ -> n
+ let rec aux = function
+ | Exact _ -> ()
| Step (_,(_,i1,(_,i2),_)) ->
- let go_on_1 = add i1 n in
- let go_on_2 = add i2 n in
- max
- (if go_on_1 then aux (n+1) (let p,_,_ = proof_of_id i1 in p) else n+1)
- (if go_on_2 then aux (n+1) (let p,_,_ = proof_of_id i2 in p) else n+1)
- in
- let i = aux 0 p in
- let _ =
- List.fold_left
- (fun acc (_,id,_,_) -> aux acc (let p,_,_ = proof_of_id id in p))
- i ol
+ let go_on_1 = add i1 in
+ let go_on_2 = add i2 in
+ if go_on_1 then aux (let p,_,_ = proof_of_id i1 in p);
+ if go_on_2 then aux (let p,_,_ = proof_of_id i2 in p)
in
+ aux p;
+ List.iter
+ (fun (_,_,id,_,_) -> aux (let p,_,_ = proof_of_id id in p))
+ ol;
(* now h is complete *)
- let proofs = Hashtbl.fold (fun k (pos,count) acc->(k,pos,count)::acc) h [] in
- let proofs = List.filter (fun (_,_,c) -> c > 1) proofs in
- let proofs =
- List.sort (fun (_,c1,_) (_,c2,_) -> Pervasives.compare c2 c1) proofs
- in
- List.map (fun (i,_,_) -> i) proofs
+ let proofs = Hashtbl.fold (fun k count acc-> (k,count)::acc) h [] in
+ let proofs = List.filter (fun (_,c) -> c > 1) proofs in
+ let res = topological_sort (List.map (fun (i,_) -> i) proofs) in
+ res
;;
-let build_proof_term h lift proof =
+let build_proof_term eq h lift proof =
let proof_of_id aux id =
let p,l,r = proof_of_id id in
try List.assoc id h,l,r with Not_found -> aux p, l, r
in
let rec aux = function
- | Exact term -> CicSubstitution.lift lift term
- | Step (subst,(_, id1, (pos,id2), pred)) ->
- if Subst.is_in_subst 302 subst then
- prerr_endline ("TROVATA in " ^ string_of_int id1 ^ " " ^ string_of_int id2);
-
+ | Exact term ->
+ CicSubstitution.lift lift term
+ | Step (subst,(rule, id1, (pos,id2), pred)) ->
let p1,_,_ = proof_of_id aux id1 in
let p2,l,r = proof_of_id aux id2 in
- let p = build_proof_step lift subst p1 p2 pos l r pred in
-(* let cond = (not (List.mem 302 (Utils.metas_of_term p)) || id1 = 8 || id1 = 132) in
- if not cond then
- prerr_endline ("ERROR " ^ string_of_int id1 ^ " " ^ string_of_int id2);
- assert cond;*)
- p
+ let varname =
+ match rule with
+ | SuperpositionRight -> Cic.Name ("SupR" ^ Utils.string_of_pos pos)
+ | Demodulation -> Cic.Name ("DemEq"^ Utils.string_of_pos pos)
+ | _ -> assert false
+ in
+ let pred =
+ match pred with
+ | Cic.Lambda (_,a,b) -> Cic.Lambda (varname,a,b)
+ | _ -> assert false
+ in
+ let p = build_proof_step eq lift subst p1 p2 pos l r pred in
+(* let cond = (not (List.mem 302 (Utils.metas_of_term p)) || id1 = 8 || id1 = 132) in
+ if not cond then
+ prerr_endline ("ERROR " ^ string_of_int id1 ^ " " ^ string_of_int id2);
+ assert cond;*)
+ p
in
aux proof
;;
-let build_goal_proof l initial ty se =
+let build_goal_proof eq l initial ty se context menv =
let se = List.map (fun i -> Cic.Meta (i,[])) se in
let lets = get_duplicate_step_in_wfo l initial in
let letsno = List.length lets in
let _,mty,_,_ = open_eq ty in
- let lift_list l = List.map (fun (i,t) -> i,CicSubstitution.lift 1 t) l
- in
+ let lift_list l = List.map (fun (i,t) -> i,CicSubstitution.lift 1 t) l in
let lets,_,h =
List.fold_left
(fun (acc,n,h) id ->
let p,l,r = proof_of_id id in
- let cic = build_proof_term h n p in
+ let cic = build_proof_term eq h n p in
let real_cic,instance =
parametrize_proof cic l r (CicSubstitution.lift n mty)
in
let proof,se =
let rec aux se current_proof = function
| [] -> current_proof,se
- | (pos,id,subst,pred)::tl ->
- if Subst.is_in_subst 302 subst then
- prerr_endline ("TROVATA in " ^ string_of_int id );
-
+ | (rule,pos,id,subst,pred)::tl ->
let p,l,r = proof_of_id id in
- let p = build_proof_term h letsno p in
+ let p = build_proof_term eq h letsno p in
let pos = if pos = Utils.Left then Utils.Right else Utils.Left in
+ let varname =
+ match rule with
+ | SuperpositionLeft -> Cic.Name ("SupL" ^ Utils.string_of_pos pos)
+ | Demodulation -> Cic.Name ("DemG"^ Utils.string_of_pos pos)
+ | _ -> assert false
+ in
+ let pred =
+ match pred with
+ | Cic.Lambda (_,a,b) -> Cic.Lambda (varname,a,b)
+ | _ -> assert false
+ in
let proof =
- build_proof_step letsno subst current_proof p pos l r pred
+ build_proof_step eq letsno subst current_proof p pos l r pred
in
let proof,se = aux se proof tl in
Subst.apply_subst_lift letsno subst proof,
List.map (fun x -> Subst.apply_subst_lift letsno subst x) se
in
- aux se (build_proof_term h letsno initial) l
+ aux se (build_proof_term eq h letsno initial) l
in
let n,proof =
let initial = proof in
cic, p))
lets (letsno-1,initial)
in
- (*canonical (contextualize_rewrites proof (CicSubstitution.lift letsno ty))*)proof, se
+ canonical
+ (contextualize_rewrites proof (CicSubstitution.lift letsno ty))
+ context menv,
+ se
;;
-let refl_proof ty term =
- Cic.Appl
- [Cic.MutConstruct
- (LibraryObjects.eq_URI (), 0, 1, []);
- ty; term]
+let refl_proof eq_uri ty term =
+ Cic.Appl [Cic.MutConstruct (eq_uri, 0, 1, []); ty; term]
;;
let metas_of_proof p =
- let p = build_proof_term [] 0 p in
+ let eq =
+ match LibraryObjects.eq_URI () with
+ | Some u -> u
+ | None ->
+ raise
+ (ProofEngineTypes.Fail
+ (lazy "No default equality defined when calling metas_of_proof"))
+ in
+ let p = build_proof_term eq [] 0 p in
Utils.metas_of_term p
;;
+let remove_local_context eq =
+ let w, p, (ty, left, right, o), menv,id = open_equality eq in
+ let p = Utils.remove_local_context p in
+ let ty = Utils.remove_local_context ty in
+ let left = Utils.remove_local_context left in
+ let right = Utils.remove_local_context right in
+ w, p, (ty, left, right, o), menv, id
+;;
+
let relocate newmeta menv to_be_relocated =
let subst, newmetasenv, newmeta =
List.fold_right
let menv = Subst.apply_subst_metasenv subst menv @ newmetasenv in
subst, menv, newmeta
+let fix_metas_goal newmeta goal =
+ let (proof, menv, ty) = goal in
+ let to_be_relocated =
+ HExtlib.list_uniq (List.sort Pervasives.compare (Utils.metas_of_term ty))
+ in
+ let subst, menv, newmeta = relocate newmeta menv to_be_relocated in
+ let ty = Subst.apply_subst subst ty in
+ let proof =
+ match proof with
+ | [] -> assert false (* is a nonsense to relocate the initial goal *)
+ | (r,pos,id,s,p) :: tl -> (r,pos,id,Subst.concat subst s,p) :: tl
+ in
+ newmeta+1,(proof, menv, ty)
+;;
let fix_metas newmeta eq =
let w, p, (ty, left, right, o), menv,_ = open_equality eq in
let to_be_relocated =
+(* List.map (fun i ,_,_ -> i) menv *)
HExtlib.list_uniq
(List.sort Pervasives.compare
- (Utils.metas_of_term left @ Utils.metas_of_term right))
+ (Utils.metas_of_term left @ Utils.metas_of_term right))
in
let subst, metasenv, newmeta = relocate newmeta menv to_be_relocated in
let ty = Subst.apply_subst subst ty in
let rec aux ((table_l, table_r) as table) t1 t2 =
match t1, t2 with
| C.Meta (m1, tl1), C.Meta (m2, tl2) ->
+ let tl1, tl2 = [],[] in
let m1_binding, table_l =
try List.assoc m1 table_l, table_l
with Not_found -> m2, (m1, m2)::table_l
exception TermIsNotAnEquality;;
let term_is_equality term =
- let iseq uri = UriManager.eq uri (LibraryObjects.eq_URI ()) in
match term with
- | Cic.Appl [Cic.MutInd (uri, _, _); _; _; _] when iseq uri -> true
+ | Cic.Appl [Cic.MutInd (uri, _, _); _; _; _]
+ when LibraryObjects.is_eq_URI uri -> true
| _ -> false
;;
let equality_of_term proof term =
- let eq_uri = LibraryObjects.eq_URI () in
- let iseq uri = UriManager.eq uri eq_uri in
match term with
- | Cic.Appl [Cic.MutInd (uri, _, _); ty; t1; t2] when iseq uri ->
+ | Cic.Appl [Cic.MutInd (uri, _, _); ty; t1; t2]
+ when LibraryObjects.is_eq_URI uri ->
let o = !Utils.compare_terms t1 t2 in
let stat = (ty,t1,t2,o) in
let w = Utils.compute_equality_weight stat in
;;
-let term_of_equality equality =
+let term_of_equality eq_uri equality =
let _, _, (ty, left, right, _), menv, _= open_equality equality in
let eq i = function Cic.Meta (j, _) -> i = j | _ -> false in
let argsno = List.length menv in
let t =
CicSubstitution.lift argsno
- (Cic.Appl [Cic.MutInd (LibraryObjects.eq_URI (), 0, []); ty; left; right])
+ (Cic.Appl [Cic.MutInd (eq_uri, 0, []); ty; left; right])
in
snd (
List.fold_right
menv (argsno, t))
;;
+let symmetric eq_ty l id uri m =
+ let eq = Cic.MutInd(uri,0,[]) in
+ let pred =
+ Cic.Lambda (Cic.Name "Sym",eq_ty,
+ Cic.Appl [CicSubstitution.lift 1 eq ;
+ CicSubstitution.lift 1 eq_ty;
+ Cic.Rel 1;CicSubstitution.lift 1 l])
+ in
+ let prefl =
+ Exact (Cic.Appl
+ [Cic.MutConstruct(uri,0,1,[]);eq_ty;l])
+ in
+ let id1 =
+ let eq = mk_equality (0,prefl,(eq_ty,l,l,Utils.Eq),m) in
+ let (_,_,_,_,id) = open_equality eq in
+ id
+ in
+ Step(Subst.empty_subst,
+ (Demodulation,id1,(Utils.Left,id),pred))
+;;
+
+module IntOT = struct
+ type t = int
+ let compare = Pervasives.compare
+end
+
+module IntSet = Set.Make(IntOT);;
+
+let n_purged = ref 0;;
+
+let collect alive1 alive2 alive3 =
+ let _ = <:start<collect>> in
+ let deps_of id =
+ let p,_,_ = proof_of_id id in
+ match p with
+ | Exact _ -> IntSet.empty
+ | Step (_,(_,id1,(_,id2),_)) ->
+ IntSet.add id1 (IntSet.add id2 IntSet.empty)
+ in
+ let rec close s =
+ let news = IntSet.fold (fun id s -> IntSet.union (deps_of id) s) s s in
+ if IntSet.equal news s then s else close news
+ in
+ let l_to_s s l = List.fold_left (fun s x -> IntSet.add x s) s l in
+ let alive_set = l_to_s (l_to_s (l_to_s IntSet.empty alive2) alive1) alive3 in
+ let closed_alive_set = close alive_set in
+ let to_purge =
+ Hashtbl.fold
+ (fun k _ s ->
+ if not (IntSet.mem k closed_alive_set) then
+ k::s else s) id_to_eq []
+ in
+ n_purged := !n_purged + List.length to_purge;
+ List.iter (Hashtbl.remove id_to_eq) to_purge;
+ let _ = <:stop<collect>> in ()
+;;
+
+let id_of e =
+ let _,_,_,_,id = open_equality e in id
+;;
+
+let get_stats () =
+ <:show<Equality.>> ^
+ "# of purged eq by the collector: " ^ string_of_int !n_purged ^ "\n"
+;;