let maxwidth = ref 3;;
type new_proof =
- Equality.goal_proof * Equality.proof * Subst.substitution * Cic.metasenv
+ Equality.goal_proof * Equality.proof * int * Subst.substitution * Cic.metasenv
type result =
| ParamodulationFailure of string
| ParamodulationSuccess of new_proof
Equality.mk_tmp_equality(0,(eq_ty,l,r,Utils.Incomparable),metas)in
match Indexing.subsumption env active_table eqtmp with
| None -> false
- | Some (s,eq') ->
-(*
- prerr_endline
- ("\n\n " ^ Equality.string_of_equality ~env eq ^
- "\nis"^(if deep then " CONTEXTUALLY " else " ")^"subsumed by \n " ^
- Equality.string_of_equality ~env eq' ^ "\n\n");
-*)
- true
+ | Some _ -> true
in
let rec aux b (ok_so_far, subsumption_used) t1 t2 =
match t1,t2 with
| t1, t2 when not ok_so_far -> ok_so_far, subsumption_used
| t1, t2 when subsumption_used -> t1 = t2, subsumption_used
-(* VERSIONE ERRATA
- | Cic.Appl (h1::l),Cic.Appl (h2::l') when h1 = h2 ->
- let rc = check_subsumed b t1 t1 in
- if rc then
- true, true
- else if h1 = h2 then
- (try
- List.fold_left2
- (fun (ok_so_far, subsumption_used) t t' ->
- aux true (ok_so_far, subsumption_used) t t')
- (ok_so_far, subsumption_used) l l'
- with Invalid_argument _ -> false,subsumption_used)
- else
- false, subsumption_used
- | _ -> false, subsumption_used *)
| Cic.Appl (h1::l),Cic.Appl (h2::l') ->
let rc = check_subsumed b t1 t2 in
if rc then
fst (aux false (true,false) left right)
;;
-(*
-let check_for_deep env active_table eq =
- match Indexing.subsumption env active_table eq with
- | None -> false
- | Some _ -> true
-;;
-*)
-
-let profiler = HExtlib.profile "check_for_deep";;
-
-let check_for_deep_subsumption env active_table eq =
- profiler.HExtlib.profile (check_for_deep_subsumption env active_table) eq
-;;
-
(* buttare via sign *)
(** simplifies current using active and passive *)
Indexing.demodulation_equality !maxmeta env table sign current in
maxmeta := newmeta;
if Equality.is_identity env newcurrent then
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "\ncurrent was: %s\nnewcurrent is: %s\n" *)
-(* (string_of_equality current) *)
-(* (string_of_equality newcurrent))); *)
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "active is: %s" *)
-(* (String.concat "\n" *)
-(* (List.map (fun (_, e) -> (string_of_equality e)) active_list)))); *)
- None
+ None
else
Some newcurrent
in
(* if Indexing.subsumption env active_table c = None then*)
(match Indexing.subsumption env passive_table c with
| None -> res
- | Some (_,c') ->
+ | Some (_,c',_) ->
None
(*prerr_endline "\n\nPESCO DALLE PASSIVE LA PIU' GENERALE\n\n";
Some c'*))
*)
;;
-type fs_time_info_t = {
- mutable build_all: float;
- mutable demodulate: float;
- mutable subsumption: float;
-};;
-
-let fs_time_info = { build_all = 0.; demodulate = 0.; subsumption = 0. };;
-
-
(** simplifies new using active and passive *)
let forward_simplify_new env new_pos ?passive active =
if Utils.debug_metas then
List.fold_left
(fun s e ->
if not (Equality.is_identity env e) then
-(* if EqualitySet.mem e s then s *)
- (*else*) EqualitySet.add e s
+ EqualitySet.add e s
else s)
EqualitySet.empty new_pos
in
(fun e -> ((Indexing.subsumption env active_table e = None) &&
(Indexing.subsumption env passive_table e = None)))
in
-(* let t1 = Unix.gettimeofday () in *)
-(* let t2 = Unix.gettimeofday () in *)
-(* fs_time_info.subsumption <- fs_time_info.subsumption +. (t2 -. t1); *)
let is_duplicate =
match passive_table with
| None ->
in
Printf.sprintf "%d: %s" d (String.concat "; " gl')) goals))
;;
-
+
let check_if_goal_is_subsumed ((_,ctx,_) as env) table (goalproof,menv,ty) =
-(* let names = names_of_context ctx in*)
-(* Printf.eprintf "check_goal_subsumed: %s\n" (CicPp.pp ty names);*)
+(*
+ let names = names_of_context ctx in
+ Printf.eprintf "check_goal_subsumed: %s\n" (CicPp.pp ty names);
+*)
match ty with
| Cic.Appl[Cic.MutInd(uri,_,_);eq_ty;left;right]
when UriManager.eq uri (LibraryObjects.eq_URI ()) ->
in
(* match Indexing.subsumption env table goal_equation with*)
match Indexing.unification env table goal_equation with
- | Some (subst, equality ) ->
+ | Some (subst, equality, pos ) ->
+ prerr_endline
+ ("GOAL SUBSUMED BY: " ^ Equality.string_of_equality equality);
+ prerr_endline ("SUBST:" ^ Subst.ppsubst subst);
let (_,p,(ty,l,r,_),m,id) = Equality.open_equality equality in
let cicmenv = Subst.apply_subst_metasenv subst (m @ menv) in
- Some (goalproof, p, subst, cicmenv)
+ let p =
+ if pos = Utils.Left then
+ Equality.symmetric eq_ty l id uri m
+ else
+ p
+ in
+ Some (goalproof, p, id, subst, cicmenv)
| None -> None)
| _ -> None
;;
| (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, Subst.empty_subst,m)
+ true, Some (goalproof, reflproof, 0, Subst.empty_subst,m)
| goal::_ ->
(match check_if_goal_is_subsumed env (snd active) goal with
| None -> false,None
| (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
- Some (goalproof, reflproof,Subst.empty_subst,m)
+ Some (goalproof, reflproof, 0, Subst.empty_subst,m)
| _ -> None
;;
let eq_indexes, equalities, maxm = find_equalities context proof in
let ugraph = CicUniv.empty_ugraph in
let env = (metasenv, context, ugraph) in
- let goal = [], metasenv, type_of_goal in
+ let goal = [], List.filter (fun (i,_,_)->i<>goalno) metasenv, type_of_goal in
let res, time =
let t1 = Unix.gettimeofday () in
let lib_eq_uris, library_equalities, maxm =
given_clause_fullred dbd env goals theorems passive active
*)
let goals = make_goal_set goal in
- let max_iterations = 1000 in
- let max_time = Unix.gettimeofday () +. 120. (* minutes *) 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
in
let finish = Unix.gettimeofday () in
| ParamodulationFailure s ->
raise (ProofEngineTypes.Fail (lazy ("NO proof found: " ^ s)))
| ParamodulationSuccess
- (goalproof,newproof,subsumption_subst, proof_menv) ->
+ (goalproof,newproof,subsumption_id,subsumption_subst, proof_menv) ->
prerr_endline "OK, found a proof!";
- prerr_endline (Equality.pp_proof names goalproof newproof);
+ prerr_endline
+ (Equality.pp_proof names goalproof newproof subsumption_subst
+ subsumption_id type_of_goal);
+ prerr_endline (CicMetaSubst.ppmetasenv [] proof_menv);
prerr_endline "ENDOFPROOFS";
(* generation of the CIC proof *)
let side_effects =
let initial = newproof in
Equality.build_goal_proof goalproof initial type_of_goal side_effects
in
-prerr_endline (CicPp.pp goal_proof names);
+(*prerr_endline (CicPp.pp goal_proof names);*)
let goal_proof = Subst.apply_subst subsumption_subst goal_proof in
let side_effects_t =
List.map (Subst.apply_subst subsumption_subst) side_effects_t
([],[],[],None) proof_menv
in
let replace where =
+ (* we need this fake equality since the metas of the hypothesis may be
+ * with a real local context *)
ProofEngineReduction.replace_lifting
- ~equality:(=) ~what ~with_what ~where
+ ~equality:(fun x y ->
+ match x,y with Cic.Meta(i,_),Cic.Meta(j,_) -> i=j | _-> false)
+ ~what ~with_what ~where
in
let goal_proof = replace goal_proof in
(* ok per le meta libere... ma per quelle che c'erano e sono rimaste?
(ProofEngineHelpers.compare_metasenvs
~oldmetasenv:metasenv ~newmetasenv:goal_proof_menv)
in
+prerr_endline ("freemetas: " ^ String.concat "," (List.map string_of_int free_metas) );
(* check/refine/... build the new proof *)
let replaced_goal =
ProofEngineReduction.replace
let final_subst =
(goalno,(context,goal_proof,type_of_goal))::subst_side_effects
in
+prerr_endline ("MENVreal_menv: " ^ CicMetaSubst.ppmetasenv [] real_menv);
let _ =
try
CicTypeChecker.type_of_aux' real_menv context goal_proof
| CicTypeChecker.AssertFailure _
| Invalid_argument "list_fold_left2" as exn ->
prerr_endline "THE PROOF DOES NOT TYPECHECK!";
- prerr_endline (CicPp.pp goal_proof names);
+ prerr_endline (CicPp.pp goal_proof names);
+ prerr_endline "THE PROOF DOES NOT TYPECHECK!";
raise exn
in
let proof, real_metasenv =
projects / helm.git / blobdiff