-(* applies equality to goal to see if the goal can be closed *)
-let apply_equality_to_goal env equality goal =
- let module C = Cic in
- let module HL = HelmLibraryObjects in
- let module I = Inference in
- let metasenv, context, ugraph = env in
- let _, proof, (ty, left, right, _), metas, args = equality in
- let eqterm =
- C.Appl [C.MutInd (LibraryObjects.eq_URI (), 0, []); ty; left; right] in
- let gproof, gmetas, gterm = goal in
-(* debug_print *)
-(* (lazy *)
-(* (Printf.sprintf "APPLY EQUALITY TO GOAL: %s, %s" *)
-(* (string_of_equality equality) (CicPp.ppterm gterm))); *)
- try
- let subst, metasenv', _ =
- let menv = metasenv @ metas @ gmetas in
- Inference.unification metas gmetas context eqterm gterm ugraph
- in
- let newproof =
- match proof with
- | I.BasicProof t -> I.BasicProof (CicMetaSubst.apply_subst subst t)
- | I.ProofBlock (s, uri, nt, t, pe, p) ->
- I.ProofBlock (subst @ s, uri, nt, t, pe, p)
- | _ -> assert false
- in
- let newgproof =
- let rec repl = function
- | I.ProofGoalBlock (_, gp) -> I.ProofGoalBlock (newproof, gp)
- | I.NoProof -> newproof
- | I.BasicProof p -> newproof
- | I.SubProof (t, i, p) -> I.SubProof (t, i, repl p)
- | _ -> assert false
- in
- repl gproof
- in
- true, subst, newgproof
- with CicUnification.UnificationFailure _ ->
- false, [], I.NoProof
-;;
-
-
-
-let new_meta metasenv =
- let m = CicMkImplicit.new_meta metasenv [] in
- incr maxmeta;
- while !maxmeta <= m do incr maxmeta done;
- !maxmeta
-;;
-
-
-(* applies a theorem or an equality to goal, returning a list of subgoals or
- an indication of failure *)
-let apply_to_goal env theorems ?passive active goal =
- let metasenv, context, ugraph = env in
- let proof, metas, term = goal in
- (* debug_print *)
- (* (lazy *)
- (* (Printf.sprintf "apply_to_goal with goal: %s" *)
- (* (\* (string_of_proof proof) *\)(CicPp.ppterm term))); *)
- let status =
- let irl =
- CicMkImplicit.identity_relocation_list_for_metavariable context in
- let proof', newmeta =
- let rec get_meta = function
- | SubProof (t, i, p) ->
- let t', i' = get_meta p in
- if i' = -1 then t, i else t', i'
- | ProofGoalBlock (_, p) -> get_meta p
- | _ -> Cic.Implicit None, -1
- in
- let p, m = get_meta proof in
- if m = -1 then
- let n = new_meta (metasenv @ metas) in
- Cic.Meta (n, irl), n
- else
- p, m
- in
- let metasenv = (newmeta, context, term)::metasenv @ metas in
- let bit = new_meta metasenv, context, term in
- let metasenv' = bit::metasenv in
- ((None, metasenv', Cic.Meta (newmeta, irl), term), newmeta)
- in
- let rec aux = function
- | [] -> `No
- | (theorem, thmty, _)::tl ->
- try
- let subst, (newproof, newgoals) =
- PrimitiveTactics.apply_tac_verbose_with_subst ~term:theorem status
- in
- if newgoals = [] then
- let _, _, p, _ = newproof in
- let newp =
- let rec repl = function
- | Inference.ProofGoalBlock (_, gp) ->
- Inference.ProofGoalBlock (Inference.BasicProof p, gp)
- | Inference.NoProof -> Inference.BasicProof p
- | Inference.BasicProof _ -> Inference.BasicProof p
- | Inference.SubProof (t, i, p2) ->
- Inference.SubProof (t, i, repl p2)
- | _ -> assert false
- in
- repl proof
- in
- let _, m = status in
- let subst = List.filter (fun (i, _) -> i = m) subst in
- `Ok (subst, [newp, metas, term])
- else
- let _, menv, p, _ = newproof in
- let irl =
- CicMkImplicit.identity_relocation_list_for_metavariable context
- in
- let goals =
- List.map
- (fun i ->
- let _, _, ty = CicUtil.lookup_meta i menv in
- let p' =
- let rec gp = function
- | SubProof (t, i, p) ->
- SubProof (t, i, gp p)
- | ProofGoalBlock (sp1, sp2) ->
- ProofGoalBlock (sp1, gp sp2)
- | BasicProof _
- | NoProof ->
- SubProof (p, i, BasicProof (Cic.Meta (i, irl)))
- | ProofSymBlock (s, sp) ->
- ProofSymBlock (s, gp sp)
- | ProofBlock (s, u, nt, t, pe, sp) ->
- ProofBlock (s, u, nt, t, pe, gp sp)
- in gp proof
- in
- (p', menv, ty))
- newgoals
- in
- let goals =
- let weight t =
- let w, m = weight_of_term t in
- w + 2 * (List.length m)
- in
- List.sort
- (fun (_, _, t1) (_, _, t2) ->
- Pervasives.compare (weight t1) (weight t2))
- goals
- in
- let best = aux tl in
- match best with
- | `Ok (_, _) -> best
- | `No -> `GoOn ([subst, goals])
- | `GoOn sl -> `GoOn ((subst, goals)::sl)
- with ProofEngineTypes.Fail msg ->
- aux tl
- in
- let r, s, l =
- if Inference.term_is_equality term then
- let rec appleq_a = function
- | [] -> false, [], []
- | (Positive, equality)::tl ->
- let ok, s, newproof = apply_equality_to_goal env equality goal in
- if ok then true, s, [newproof, metas, term] else appleq_a tl
- | _::tl -> appleq_a tl
- in
- let rec appleq_p = function
- | [] -> false, [], []
- | equality::tl ->
- let ok, s, newproof = apply_equality_to_goal env equality goal in
- if ok then true, s, [newproof, metas, term] else appleq_p tl
- in
- let al, _ = active in
- match passive with
- | None -> appleq_a al
- | Some (_, (pl, _), _) ->
- let r, s, l = appleq_a al in if r then r, s, l else appleq_p pl
- else
- false, [], []
- in
- if r = true then `Ok (s, l) else aux theorems
-;;
-
-
-(* sorts a conjunction of goals in order to detect earlier if it is
- unsatisfiable. Non-predicate goals are placed at the end of the list *)
-let sort_goal_conj (metasenv, context, ugraph) (depth, gl) =
- let gl =
- List.stable_sort
- (fun (_, e1, g1) (_, e2, g2) ->
- let ty1, _ =
- CicTypeChecker.type_of_aux' (e1 @ metasenv) context g1 ugraph
- and ty2, _ =
- CicTypeChecker.type_of_aux' (e2 @ metasenv) context g2 ugraph
- in
- let prop1 =
- let b, _ =
- CicReduction.are_convertible context (Cic.Sort Cic.Prop) ty1 ugraph
- in
- if b then 0 else 1
- and prop2 =
- let b, _ =
- CicReduction.are_convertible context (Cic.Sort Cic.Prop) ty2 ugraph
- in
- if b then 0 else 1
- in
- if prop1 = 0 && prop2 = 0 then
- let e1 = if Inference.term_is_equality g1 then 0 else 1
- and e2 = if Inference.term_is_equality g2 then 0 else 1 in
- e1 - e2
- else
- prop1 - prop2)
- gl
- in
- (depth, gl)
-;;
-
-
-let is_meta_closed goals =
- List.for_all (fun (_, _, g) -> CicUtil.is_meta_closed g) goals
-;;
-
-
-(* applies a series of theorems/equalities to a conjunction of goals *)
-let rec apply_to_goal_conj env theorems ?passive active (depth, goals) =
- let aux (goal, r) tl =
- let propagate_subst subst (proof, metas, term) =
- let rec repl = function
- | NoProof -> NoProof
- | BasicProof t ->
- BasicProof (CicMetaSubst.apply_subst subst t)
- | ProofGoalBlock (p, pb) ->
- let pb' = repl pb in
- ProofGoalBlock (p, pb')
- | SubProof (t, i, p) ->
- let t' = CicMetaSubst.apply_subst subst t in
- let p = repl p in
- SubProof (t', i, p)
- | ProofSymBlock (ens, p) -> ProofSymBlock (ens, repl p)
- | ProofBlock (s, u, nty, t, pe, p) ->
- ProofBlock (subst @ s, u, nty, t, pe, p)
- in (repl proof, metas, term)
- in
- (* let r = apply_to_goal env theorems ?passive active goal in *) (
- match r with
- | `No -> `No (depth, goals)
- | `GoOn sl ->
- let l =
- List.map
- (fun (s, gl) ->
- let tl = List.map (propagate_subst s) tl in
- sort_goal_conj env (depth+1, gl @ tl)) sl
- in
- `GoOn l
- | `Ok (subst, gl) ->
- if tl = [] then
- `Ok (depth, gl)
- else
- let p, _, _ = List.hd gl in
- let subproof =
- let rec repl = function
- | SubProof (_, _, p) -> repl p
- | ProofGoalBlock (p1, p2) ->
- ProofGoalBlock (repl p1, repl p2)
- | p -> p
- in
- build_proof_term (repl p)
- in
- let i =
- let rec get_meta = function
- | SubProof (_, i, p) ->
- let i' = get_meta p in
- if i' = -1 then i else i'
-(* max i (get_meta p) *)
- | ProofGoalBlock (_, p) -> get_meta p
- | _ -> -1
- in
- get_meta p
- in
- let subst =
- let _, (context, _, _) = List.hd subst in
- [i, (context, subproof, Cic.Implicit None)]
- in
- let tl = List.map (propagate_subst subst) tl in
- let conj = sort_goal_conj env (depth(* +1 *), tl) in
- `GoOn ([conj])
- )
- in
- if depth > !maxdepth || (List.length goals) > !maxwidth then
- `No (depth, goals)
- else
- let rec search_best res = function
- | [] -> res
- | goal::tl ->
- let r = apply_to_goal env theorems ?passive active goal in
- match r with
- | `Ok _ -> (goal, r)
- | `No -> search_best res tl
- | `GoOn l ->
- let newres =
- match res with
- | _, `Ok _ -> assert false
- | _, `No -> goal, r
- | _, `GoOn l2 ->
- if (List.length l) < (List.length l2) then goal, r else res
- in
- search_best newres tl
- in
- let hd = List.hd goals in
- let res = hd, (apply_to_goal env theorems ?passive active hd) in
- let best =
- match res with
- | _, `Ok _ -> res
- | _, _ -> search_best res (List.tl goals)
- in
- let res = aux best (List.filter (fun g -> g != (fst best)) goals) in
- match res with
- | `GoOn ([conj]) when is_meta_closed (snd conj) &&
- (List.length (snd conj)) < (List.length goals)->
- apply_to_goal_conj env theorems ?passive active conj
- | _ -> res
-;;
-
-
-(*
-module OrderedGoals = struct
- type t = int * (Inference.proof * Cic.metasenv * Cic.term) list
-
- let compare g1 g2 =
- let d1, l1 = g1
- and d2, l2 = g2 in
- let r = d2 - d1 in
- if r <> 0 then r
- else let r = (List.length l1) - (List.length l2) in
- if r <> 0 then r
- else
- let res = ref 0 in
- let _ =
- List.exists2
- (fun (_, _, t1) (_, _, t2) ->
- let r = Pervasives.compare t1 t2 in
- if r <> 0 then (
- res := r;
- true
- ) else
- false) l1 l2
- in !res
-end
-
-module GoalsSet = Set.Make(OrderedGoals);;
-
-
-exception SearchSpaceOver;;
-*)
-
-
-(*
-let apply_to_goals env is_passive_empty theorems active goals =
- debug_print (lazy "\n\n\tapply_to_goals\n\n");
- let add_to set goals =
- List.fold_left (fun s g -> GoalsSet.add g s) set goals
- in
- let rec aux set = function
- | [] ->
- debug_print (lazy "HERE!!!");
- if is_passive_empty then raise SearchSpaceOver else false, set
- | goals::tl ->
- let res = apply_to_goal_conj env theorems active goals in
- match res with
- | `Ok newgoals ->
- let _ =
- let d, p, t =
- match newgoals with
- | (d, (p, _, t)::_) -> d, p, t
- | _ -> assert false
- in
- debug_print
- (lazy
- (Printf.sprintf "\nOK!!!!\ndepth: %d\nProof: %s\ngoal: %s\n"
- d (string_of_proof p) (CicPp.ppterm t)))
- in
- true, GoalsSet.singleton newgoals
- | `GoOn newgoals ->
- let set' = add_to set (goals::tl) in
- let set' = add_to set' newgoals in
- false, set'
- | `No newgoals ->
- aux set tl
- in
- let n = List.length goals in
- let res, goals = aux (add_to GoalsSet.empty goals) goals in
- let goals = GoalsSet.elements goals in
- debug_print (lazy "\n\tapply_to_goals end\n");
- let m = List.length goals in
- if m = n && is_passive_empty then
- raise SearchSpaceOver
- else
- res, goals
-;;
-*)
-
-
-(* sorts the list of passive goals to minimize the search for a proof (doesn't
- work that well yet...) *)
-let sort_passive_goals goals =
- List.stable_sort
- (fun (d1, l1) (d2, l2) ->
- let r1 = d2 - d1
- and r2 = (List.length l1) - (List.length l2) in
- let foldfun ht (_, _, t) =
- let _ = List.map (fun i -> Hashtbl.replace ht i 1) (metas_of_term t)
- in ht
- in
- let m1 = Hashtbl.length (List.fold_left foldfun (Hashtbl.create 3) l1)
- and m2 = Hashtbl.length (List.fold_left foldfun (Hashtbl.create 3) l2)
- in let r3 = m1 - m2 in
- if r3 <> 0 then r3
- else if r2 <> 0 then r2
- else r1)
- (* let _, _, g1 = List.hd l1 *)
-(* and _, _, g2 = List.hd l2 in *)
-(* let e1 = if Inference.term_is_equality g1 then 0 else 1 *)
-(* and e2 = if Inference.term_is_equality g2 then 0 else 1 *)
-(* in let r4 = e1 - e2 in *)
-(* if r4 <> 0 then r3 else r1) *)
- goals
-;;
-
-