module PEH = ProofEngineHelpers
module HEL = HExtlib
module DTI = DoubleTypeInference
+module NU = CicNotationUtil
+module L = Librarian
module Cl = ProceduralClassify
module T = ProceduralTypes
case: int list
}
-let debug = false
+let debug = ref false
(* helpers ******************************************************************)
let inc st =
{st with case = match st.case with
- | [] -> assert false
+ | [] -> []
| hd :: tl -> succ hd :: tl
}
with Not_found -> `Type (CicUniv.fresh())
with Invalid_argument _ -> failwith "A2P.get_sort"
*)
-let get_type msg st bo =
-try
- let ty, _ = TC.type_of_aux' [] st.context (H.cic bo) Un.oblivion_ugraph in
- ty
-with e -> failwith (msg ^ ": " ^ Printexc.to_string e)
-
let get_entry st id =
let rec aux = function
| [] -> assert false
in
aux st.context
-let get_ind_names uri tno =
-try
- let ts = match E.get_obj Un.oblivion_ugraph uri with
- | C.InductiveDefinition (ts, _, _, _), _ -> ts
- | _ -> assert false
- in
- match List.nth ts tno with
- | (_, _, _, cs) -> List.map fst cs
-with Invalid_argument _ -> failwith "A2P.get_ind_names"
-
let string_of_atomic = function
| C.ARel (_, _, _, s) -> s
| C.AVar (_, uri, _) -> H.name_of_uri uri None None
let names, _ = List.fold_left map ([], 1) l in
List.rev names
+let get_type msg st t = H.get_type msg st.context (H.cic t)
+
(* proof construction *******************************************************)
-let anonymous_premise = C.Name "PREMISE"
+let anonymous_premise = C.Name "UNNAMED"
let mk_exp_args hd tl classes synth =
let meta id = C.AImplicit (id, None) in
let e = Cn.hole "" in
let csty, cety = H.cic sty, H.cic ety in
let script =
- if debug then
+ if !debug then
let sname = match name with None -> "" | Some (id, _) -> id in
let note = Printf.sprintf "%s: %s\nSINTH: %s\nEXP: %s"
note sname (Pp.ppterm csty) (Pp.ppterm cety)
let convert st ?name v =
match get_inner_types st v with
| None ->
- if debug then [T.Note "NORMAL: NO INNER TYPES"] else []
+ if !debug then [T.Note "NORMAL: NO INNER TYPES"] else []
| Some (sty, ety) -> mk_convert st ?name sty ety "NORMAL"
-
-let convert_elim st ?name t v pattern =
- match t, get_inner_types st t, get_inner_types st v with
- | _, None, _
- | _, _, None -> [(* T.Note "ELIM: NO INNER TYPES"*)]
- | C.AAppl (_, hd :: tl), Some (tsty, _), Some (vsty, _) ->
- let where = List.hd (List.rev tl) in
- let cty = Cn.elim_inferred_type
- st.context (H.cic vsty) (H.cic where) (H.cic hd) (H.cic pattern)
- in
- mk_convert st ?name (Cn.fake_annotate "" st.context cty) tsty "ELIM"
- | _, Some _, Some _ -> assert false
let get_intro = function
| C.Anonymous -> None
if (Cn.does_not_occur e) then st, [] else
match where with
| C.ARel (_, _, i, premise) as w ->
-(* let _script = convert_elim st ~name:(premise, i) v w e in *)
let script name =
let where = Some (premise, name) in
- let script = mk_arg st what @ mk_arg st w (* @ script *) in
+ let script = mk_arg st what @ mk_arg st w in
T.Rewrite (direction, what, where, e, dtext) :: script
in
if DTI.does_not_occur (succ i) (H.cic t) || compare premise name then
let ity = H.acic_bc st.context ity in
let br1 = [T.Id ""] in
let br2 = List.rev (T.Apply (w, "assumption") :: script None) in
- let text = "non linear rewrite" in
+ let text = "non-linear rewrite" in
st, [T.Branch ([br2; br1], ""); T.Cut (name, ity, text)]
end
| _ -> assert false
let predicate = List.nth tl 2 in
let e = Cn.mk_pattern 1 predicate in
let script = [T.Branch (qs, "")] in
- if (Cn.does_not_occur e) then script else
-(* let script = convert_elim st t t e in *)
+ if (Cn.does_not_occur e) then script else
T.Rewrite (direction, where, None, e, dtext) :: script
let rec proc_lambda st what name v t =
and proc_appl st what hd tl =
let proceed, dtext = test_depth st in
let script = if proceed then
- let ty = get_type "TC2" st hd in
+ let ty = match get_inner_types st hd with
+ | Some (ity, _) -> H.cic ity
+ | None -> get_type "TC2" st hd
+ in
let classes, rc = Cl.classify st.context ty in
let goal_arity, goal = match get_inner_types st what with
| None -> 0, None
let classes2, tl2, _, where = split2_last classes tl in
let script2 = List.rev (mk_arg st where) @ script in
let synth2 = I.S.add 1 synth in
- let names = get_ind_names uri tyno in
+ let names = H.get_ind_names uri tyno in
let qs = proc_bkd_proofs (next st) synth2 names classes2 tl2 in
if List.length qs <> List.length names then
let qs = proc_bkd_proofs (next st) synth [] classes tl in
let predicate = List.nth tl2 (parsno - i) in
let e = Cn.mk_pattern j predicate in
let using = Some hd in
- (* convert_elim st what what e @ *) script2 @
+ script2 @
[T.Elim (where, using, e, dtext ^ text); T.Branch (qs, "")]
| None ->
let names = get_sub_names hd tl in
and proc_bkd_proofs st synth names classes ts =
try
- let get_note =
- let names = ref (names, push st) in
- fun f ->
- match !names with
- | [], st -> fun _ -> f st
- | "" :: tl, st -> names := tl, st; fun _ -> f st
- | hd :: tl, st ->
- let note = case st hd in
- names := tl, inc st;
- fun b -> if b then T.Note note :: f st else f st
+ let get_names b = ref (names, if b then push st else st) in
+ let get_note f b names =
+ match !names with
+ | [], st -> f st
+ | "" :: tl, st -> names := tl, st; f st
+ | hd :: tl, st ->
+ let note = case st hd in
+ names := tl, inc st;
+ if b then T.Note note :: f st else f st
in
let _, dtext = test_depth st in
let aux (inv, _) v =
in
let ps = T.list_map2_filter aux classes ts in
let b = List.length ps > 1 in
- List.rev_map (fun f -> f b) ps
+ let names = get_names b in
+ List.rev_map (fun f -> f b names) ps
with Invalid_argument s -> failwith ("A2P.proc_bkd_proofs: " ^ s)
(* object costruction *******************************************************)
-let is_theorem pars =
- pars = [] ||
- List.mem (`Flavour `Theorem) pars || List.mem (`Flavour `Fact) pars ||
- List.mem (`Flavour `Remark) pars || List.mem (`Flavour `Lemma) pars
-
-let is_definition pars =
- List.mem (`Flavour `Definition) pars
-
-let proc_obj st = function
- | C.AConstant (_, _, s, Some v, t, [], pars) when is_theorem pars ->
- let ast = proc_proof st v in
- let steps, nodes = T.count_steps 0 ast, T.count_nodes 0 ast in
- let text = Printf.sprintf "tactics: %u\nnodes: %u" steps nodes in
- T.Statement (`Theorem, Some s, t, None, "") :: ast @ [T.Qed text]
- | C.AConstant (_, _, s, Some v, t, [], pars) when is_definition pars ->
- [T.Statement (`Definition, Some s, t, Some v, "")]
- | C.AConstant (_, _, s, None, t, [], pars) ->
+let th_flavours = [`Theorem; `Lemma; `Remark; `Fact]
+
+let def_flavours = [`Definition]
+
+let get_flavour ?flavour attrs =
+ let rec aux = function
+ | [] -> List.hd th_flavours
+ | `Flavour fl :: _ -> fl
+ | _ :: tl -> aux tl
+ in
+ match flavour with
+ | Some fl -> fl
+ | None -> aux attrs
+
+let proc_obj ?flavour ?(info="") st = function
+ | C.AConstant (_, _, s, Some v, t, [], attrs) ->
+ begin match get_flavour ?flavour attrs with
+ | flavour when List.mem flavour th_flavours ->
+ let ast = proc_proof st v in
+ let steps, nodes = T.count_steps 0 ast, T.count_nodes 0 ast in
+ let text = Printf.sprintf "%s\n%s%s: %u\n%s: %u\n%s"
+ "COMMENTS" info "Tactics" steps "Final nodes" nodes "END"
+ in
+ T.Statement (flavour, Some s, t, None, "") :: ast @ [T.Qed text]
+ | flavour when List.mem flavour def_flavours ->
+ [T.Statement (flavour, Some s, t, Some v, "")]
+ | _ ->
+ failwith "not a theorem, definition, axiom or inductive type"
+ end
+ | C.AConstant (_, _, s, None, t, [], attrs) ->
[T.Statement (`Axiom, Some s, t, None, "")]
- | _ ->
- failwith "not a theorem, definition, axiom"
+ | C.AInductiveDefinition (_, types, [], lpsno, attrs) ->
+ [T.Inductive (types, lpsno, "")]
+ | _ ->
+ failwith "not a theorem, definition, axiom or inductive type"
(* interface functions ******************************************************)
-let procedural_of_acic_object ~ids_to_inner_sorts ~ids_to_inner_types ?depth
- ?flavour prefix anobj =
+let procedural_of_acic_object ~ids_to_inner_sorts ~ids_to_inner_types
+ ?info ?depth ?flavour prefix anobj =
let st = {
sorts = ids_to_inner_sorts;
types = ids_to_inner_types;
context = [];
case = []
} in
+ L.time_stamp "P : LEVEL 2 ";
HLog.debug "Procedural: level 2 transformation";
- let steps = proc_obj st anobj in
+ let steps = proc_obj st ?flavour ?info anobj in
+ L.time_stamp "P : RENDERING";
HLog.debug "Procedural: grafite rendering";
- List.rev (T.render_steps [] steps)
+ let r = List.rev (T.render_steps [] steps) in
+ L.time_stamp "P : DONE "; r
let procedural_of_acic_term ~ids_to_inner_sorts ~ids_to_inner_types ?depth
prefix context annterm =