Step (Subst.concat subst s,(rule, id1, (pos,id2), pred))
;;
-let build_proof_step ?(sym=false) lift subst p1 p2 pos l r 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 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
- if sym then
- let uri,pl,pr =
- let eq,_,pl,pr = open_eq body in
- LibraryObjects.sym_eq_URI ~eq, pl, pr
- in
- let l = CicSubstitution.subst other pl in
- let r = CicSubstitution.subst other pr in
- mk_sym uri ty l r p
- else
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 parameters =
+ CicUtil.metas_of_term p @ CicUtil.metas_of_term l @ CicUtil.metas_of_term r
+ in (* ?if they are under a lambda? *)
let parameters =
HExtlib.list_uniq (List.sort Pervasives.compare parameters)
in
| Step (_,(_,id1,(_,id2),_)) ->
let m = find_deps m id1 in
let m = find_deps m id2 in
- M.add i (M.find id1 m @ M.find id2 m @ [id1;id2]) m
+ (* 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 =
| Some ll -> Some (List.filter (fun i -> not (List.mem i l)) ll))
m
in
- let rec aux m =
+ let rec aux m res =
let keys = keys m in
let ok = split keys m in
let m = purge ok m in
- ok @ (if ok = [] then [] else aux m)
+ let res = ok @ res in
+ if ok = [] then res else aux m res
in
- aux m
+ aux m []
;;
(* now h is complete *)
let proofs = Hashtbl.fold (fun k count acc-> (k,count)::acc) h [] in
let proofs = List.filter (fun (_,c) -> c > 1) proofs in
- topological_sort (List.map (fun (i,_) -> i) proofs)
+ 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
| Cic.Lambda (_,a,b) -> Cic.Lambda (varname,a,b)
| _ -> assert false
in
- let p = build_proof_step lift subst p1 p2 pos l r pred 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);
aux proof
;;
-let build_goal_proof l initial ty se =
+let build_goal_proof eq l initial ty se =
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
| [] -> current_proof,se
| (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
| _ -> 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
se
;;
-let refl_proof ty term =
- Cic.Appl
- [Cic.MutConstruct
- (Utils.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
;;
exception TermIsNotAnEquality;;
let term_is_equality term =
- let iseq uri = UriManager.eq uri (Utils.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 = Utils.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 (Utils.eq_URI (), 0, []); ty; left; right])
+ (Cic.Appl [Cic.MutInd (eq_uri, 0, []); ty; left; right])
in
snd (
List.fold_right
let string_of_res ?env =
function
None -> "None"
- | Some (t, s, m, u, ((p,e), eq_URI)) ->
+ | Some (t, s, m, u, (p,e)) ->
Printf.sprintf "Some: (%s, %s, %s)"
(Utils.string_of_pos p)
(Equality.string_of_equality ?env e)
let check_res res msg =
match res with
- Some (t, subst, menv, ug, (eq_found, eq_URI)) ->
+ Some (t, subst, menv, ug, eq_found) ->
let eqs = Equality.string_of_equality (snd eq_found) in
check_disjoint_invariant subst menv msg;
check_for_duplicates menv (msg ^ "\nchecking " ^ eqs);
~metasenv context termty ty ugraph)) then (
find_matches metasenv context ugraph lift_amount term termty tl
) else
- let do_match c eq_URI =
+ let do_match c =
let subst', metasenv', ugraph' =
Inference.matching
metasenv metas context term (S.lift lift_amount c) ugraph
in
- Some (Cic.Rel (1 + lift_amount), subst', metasenv', ugraph',
- (candidate, eq_URI))
+ Some (Cic.Rel(1+lift_amount),subst',metasenv',ugraph',candidate)
in
- let c, other, eq_URI =
- if pos = Utils.Left then left, right, Utils.eq_ind_URI ()
- else right, left, Utils.eq_ind_r_URI ()
+ let c, other =
+ if pos = Utils.Left then left, right
+ else right, left
in
if o <> U.Incomparable then
let res =
try
- do_match c eq_URI
+ do_match c
with Inference.MatchingFailure ->
find_matches metasenv context ugraph lift_amount term termty tl
in
res
else
let res =
- try do_match c eq_URI
+ try do_match c
with Inference.MatchingFailure -> None
in
if Utils.debug_res then ignore (check_res res "find2");
| candidate::tl ->
let pos, equality = candidate in
let (_,_,(ty,left,right,o),metas,_)=Equality.open_equality equality in
- let do_match c eq_URI =
+ let do_match c =
let subst', metasenv', ugraph' =
unif_fun metasenv metas context term (S.lift lift_amount c) ugraph
in
- (C.Rel (1+lift_amount),subst',metasenv',ugraph',(candidate, eq_URI))
+ (C.Rel (1+lift_amount),subst',metasenv',ugraph',candidate)
in
- let c, other, eq_URI =
- if pos = Utils.Left then left, right, Utils.eq_ind_URI ()
- else right, left, Utils.eq_ind_r_URI ()
+ let c, other =
+ if pos = Utils.Left then left, right
+ else right, left
in
if o <> U.Incomparable then
try
- let res = do_match c eq_URI in
+ let res = do_match c in
res::(find_all_matches ~unif_fun metasenv context ugraph
lift_amount term termty tl)
with
lift_amount term termty tl
else
try
- let res = do_match c eq_URI in
+ let res = do_match c in
match res with
| _, s, _, _, _ ->
let c' = apply_subst s c
in
let rec ok what leftorright = function
| [] -> None
- | (_, subst, menv, ug, ((pos,equation),_))::tl ->
+ | (_, subst, menv, ug, (pos,equation))::tl ->
let _, _, (_, l, r, o), m,_ = Equality.open_equality equation in
try
let other = if pos = Utils.Left then r else l in
exception Foo
(** demodulation, when target is an equality *)
-let rec demodulation_equality ?from newmeta env table sign target =
+let rec demodulation_equality ?from eq_uri newmeta env table sign target =
let module C = Cic in
let module S = CicSubstitution in
let module M = CicMetaSubst in
let metasenv' = (* metasenv @ *) metas in
let maxmeta = ref newmeta in
- let build_newtarget is_left (t, subst, menv, ug, (eq_found, eq_URI)) =
+ let build_newtarget is_left (t, subst, menv, ug, eq_found) =
if Utils.debug_metas then
begin
let name = C.Name "x" in
let bo' =
let l, r = if is_left then t, S.lift 1 right else S.lift 1 left, t in
- C.Appl [C.MutInd (Utils.eq_URI (), 0, []);
- S.lift 1 eq_ty; l; r]
+ C.Appl [C.MutInd (eq_uri, 0, []); S.lift 1 eq_ty; l; r]
in
if sign = Utils.Positive then
(bo, (Equality.Step (subst,(Equality.Demodulation, id,(pos,id'),
(Equality.meta_convertibility_eq target newtarget) then
newmeta, newtarget
else
- demodulation_equality ?from newmeta env table sign newtarget
+ demodulation_equality ?from eq_uri newmeta env table sign newtarget
| None ->
let res = demodulation_aux metasenv' context ugraph table 0 right in
if Utils.debug_res then check_res res "demod result 1";
(Equality.meta_convertibility_eq target newtarget) then
newmeta, newtarget
else
- demodulation_equality ?from newmeta env table sign newtarget
+ demodulation_equality ?from eq_uri newmeta env table sign newtarget
| None ->
newmeta, target
in
index: its updated value is also returned
*)
let superposition_right
- ?(subterms_only=false) newmeta (metasenv, context, ugraph) table target
-=
+ ?(subterms_only=false) eq_uri newmeta (metasenv, context, ugraph) table target=
let module C = Cic in
let module S = CicSubstitution in
let module M = CicMetaSubst in
in
(res left right), (res right left)
in
- let build_new ordering (bo, s, m, ug, (eq_found, eq_URI)) =
+ let build_new ordering (bo, s, m, ug, eq_found) =
if Utils.debug_metas then
ignore (check_target context (snd eq_found) "buildnew1" );
let bo'' =
let l, r =
if ordering = U.Gt then bo, S.lift 1 right else S.lift 1 left, bo in
- C.Appl [C.MutInd (Utils.eq_URI (), 0, []);
- S.lift 1 eq_ty; l; r]
+ C.Appl [C.MutInd (eq_uri, 0, []); S.lift 1 eq_ty; l; r]
in
bo',
Equality.Step
let term, termty, metas = theorem in
let metasenv' = metas in
- let build_newtheorem (t, subst, menv, ug, (eq_found, eq_URI)) =
+ let build_newtheorem (t, subst, menv, ug, eq_found) =
let pos, equality = eq_found in
let (_, proof', (ty, what, other, _), menv',id) =
Equality.open_equality equality in
* expansion builds a new goal *)
let build_newgoal context goal posu rule expansion =
let goalproof,_,_,_,_,_ = open_goal goal in
- let (t,subst,menv,ug,(eq_found,eq_URI)) = fix_expansion goal posu expansion in
+ let (t,subst,menv,ug,eq_found) = fix_expansion goal posu expansion in
let pos, equality = eq_found in
let (_, proof', (ty, what, other, _), menv',id) =
Equality.open_equality equality in
if c = Utils.Incomparable then
let expansionsl, _ = betaexpand_term menv context ugraph table 0 l in
let expansionsr, _ = betaexpand_term menv context ugraph table 0 r in
- prerr_endline "ZZZ";
- prerr_endline (string_of_int (List.length expansionsl));
- prerr_endline (string_of_int (List.length expansionsr));
List.map (build_newgoal context goal Utils.Right Equality.SuperpositionLeft) expansionsl
@
List.map (build_newgoal context goal Utils.Left Equality.SuperpositionLeft) expansionsr
(** inference of new equalities between current and some in active *)
-let infer env current (active_list, active_table) =
+let infer eq_uri env current (active_list, active_table) =
let (_,c,_) = env in
if Utils.debug_metas then
(ignore(Indexing.check_target c current "infer1");
let active_table = Indexing.index active_table copy_of_current in
let _ = <:start<current contro active>> in
let maxm, res =
- Indexing.superposition_right !maxmeta env active_table current
+ Indexing.superposition_right eq_uri !maxmeta env active_table current
in
let _ = <:stop<current contro active>> in
if Utils.debug_metas then
| [] -> []
| equality::tl ->
let maxm, res =
- Indexing.superposition_right ~subterms_only:true !maxmeta env table equality
+ Indexing.superposition_right
+ ~subterms_only:true eq_uri !maxmeta env table equality
in
maxmeta := maxm;
if Utils.debug_metas then
(* buttare via sign *)
(** simplifies current using active and passive *)
-let forward_simplify env (sign,current) ?passive (active_list, active_table) =
+let forward_simplify
+ eq_uri env (sign,current) ?passive (active_list, active_table)
+=
let _, context, _ = env in
let passive_table =
match passive with
in
let demodulate table current =
let newmeta, newcurrent =
- Indexing.demodulation_equality !maxmeta env table sign current in
+ Indexing.demodulation_equality eq_uri !maxmeta env table sign current in
maxmeta := newmeta;
if Equality.is_identity env newcurrent then
None
;;
(** simplifies new using active and passive *)
-let forward_simplify_new env new_pos ?passive active =
+let forward_simplify_new eq_uri env new_pos ?passive active =
if Utils.debug_metas then
begin
let m,c,u = env in
in
let demodulate sign table target =
let newmeta, newtarget =
- Indexing.demodulation_equality !maxmeta env table sign target in
+ Indexing.demodulation_equality eq_uri !maxmeta env table sign target
+ in
maxmeta := newmeta;
newtarget
in
(** simplifies active usign new *)
-let backward_simplify_active env new_pos new_table min_weight active =
+let backward_simplify_active eq_uri env new_pos new_table min_weight active =
let active_list, active_table = active in
let active_list, newa, pruned =
List.fold_right
if ew < min_weight then
equality::res, newn,pruned
else
- match forward_simplify env (Utils.Positive, equality) (new_pos, new_table) with
+ match
+ forward_simplify
+ eq_uri env (Utils.Positive, equality) (new_pos, new_table)
+ with
| None -> res, newn, id::pruned
| Some e ->
if Equality.compare equality e = 0 then
(** simplifies passive using new *)
-let backward_simplify_passive env new_pos new_table min_weight passive =
+let backward_simplify_passive eq_uri env new_pos new_table min_weight passive =
let (pl, ps), passive_table = passive in
let f sign equality (resl, ress, newn) =
let ew, _, _, _ , _ = Equality.open_equality equality in
if ew < min_weight then
equality::resl, ress, newn
else
- match forward_simplify env (sign, equality) (new_pos, new_table) with
+ match
+ forward_simplify eq_uri env (sign, equality) (new_pos, new_table)
+ with
| None -> resl, EqualitySet.remove equality ress, newn
| Some e ->
if equality = e then
;;
-let backward_simplify env new' ?passive active =
+let backward_simplify eq_uri env new' ?passive active =
let new_pos, new_table, min_weight = build_table new' in
(*
List.fold_left
in
*)
let active, newa, pruned =
- backward_simplify_active env new_pos new_table min_weight active in
+ backward_simplify_active eq_uri env new_pos new_table min_weight active
+ in
match passive with
| None ->
active, (make_passive []), newa, None, pruned
active, passive, newa, newp *)
;;
-let close env new' given =
+let close eq_uri env new' given =
let new_pos, new_table, min_weight =
List.fold_left
(fun (l, t, w) e ->
in
List.fold_left
(fun p c ->
- let pos = infer env c (new_pos,new_table) in
+ let pos = infer eq_uri env c (new_pos,new_table) in
pos@p)
[] given
;;
| _ -> false
;;
-let prova env new' active =
+let prova eq_uri env new' active =
let given = List.filter is_commutative_law (fst active) in
let _ =
debug_print
(List.map
(fun e -> Equality.string_of_equality ~env e)
given)))) in
- close env new' given
+ close eq_uri env new' given
;;
(* returns an estimation of how many equalities in passive can be activated
;;
-let rec simpl env e others others_simpl =
+let rec simpl eq_uri env e others others_simpl =
let active = others @ others_simpl in
let tbl =
List.fold_left
(fun t e -> Indexing.index t e)
Indexing.empty active
in
- let res = forward_simplify env (Positive,e) (active, tbl) in
+ let res = forward_simplify eq_uri env (Positive,e) (active, tbl) in
match others with
| hd::tl -> (
match res with
- | None -> simpl env hd tl others_simpl
- | Some e -> simpl env hd tl (e::others_simpl)
+ | None -> simpl eq_uri env hd tl others_simpl
+ | Some e -> simpl eq_uri env hd tl (e::others_simpl)
)
| [] -> (
match res with
)
;;
-let simplify_equalities env equalities =
+let simplify_equalities eq_uri env equalities =
debug_print
(lazy
(Printf.sprintf "equalities:\n%s\n"
| [] -> []
| hd::tl ->
let res =
- List.rev (simpl env hd tl [])
+ List.rev (simpl eq_uri env hd tl [])
in
debug_print
(lazy
*)
match ty with
| Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right]
- when UriManager.eq uri (Utils.eq_URI ()) ->
+ when LibraryObjects.is_eq_URI uri ->
(let goal_equation =
Equality.mk_equality
(0,Equality.Exact (Cic.Implicit None),(eq_ty,left,right,Eq),menv)
| _ -> None
;;
-let counter = ref 0
-
-(** given-clause algorithm with full reduction strategy *)
-let rec given_clause_fullred dbd env goals theorems ~passive active =
- let goals = simplify_goals env goals ~passive active in
- let _,context,_ = env in
- let ok, (goals:
- (Equality.goal_proof * Cic.metasenv * Cic.term) list *
- (Equality.goal_proof * Cic.metasenv * Cic.term) list) = activate_goal
-
- (goals:
- (Equality.goal_proof * Cic.metasenv * Cic.term) list *
- (Equality.goal_proof * Cic.metasenv * Cic.term) list)
- in
-(* let theorems = simplify_theorems env theorems ~passive active in *)
- if ok then
- let names = List.map (HExtlib.map_option (fun (name,_) -> name)) context in
- let _, _, t = List.hd (fst goals) in
- let _ = prerr_endline ("goal activated = " ^ (CicPp.pp t names)) in
-(* let _ = *)
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "\ngoals = \nactive\n%s\npassive\n%s\n" *)
-(* (print_goals (fst goals)) (print_goals (snd goals)))); *)
-(* let current = List.hd (fst goals) in *)
-(* let p, _, t = List.hd (snd current) in *)
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "goal activated:\n%s\n%s\n" *)
-(* (CicPp.ppterm t) (string_of_proof p))); *)
-(* in *)
- let ok, proof =
- (* apply_goal_to_theorems dbd env theorems ~passive active goals in *)
- let iseq uri = UriManager.eq uri (Utils.eq_URI ()) in
- match fst goals with
- | (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])::_
- when left = right && iseq uri ->
- let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in
- true, Some (goalproof, reflproof, 0, Subst.empty_subst,m)
- | goal::_ ->
- (match check_if_goal_is_subsumed env (snd active) goal with
- | None -> false,None
- | Some p ->
- prerr_endline "Proof found by subsumption!";
- true, Some p)
- | _ -> false, None
- in
- if ok then
- ( prerr_endline "esco qui";
- (*
- let s = Printf.sprintf "actives:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun (s, e) -> (string_of_sign s) ^ " " ^
- (string_of_equality ~env e))
- (fst active)))) in
- let sp = Printf.sprintf "passives:\n%s\n"
- (String.concat "\n"
- (List.map
- (string_of_equality ~env)
- (let x,y,_ = passive in (fst x)@(fst y)))) in
- prerr_endline s;
- prerr_endline sp; *)
- match proof with
- | None -> assert false
- | Some p -> ParamodulationSuccess p)
- else
- given_clause_fullred_aux dbd env goals theorems passive active
- else
-(* let ok', theorems = activate_theorem theorems in *)
-(* if ok' then *)
-(* let ok, goals = apply_theorem_to_goals env theorems active goals in *)
-(* if ok then *)
-(* let proof = *)
-(* match (fst goals) with *)
-(* | (_, [proof, _, _])::_ -> Some proof *)
-(* | _ -> assert false *)
-(* in *)
-(* ParamodulationSuccess (proof, env) *)
-(* else *)
-(* given_clause_fullred_aux env goals theorems passive active *)
-(* else *)
- if (passive_is_empty passive) then ParamodulationFailure ""
- else given_clause_fullred_aux dbd env goals theorems passive active
-
-and given_clause_fullred_aux dbd env goals theorems passive active =
- prerr_endline (string_of_int !counter ^
- " MAXMETA: " ^ string_of_int !maxmeta ^
- " #ACTIVES: " ^ string_of_int (size_of_active active) ^
- " #PASSIVES: " ^ string_of_int (size_of_passive passive));
- incr counter;
-(*
- if !counter mod 10 = 0 then
- begin
- let size = HExtlib.estimate_size (passive,active) in
- let sizep = HExtlib.estimate_size (passive) in
- let sizea = HExtlib.estimate_size (active) in
- let (l1,s1),(l2,s2), t = passive in
- let sizetbl = HExtlib.estimate_size t in
- let sizel = HExtlib.estimate_size (l1,l2) in
- let sizes = HExtlib.estimate_size (s1,s2) in
-
- prerr_endline ("SIZE: " ^ string_of_int size);
- prerr_endline ("SIZE P: " ^ string_of_int sizep);
- prerr_endline ("SIZE A: " ^ string_of_int sizea);
- prerr_endline ("SIZE TBL: " ^ string_of_int sizetbl ^
- " SIZE L: " ^ string_of_int sizel ^
- " SIZE S:" ^ string_of_int sizes);
- end;*)
-(*
- if (size_of_active active) mod 50 = 0 then
- (let s = Printf.sprintf "actives:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun (s, e) -> (string_of_sign s) ^ " " ^
- (string_of_equality ~env e))
- (fst active)))) in
- let sp = Printf.sprintf "passives:\n%s\n"
- (String.concat "\n"
- (List.map
- (string_of_equality ~env)
- (let x,y,_ = passive in (fst x)@(fst y)))) in
- prerr_endline s;
- prerr_endline sp); *)
- let time1 = Unix.gettimeofday () in
- let (_,context,_) = env in
- let selection_estimate = get_selection_estimate () in
- let kept = size_of_passive passive in
- let passive =
- if !time_limit = 0. || !processed_clauses = 0 then
- passive
- else if !elapsed_time > !time_limit then (
- debug_print (lazy (Printf.sprintf "Time limit (%.2f) reached: %.2f\n"
- !time_limit !elapsed_time));
- make_passive []
- ) else if kept > selection_estimate then (
- debug_print
- (lazy (Printf.sprintf ("Too many passive equalities: pruning..." ^^
- "(kept: %d, selection_estimate: %d)\n")
- kept selection_estimate));
- prune_passive selection_estimate active passive
- ) else
- passive
- in
-
- let time2 = Unix.gettimeofday () in
- passive_maintainance_time := !passive_maintainance_time +. (time2 -. time1);
-
- kept_clauses := (size_of_passive passive) + (size_of_active active);
- match passive_is_empty passive with
- | true -> ParamodulationFailure ""
- (* given_clause_fullred dbd env goals theorems passive active *)
- | false ->
- let current, passive = select env goals passive in
- prerr_endline
- ("Selected = " ^ Equality.string_of_equality ~env current);
-(* ^
- (let w,p,(t,l,r,o),m = current in
- " size w: " ^ string_of_int (HExtlib.estimate_size w)^
- " size p: " ^ string_of_int (HExtlib.estimate_size p)^
- " size t: " ^ string_of_int (HExtlib.estimate_size t)^
- " size l: " ^ string_of_int (HExtlib.estimate_size l)^
- " size r: " ^ string_of_int (HExtlib.estimate_size r)^
- " size o: " ^ string_of_int (HExtlib.estimate_size o)^
- " size m: " ^ string_of_int (HExtlib.estimate_size m)^
- " size m-c: " ^ string_of_int
- (HExtlib.estimate_size (List.map (fun (x,_,_) -> x) m)))) *)
- let time1 = Unix.gettimeofday () in
- let res = forward_simplify env (Positive, current) ~passive active in
- let time2 = Unix.gettimeofday () in
- forward_simpl_time := !forward_simpl_time +. (time2 -. time1);
- match res with
- | None ->
- (* weight_age_counter := !weight_age_counter + 1; *)
- given_clause_fullred dbd env goals theorems passive active
- | Some current ->
-(* prerr_endline (Printf.sprintf "selected simpl: %s"
- (Equality.string_of_equality ~env current));*)
- let t1 = Unix.gettimeofday () in
- let new' = infer env current active in
- let _ =
- debug_print
- (lazy
- (Printf.sprintf "new' (senza semplificare):\n%s\n"
- (String.concat "\n"
- (List.map
- (fun e -> "Positive " ^
- (Equality.string_of_equality ~env e)) new'))))
- in
- let t2 = Unix.gettimeofday () in
- infer_time := !infer_time +. (t2 -. t1);
- let active =
- if Equality.is_identity env current then active
- else
- let al, tbl = active in
- al @ [current], Indexing.index tbl current
- in
- let rec simplify new' active passive =
- let t1 = Unix.gettimeofday () in
- let new' = forward_simplify_new env new'~passive active in
- let t2 = Unix.gettimeofday () in
- forward_simpl_new_time :=
- !forward_simpl_new_time +. (t2 -. t1);
- let t1 = Unix.gettimeofday () in
- let active, passive, newa, retained, pruned =
- backward_simplify env new' ~passive active in
- let passive =
- List.fold_left filter_dependent passive pruned in
- let t2 = Unix.gettimeofday () in
- backward_simpl_time := !backward_simpl_time +. (t2 -. t1);
- match newa, retained with
- | None, None -> active, passive, new'
- | Some p, None
- | None, Some p ->
- if Utils.debug_metas then
- begin
- List.iter
- (fun x->Indexing.check_target context x "simplify1")
- p;
- end;
- simplify (new' @ p) active passive
- | Some p, Some rp ->
- simplify (new' @ p @ rp) active passive
- in
- let active, passive, new' = simplify new' active passive in
- let goals =
- let a,b,_ = build_table new' in
- simplify_goals env goals ~passive (a,b)
- in
-
-(* pessima prova
- let new1 = prova env new' active in
- let new' = (fst new') @ (fst new1), (snd new') @ (snd new1) in
- let _ =
- match new1 with
- | neg, pos ->
- debug_print
- (lazy
- (Printf.sprintf "new1:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun e -> "Negative " ^
- (string_of_equality ~env e)) neg) @
- (List.map
- (fun e -> "Positive " ^
- (string_of_equality ~env e)) pos)))))
- in
-end prova *)
- let k = size_of_passive passive in
- if k < (kept - 1) then
- processed_clauses := !processed_clauses + (kept - 1 - k);
-
- let _ =
- debug_print
- (lazy
- (Printf.sprintf "active:\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun e -> (Equality.string_of_equality ~env e))
- (fst active))))))
- in
- let _ =
- debug_print
- (lazy
- (Printf.sprintf "new':\n%s\n"
- (String.concat "\n"
- ((List.map
- (fun e -> "Negative " ^
- (Equality.string_of_equality ~env e)) new')))))
- in
- let passive = add_to_passive passive new' in
- given_clause_fullred dbd env goals theorems passive active
-;;
-
-(*
-let profiler0 = HExtlib.profile "P/Saturation.given_clause_fullred"
-
-let given_clause_fullred dbd env goals theorems passive active =
- profiler0.HExtlib.profile
- (given_clause_fullred dbd env goals theorems passive) active
-*)
-
-let iseq uri = UriManager.eq uri (Utils.eq_URI ());;
-
let check_if_goal_is_identity env = function
| (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])
- when left = right && iseq uri ->
- let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in
+ when left = right && LibraryObjects.is_eq_URI uri ->
+ let reflproof = Equality.Exact (Equality.refl_proof uri eq_ty left) in
Some (goalproof, reflproof, 0, Subst.empty_subst,m)
| (goalproof,m,Cic.Appl[Cic.MutInd(uri,_,ens);eq_ty;left;right])
- when iseq uri ->
+ when LibraryObjects.is_eq_URI uri ->
(let _,context,_ = env in
try
let s,m,_ =
Inference.unification m m context left right CicUniv.empty_ugraph
in
- let reflproof = Equality.Exact (Equality.refl_proof eq_ty left) in
+ let reflproof = Equality.Exact (Equality.refl_proof uri eq_ty left) in
let m = Subst.apply_subst_metasenv s m in
Some (goalproof, reflproof, 0, s,m)
with _ -> None)
->
let selected = hd in
let passive_goals = tl in
- let new' = Indexing.superposition_left env (snd active) selected in
+ let _,_,ty = selected in
+ let new' =
+ if CicUtil.is_meta_closed ty then
+ []
+ else
+ Indexing.superposition_left env (snd active) selected
+ in
selected::active_goals, passive_goals @ new'
| _::tl -> aux tl
in
let infer_goal_set_with_current env current goals =
let active_goals, passive_goals = goals in
let _,table,_ = build_table [current] in
- let _,_,_,_,id = Equality.open_equality current in
active_goals,
List.fold_left
(fun acc g ->
let new' = Indexing.superposition_left env table g in
- if id = 2 then
- begin
- prerr_endline "XXXXXXX";
- List.iter (fun _,_,e -> prerr_endline (CicPp.ppterm e)) new' ;
- end;
acc @ new')
passive_goals active_goals
;;
(** given-clause algorithm with full reduction strategy: NEW implementation *)
(* here goals is a set of goals in OR *)
let given_clause
- ((_,context,_) as env) goals theorems passive active max_iterations max_time
+ eq_uri ((_,context,_) as env) goals theorems passive active max_iterations max_time
=
let names = names_of_context context in
let initial_time = Unix.gettimeofday () in
ParamodulationFailure "No more passive"(*maybe this is a success! *)
else
begin
- let goals = infer_goal_set env active goals in
- let goals = infer_goal_set env active goals in
let goals = infer_goal_set env active goals in
let current, passive = select env goals passive in
let _,_,goaltype = List.hd (fst goals) in
(Equality.string_of_equality ~env current));
(* SIMPLIFICATION OF CURRENT *)
let res =
- forward_simplify env (Positive, current) (*~passive*) active
+ forward_simplify eq_uri env (Positive, current) active
in
match res with
| None -> step goals theorems passive active (iterno+1)
| Some current ->
(* GENERATION OF NEW EQUATIONS *)
prerr_endline "infer";
- let new' = infer env current active in
+ let new' = infer eq_uri env current active in
prerr_endline "infer goal";
let goals = infer_goal_set_with_current env current goals in
let active =
(* FORWARD AND BACKWARD SIMPLIFICATION *)
prerr_endline "fwd/back simpl";
let rec simplify new' active passive =
- let new' = forward_simplify_new env new' ~passive active in
+ let new' =
+ forward_simplify_new eq_uri env new' ~passive active
+ in
let active, passive, newa, retained, pruned =
- backward_simplify env new' ~passive active
+ backward_simplify eq_uri env new' ~passive active
in
let passive =
List.fold_left filter_dependent passive pruned
| Some p, Some rp -> simplify (new' @ p @ rp) active passive
in
let active, passive, new' = simplify new' active passive in
- if iterno = 36 || iterno = 654 then
- begin
- prerr_endline "...................";
- List.iter
- (fun x -> prerr_endline (Equality.string_of_equality
-~env:env x)) new';
- prerr_endline "FINE...................";
- end;
prerr_endline "simpl goal with new";
let goals =
let a,b,_ = build_table new' in
let _ = <:start<simplify_goal_set new>> in
- <:stop<simplify_goal_set new
- simplify_goal_set env goals passive (a,b)
- >>
+ let rc = simplify_goal_set env goals passive (a,b) in
+ let _ = <:stop<simplify_goal_set new>> in
+ rc
in
let passive = add_to_passive passive new' in
step goals theorems passive active (iterno+1)
step goals theorems passive active 1
;;
-let rec saturate_equations env goal accept_fun passive active =
+let rec saturate_equations eq_uri env goal accept_fun passive active =
elapsed_time := Unix.gettimeofday () -. !start_time;
if !elapsed_time > !time_limit then
(active, passive)
else
let current, passive = select env ([goal],[]) passive in
- let res = forward_simplify env (Positive, current) ~passive active in
+ let res = forward_simplify eq_uri env (Positive, current) ~passive active in
match res with
| None ->
- saturate_equations env goal accept_fun passive active
+ saturate_equations eq_uri env goal accept_fun passive active
| Some current ->
debug_print (lazy (Printf.sprintf "selected: %s"
(Equality.string_of_equality ~env current)));
- let new' = infer env current active in
+ let new' = infer eq_uri env current active in
let active =
if Equality.is_identity env current then active
else
al @ [current], Indexing.index tbl current
in
let rec simplify new' active passive =
- let new' = forward_simplify_new env new' ~passive active in
+ let new' = forward_simplify_new eq_uri env new' ~passive active in
let active, passive, newa, retained, pruned =
- backward_simplify env new' ~passive active in
+ backward_simplify eq_uri env new' ~passive active in
let passive =
List.fold_left filter_dependent passive pruned in
match newa, retained with
in
let new' = List.filter accept_fun new' in
let passive = add_to_passive passive new' in
- saturate_equations env goal accept_fun passive active
+ saturate_equations eq_uri env goal accept_fun passive active
;;
let main dbd full term metasenv ugraph = ()
Equality.reset ();
;;
+let eq_of_goal = function
+ | Cic.Appl [Cic.MutInd(uri,0,_);_;_;_] when LibraryObjects.is_eq_URI uri ->
+ uri
+ | _ -> raise (ProofEngineTypes.Fail (lazy ("The goal is not an equality ")))
+;;
+
let saturate
dbd ?(full=false) ?(depth=default_depth) ?(width=default_width) status =
let module C = Cic in
reset_refs ();
Indexing.init_index ();
- counter := 0;
maxdepth := depth;
maxwidth := width;
(* CicUnification.unif_ty := false;*)
let proof, goalno = status in
let uri, metasenv, meta_proof, term_to_prove = proof in
let _, context, type_of_goal = CicUtil.lookup_meta goalno metasenv in
+ let eq_uri = eq_of_goal type_of_goal in
let names = names_of_context context in
let eq_indexes, equalities, maxm = find_equalities context proof in
let ugraph = CicUniv.empty_ugraph in
let library_equalities = List.map snd library_equalities in
let t2 = Unix.gettimeofday () in
maxmeta := maxm+2;
- let equalities = simplify_equalities env (equalities@library_equalities) in
+ let equalities =
+ simplify_equalities eq_uri env (equalities@library_equalities)
+ in
debug_print
(lazy
(Printf.sprintf "Time to retrieve equalities: %.9f\n" (t2 -. t1)));
let context_hyp = find_context_hypotheses env eq_indexes in
context_hyp @ thms, []
else
- let refl_equal =
- let us = UriManager.string_of_uri (Utils.eq_URI ()) in
- UriManager.uri_of_string (us ^ "#xpointer(1/1/1)")
- in
+ let refl_equal = LibraryObjects.eq_refl_URI ~eq:eq_uri in
let t = CicUtil.term_of_uri refl_equal in
let ty, _ = CicTypeChecker.type_of_aux' [] [] t CicUniv.empty_ugraph in
[(t, ty, [])], []
*)
let goals = make_goal_set goal in
let max_iterations = 10000 in
- let max_time = Unix.gettimeofday () +. 300. (* minutes *) in
- given_clause env goals theorems passive active max_iterations max_time
+ let max_time = Unix.gettimeofday () +. 600. (* minutes *) in
+ given_clause
+ eq_uri env goals theorems passive active max_iterations max_time
in
let finish = Unix.gettimeofday () in
(res, finish -. start)
in
let goal_proof, side_effects_t =
let initial = Equality.add_subst subsumption_subst newproof in
- Equality.build_goal_proof goalproof initial type_of_goal side_effects
+ Equality.build_goal_proof
+ eq_uri goalproof initial type_of_goal side_effects
in
let goal_proof = Subst.apply_subst subsumption_subst goal_proof in
let metas_still_open_in_proof = Utils.metas_of_term goal_proof in
let goal' = List.nth goals 0 in
let uri, metasenv, meta_proof, term_to_prove = proof in
let _, context, type_of_goal = CicUtil.lookup_meta goal' metasenv in
+ let eq_uri = eq_of_goal type_of_goal in
let eq_indexes, equalities, maxm = find_equalities context proof in
let ugraph = CicUniv.empty_ugraph in
let env = (metasenv, context, ugraph) in
(fun t (_, e) -> Indexing.index t e)
Indexing.empty active
in
- let res = forward_simplify env (Positive, e) (active, tbl) in
+ let res = forward_simplify eq_uri env (Positive, e) (active, tbl) in
match others with
| hd::tl -> (
match res with
let goal' = List.nth goals 0 in
let _, metasenv, meta_proof, _ = proof in
let _, context, goal = CicUtil.lookup_meta goal' metasenv in
+ let eq_uri = eq_of_goal goal in
let eq_indexes, equalities, maxm = find_equalities context proof in
let lib_eq_uris, library_equalities, maxm =
find_library_equalities dbd context (proof, goal') (maxm+2)
(*try*)
let goal = [], [], goal
in
- let equalities = simplify_equalities env (equalities@library_equalities) in
+ let equalities =
+ simplify_equalities eq_uri env (equalities@library_equalities)
+ in
let active = make_active () in
let passive = make_passive equalities in
Printf.printf "\ncontext:\n%s\n" (PP.ppcontext context);
start_time := Unix.gettimeofday ();
if !time_limit < 1. then time_limit := 60.;
let ra, rp =
- saturate_equations env goal (fun e -> true) passive active
+ saturate_equations eq_uri env goal (fun e -> true) passive active
in
let initial =
(List.map (fun e -> CicPp.ppterm (term_of_equality e)) active)) *)
(* (String.concat "\n" (List.map (string_of_equality ~env) passive)); *)
(String.concat "\n"
- (List.map (fun e -> CicPp.ppterm (Equality.term_of_equality e)) passive));
+ (List.map
+ (fun e -> CicPp.ppterm (Equality.term_of_equality eq_uri e))
+ passive));
print_newline ();
(*
with e ->
let module I = Inference in
let curi,metasenv,pbo,pty = proof in
let metano,context,ty = CicUtil.lookup_meta goal metasenv in
- let eq_indexes, equalities, maxm = I.find_equalities context proof in
+ let eq_uri = eq_of_goal ty in
+ let eq_indexes, equalities, maxm =
+ Inference.find_equalities context proof
+ in
let lib_eq_uris, library_equalities, maxm =
I.find_library_equalities dbd context (proof, goal) (maxm+2) in
if library_equalities = [] then prerr_endline "VUOTA!!!";
let library_equalities = List.map snd library_equalities in
let initgoal = [], [], ty in
let env = (metasenv, context, CicUniv.empty_ugraph) in
- let equalities = simplify_equalities env (equalities@library_equalities) in
+ let equalities =
+ simplify_equalities eq_uri env (equalities@library_equalities)
+ in
let table =
List.fold_left
(fun tbl eq -> Indexing.index tbl eq)
begin
let opengoal = Equality.Exact (Cic.Meta(maxm,irl)) in
let proofterm,_ =
- Equality.build_goal_proof newproof opengoal ty [] in
+ Equality.build_goal_proof eq_uri newproof opengoal ty []
+ in
let extended_metasenv = (maxm,context,newty)::metasenv in
let extended_status =
(curi,extended_metasenv,pbo,pty),goal in
projects / helm.git / commitdiff