module PEH = ProofEngineHelpers
module HEL = HExtlib
module DTI = DoubleTypeInference
+module NU = CicNotationUtil
+module L = Librarian
module Cl = ProceduralClassify
module T = ProceduralTypes
type status = {
sorts : (C.id, A.sort_kind) Hashtbl.t;
types : (C.id, A.anntypes) Hashtbl.t;
- prefix: string;
max_depth: int option;
depth: int;
context: C.context;
- clears: string list;
- clears_note: string;
- case: int list;
- skip_thm_and_qed : bool;
+ case: int list
}
-let debug = true
+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
+let string_of_atomic = function
+ | C.ARel (_, _, _, s) -> s
+ | C.AVar (_, uri, _) -> H.name_of_uri uri None None
+ | C.AConst (_, uri, _) -> H.name_of_uri uri None None
+ | C.AMutInd (_, uri, i, _) -> H.name_of_uri uri (Some i) None
+ | C.AMutConstruct (_, uri, i, j, _) -> H.name_of_uri uri (Some i) (Some j)
+ | _ -> ""
+
+let get_sub_names head l =
+ let s = string_of_atomic head in
+ if s = "" then [] else
+ let map (names, i) _ =
+ let name = Printf.sprintf "%s_%u" s i in name :: names, succ i
in
- match List.nth ts tno with
- | (_, _, _, cs) -> List.map fst cs
-with Invalid_argument _ -> failwith "A2P.get_ind_names"
+ 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)
+
+let clear_absts m =
+ let rec aux k n = function
+ | C.ALambda (id, s, v, t) when k > 0 ->
+ C.ALambda (id, s, v, aux (pred k) n t)
+ | C.ALambda (_, _, _, t) when n > 0 ->
+ aux 0 (pred n) (Cn.lift 1 (-1) t)
+ | t when n > 0 ->
+ Printf.eprintf "A2P.clear_absts: %u %s\n" n (Pp.ppterm (H.cic t));
+ assert false
+ | t -> t
+ in
+ aux m
(* 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
| C.Name s -> Some s
let mk_preamble st what script =
- let clears st script =
- if true (* st.clears = [] *) then script else T.Clear (st.clears, st.clears_note) :: script
- in
- clears st (convert st what @ script)
+ convert st what @ script
let mk_arg st = function
| C.ARel (_, _, i, name) as what -> convert st ~name:(name, i) what
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 qs = proc_bkd_proofs (next st) synth [] classes tl in
+ let names = get_sub_names hd tl in
+ let qs = proc_bkd_proofs (next st) synth names classes tl in
let hd = mk_exp_args hd tl classes synth in
script @ [T.Apply (hd, dtext ^ text); T.Branch (qs, "")]
else
in
mk_preamble st what script
+and proc_case st what uri tyno u v ts =
+ let proceed, dtext = test_depth st in
+ let script = if proceed then
+ let synth, classes = I.S.empty, Cl.make ts in
+ let names = H.get_ind_names uri tyno in
+ let qs = proc_bkd_proofs (next st) synth names classes ts in
+ let lpsno, _ = H.get_ind_type uri tyno in
+ let ps, sort_disp = H.get_ind_parameters st.context (H.cic v) in
+ let _, rps = HEL.split_nth lpsno ps in
+ let rpsno = List.length rps in
+ let predicate = clear_absts rpsno (1 - sort_disp) u in
+ let e = Cn.mk_pattern rpsno predicate in
+ let text = "" in
+ let script = List.rev (mk_arg st v) in
+ script @ [T.Cases (v, e, dtext ^ text); T.Branch (qs, "")]
+ else
+ [T.Apply (what, dtext)]
+ in
+ mk_preamble st what script
+
and proc_other st what =
+ let _, dtext = test_depth st in
let text = Printf.sprintf "%s: %s" "UNEXPANDED" (string_of_head what) in
- let script = [T.Note text] in
+ let script = [T.Apply (what, dtext ^ text)] in
mk_preamble st what script
and proc_proof st t =
(Pp.ppterm (H.cic it)) (Pp.ppterm (H.cic et)))
| None -> None, "\nNo types"
in
- let context, clears = Cn.get_clears st.context (H.cic t) xtypes in
- let note = Pp.ppcontext st.context ^ note in
- {st with context = context; clears = clears; clears_note = note; }
+ let context, _clears = Cn.get_clears st.context (H.cic t) xtypes in
+ {st with context = context}
in
match t with
- | C.ALambda (_, name, w, t) as what -> proc_lambda (f st) what name w t
- | C.ALetIn (_, name, v, w, t) as what -> proc_letin (f st) what name v w t
- | C.ARel _ as what -> proc_rel (f st) what
- | C.AMutConstruct _ as what -> proc_mutconstruct (f st) what
- | C.AConst _ as what -> proc_const (f st) what
- | C.AAppl (_, hd :: tl) as what -> proc_appl (f st) what hd tl
- | what -> proc_other (f st) what
+ | C.ALambda (_, name, w, t) as what -> proc_lambda (f st) what name w t
+ | C.ALetIn (_, name, v, w, t) as what -> proc_letin (f st) what name v w t
+ | C.ARel _ as what -> proc_rel (f st) what
+ | C.AMutConstruct _ as what -> proc_mutconstruct (f st) what
+ | C.AConst _ as what -> proc_const (f st) what
+ | C.AAppl (_, hd :: tl) as what -> proc_appl (f st) what hd tl
+ | C.AMutCase (_, uri, i, u, v, ts) as what -> proc_case (f st) what uri i u v ts
+ | what -> proc_other (f st) what
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 =
if I.overlaps synth inv then None else
if I.S.is_empty inv then Some (get_note (fun st -> proc_proof st v)) else
- Some (fun _ -> [T.Apply (v, dtext ^ "dependent")])
+ Some (get_note (fun _ -> [T.Apply (v, dtext ^ "dependent")]))
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 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
- if st.skip_thm_and_qed then ast
- else T.Theorem (Some s, t, "") :: ast @ [T.Qed text]
- | _ ->
- failwith "not a theorem"
+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, "")]
+ | C.AInductiveDefinition (_, types, [], lpsno, attrs) ->
+ [T.Inductive (types, lpsno, "")]
+ | _ ->
+ failwith "not a theorem, definition, axiom or inductive type"
(* interface functions ******************************************************)
-let acic2procedural ~ids_to_inner_sorts ~ids_to_inner_types ?depth
-?(skip_thm_and_qed=false) prefix aobj =
+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;
- prefix = prefix;
max_depth = depth;
depth = 0;
context = [];
- clears = [];
- clears_note = "";
- case = [];
- skip_thm_and_qed = skip_thm_and_qed;
+ case = []
+ } in
+ L.time_stamp "P : LEVEL 2 ";
+ HLog.debug "Procedural: level 2 transformation";
+ let steps = proc_obj st ?flavour ?info anobj in
+ L.time_stamp "P : RENDERING";
+ HLog.debug "Procedural: grafite rendering";
+ 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 =
+ let st = {
+ sorts = ids_to_inner_sorts;
+ types = ids_to_inner_types;
+ max_depth = depth;
+ depth = 0;
+ context = context;
+ case = []
} in
HLog.debug "Procedural: level 2 transformation";
- let steps = proc_obj st aobj in
+ let steps = proc_proof st annterm in
HLog.debug "Procedural: grafite rendering";
List.rev (T.render_steps [] steps)
projects / helm.git / blobdiff