X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Facic_procedural%2Facic2Procedural.ml;h=18e1ecc5b3826b5a287bf3cd13f14c6fc443993a;hb=d3d4ea54cb895a1adc6cb327df42e1394b3f2bea;hp=fb99090e98b76df165c3cbd8244ee17fb70c1601;hpb=b4027b84fae91e907b6874060b91d89b6a1ad780;p=helm.git diff --git a/helm/software/components/acic_procedural/acic2Procedural.ml b/helm/software/components/acic_procedural/acic2Procedural.ml index fb99090e9..18e1ecc5b 100644 --- a/helm/software/components/acic_procedural/acic2Procedural.ml +++ b/helm/software/components/acic_procedural/acic2Procedural.ml @@ -26,6 +26,7 @@ module C = Cic module I = CicInspect module D = Deannotate +module S = CicSubstitution module TC = CicTypeChecker module Un = CicUniv module UM = UriManager @@ -34,12 +35,15 @@ module HObj = HelmLibraryObjects module A = Cic2acic module Ut = CicUtil module E = CicEnvironment -module PEH = ProofEngineHelpers module Pp = CicPp +module PEH = ProofEngineHelpers +module HEL = HExtlib +module DTI = DoubleTypeInference module Cl = ProceduralClassify module T = ProceduralTypes module Cn = ProceduralConversion +module H = ProceduralHelpers type status = { sorts : (C.id, A.sort_kind) Hashtbl.t; @@ -48,7 +52,10 @@ type status = { max_depth: int option; depth: int; context: C.context; - intros: string list + intros: string option list; + clears: string list; + clears_note: string; + case: int list } (* helpers ******************************************************************) @@ -58,11 +65,11 @@ let cic = D.deannotate_term let split2_last l1 l2 = try let n = pred (List.length l1) in - let before1, after1 = T.list_split n l1 in - let before2, after2 = T.list_split n l2 in + let before1, after1 = HEL.split_nth n l1 in + let before2, after2 = HEL.split_nth n l2 in before1, before2, List.hd after1, List.hd after2 with Invalid_argument _ -> failwith "A2P.split2_last" - + let string_of_head = function | C.ASort _ -> "sort" | C.AConst _ -> "const" @@ -88,6 +95,18 @@ let next st = {(clear st) with depth = succ st.depth} let add st entry intro = {st with context = entry :: st.context; intros = intro :: st.intros} +let push st = {st with case = 1 :: st.case} + +let inc st = + {st with case = match st.case with + | [] -> assert false + | hd :: tl -> succ hd :: tl + } + +let case st str = + let case = String.concat "." (List.rev_map string_of_int st.case) in + Printf.sprintf "case %s: %s" case str + let test_depth st = try let msg = Printf.sprintf "Depth %u: " st.depth in @@ -117,21 +136,7 @@ let is_fwd_rewrite_left hd tl = | C.ARel _ -> true | _ -> false else false -(* -let get_ind_name uri tno xcno = -try - let ts = match E.get_obj Un.empty_ugraph uri with - | C.InductiveDefinition (ts, _, _,_), _ -> ts - | _ -> assert false - in - let tname, cs = match List.nth ts tno with - | (name, _, _, cs) -> name, cs - in - match xcno with - | None -> tname - | Some cno -> fst (List.nth cs (pred cno)) -with Invalid_argument _ -> failwith "A2P.get_ind_name" -*) + let get_inner_types st v = try let id = Ut.id_of_annterm v in @@ -161,21 +166,31 @@ let get_entry st id = | _ :: tl -> aux tl in aux st.context - + +let get_ind_names uri tno = +try + let ts = match E.get_obj Un.empty_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" + (* proof construction *******************************************************) -let unused_premise = "UNUSED" +let used_premise = C.Name "USED" -let mk_exp_args hd tl classes = +let mk_exp_args hd tl classes synth = let meta id = C.AImplicit (id, None) in let map v (cl, b) = - if I.S.mem 0 cl && b then v else meta "" + if I.overlaps synth cl && b then v else meta "" in let rec aux = function | [] -> [] | hd :: tl -> if hd = meta "" then aux tl else List.rev (hd :: tl) in - let args = List.rev_map2 map tl classes in + let args = T.list_rev_map2 map tl classes in let args = aux args in if args = [] then hd else C.AAppl ("", hd :: args) @@ -183,30 +198,39 @@ let convert st ?name v = match get_inner_types st v with | None -> [] | Some (sty, ety) -> + let e = Cn.hole "" in let csty, cety = cic sty, cic ety in if Ut.alpha_equivalence csty cety then [] else - let e = Cn.mk_pattern 0 (T.mk_arel 1 "") in match name with - | None -> [T.Change (sty, ety, None, e, "")] - | Some id -> + | None -> [T.Change (sty, ety, None, e, "")] + | Some (id, i) -> begin match get_entry st id with | C.Def _ -> [T.ClearBody (id, "")] | C.Decl w -> - if Ut.alpha_equivalence csty w then [] - else [T.Change (sty, ety, Some (id, id), e, "")] + let w = S.lift i w in + if Ut.alpha_equivalence csty w then [] + else + [T.Note (Pp.ppterm csty); T.Note (Pp.ppterm w); + T.Change (sty, ety, Some (id, Some id), e, "")] end let get_intro = function - | C.Anonymous -> unused_premise - | C.Name s -> s + | C.Anonymous -> None + | C.Name s -> Some s let mk_intros st script = - if st.intros = [] then script else - let count = List.length st.intros in - T.Intros (Some count, List.rev st.intros, "") :: script + let intros st script = + if st.intros = [] then script else + let count = List.length st.intros in + T.Intros (Some count, List.rev st.intros, "") :: script + in + let clears st script = + if st.clears = [] then script else T.Clear (st.clears, st.clears_note) :: script + in + intros st (clears st script) let mk_arg st = function - | C.ARel (_, _, _, name) as what -> convert st ~name what + | C.ARel (_, _, i, name) as what -> convert st ~name:(name, i) what | _ -> [] let mk_fwd_rewrite st dtext name tl direction = @@ -217,7 +241,8 @@ let mk_fwd_rewrite st dtext name tl direction = | C.ARel (_, _, _, premise) -> let script = mk_arg st what in let where = Some (premise, name) in - T.Rewrite (direction, what, where, e, dtext) :: script + let st = {st with context = Cn.clear st.context premise} in + st, T.Rewrite (direction, what, where, e, dtext) :: script | _ -> assert false let mk_rewrite st dtext what qs tl direction = @@ -227,6 +252,17 @@ let mk_rewrite st dtext what qs tl direction = [T.Rewrite (direction, what, None, e, dtext); T.Branch (qs, "")] let rec proc_lambda st name v t = + let dno = DTI.does_not_occur 1 (cic t) in + let dno = dno && match get_inner_types st t with + | None -> true + | Some (it, et) -> + DTI.does_not_occur 1 (cic it) && DTI.does_not_occur 1 (cic et) + in + let name = match dno, name with + | true, _ -> C.Anonymous + | false, C.Anonymous -> H.mk_fresh_name st.context used_premise + | false, name -> name + in let entry = Some (name, C.Decl (cic v)) in let intro = get_intro name in proc_proof (add st entry intro) t @@ -235,20 +271,20 @@ and proc_letin st what name v t = let intro = get_intro name in let proceed, dtext = test_depth st in let script = if proceed then - let hyp, rqv = match get_inner_types st v with + let st, hyp, rqv = match get_inner_types st v with | Some (ity, _) -> - let rqv = match v with + let st, rqv = match v with | C.AAppl (_, hd :: tl) when is_fwd_rewrite_right hd tl -> mk_fwd_rewrite st dtext intro tl true | C.AAppl (_, hd :: tl) when is_fwd_rewrite_left hd tl -> mk_fwd_rewrite st dtext intro tl false | v -> - let qs = [[T.Id ""]; proc_proof (next st) v] in - [T.Branch (qs, ""); T.Cut (intro, ity, dtext)] + let qs = [proc_proof (next st) v; [T.Id ""]] in + st, [T.Branch (qs, ""); T.Cut (intro, ity, dtext)] in - C.Decl (cic ity), rqv + st, C.Decl (cic ity), rqv | None -> - C.Def (cic v, None), [T.LetIn (intro, v, dtext)] + st, C.Def (cic v, None), [T.LetIn (intro, v, dtext)] in let entry = Some (name, hyp) in let qt = proc_proof (next (add st entry intro)) t in @@ -273,32 +309,41 @@ 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 (classes, rc) as h = Cl.classify st.context ty in - let argsno = List.length classes in - let diff = argsno - List.length tl in - if diff <> 0 then failwith (Printf.sprintf "NOT TOTAL: %i %s |--- %s" diff (Pp.ppcontext st.context) (Pp.ppterm (cic hd))); - let synth = I.S.singleton 0 in - let text = Printf.sprintf "%u %s" argsno (Cl.to_string h) in + let classes, rc = Cl.classify st.context ty in + let goal_arity = match get_inner_types st what with + | None -> 0 + | Some (ity, _) -> snd (PEH.split_with_whd (st.context, cic ity)) + in + let parsno, argsno = List.length classes, List.length tl in + let decurry = parsno - argsno in + let diff = goal_arity - decurry in + if diff < 0 then failwith (Printf.sprintf "NOT TOTAL: %i %s |--- %s" diff (Pp.ppcontext st.context) (Pp.ppterm (cic hd))); + let rec mk_synth a n = + if n < 0 then a else mk_synth (I.S.add n a) (pred n) + in + let synth = mk_synth I.S.empty decurry in + let text = "" (* Printf.sprintf "%u %s" parsno (Cl.to_string h) *) in let script = List.rev (mk_arg st hd) @ convert st what in match rc with - | Some (i, j) -> + | Some (i, j, uri, tyno) -> let classes, tl, _, where = split2_last classes tl in let script = List.rev (mk_arg st where) @ script in let synth = I.S.add 1 synth in - let qs = proc_bkd_proofs (next st) synth classes tl in + let names = get_ind_names uri tyno in + let qs = proc_bkd_proofs (next st) synth names classes tl in if is_rewrite_right hd then script @ mk_rewrite st dtext where qs tl false else if is_rewrite_left hd then script @ mk_rewrite st dtext where qs tl true else - let predicate = List.nth tl (argsno - i) in - let e = Cn.mk_pattern 0 (T.mk_arel 1 "") (* j predicate *) in + let predicate = List.nth tl (parsno - i) in + let e = Cn.mk_pattern j predicate in let using = Some hd in script @ [T.Elim (where, using, e, dtext ^ text); T.Branch (qs, "")] | None -> - let qs = proc_bkd_proofs (next st) synth classes tl in - let hd = mk_exp_args hd tl classes in + let qs = proc_bkd_proofs (next st) synth [] classes tl in + let hd = mk_exp_args hd tl classes synth in script @ [T.Apply (hd, dtext ^ text); T.Branch (qs, "")] else [T.Apply (what, dtext)] @@ -310,25 +355,50 @@ and proc_other st what = let script = [T.Note text] in mk_intros st script - -and proc_proof st = function - | C.ALambda (_, name, w, t) -> proc_lambda st name w t - | C.ALetIn (_, name, v, t) as what -> proc_letin st what name v t - | C.ARel _ as what -> proc_rel st what - | C.AMutConstruct _ as what -> proc_mutconstruct st what - | C.AAppl (_, hd :: tl) as what -> proc_appl st what hd tl - | what -> proc_other st what - -and proc_bkd_proofs st synth classes ts = +and proc_proof st t = + let f st = + let xtypes, note = match get_inner_types st t with + | Some (it, et) -> Some (cic it, cic et), + (Printf.sprintf "\nInferred: %s\nExpected: %s" + (Pp.ppterm (cic it)) (Pp.ppterm (cic et))) + | None -> None, "\nNo types" + in + let context, clears = Cn.get_clears st.context (cic t) xtypes in + let note = Pp.ppcontext st.context ^ note in + {st with context = context; clears = clears; clears_note = note} + in + match t with + | C.ALambda (_, name, w, t) -> proc_lambda st name w t + | C.ALetIn (_, name, v, t) as what -> proc_letin (f st) what name v t + | C.ARel _ as what -> proc_rel (f st) what + | C.AMutConstruct _ as what -> proc_mutconstruct (f st) what + | C.AAppl (_, hd :: tl) as what -> proc_appl (f st) what hd tl + | 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 + 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 (proc_proof st v) else - Some [T.Apply (v, dtext ^ "dependent")] - in - T.list_map2_filter aux classes ts -with Invalid_argument _ -> failwith "A2P.proc_bkd_proofs" + if I.S.is_empty inv then Some (get_note (fun st -> proc_proof st v)) else + Some (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 + +with Invalid_argument s -> failwith ("A2P.proc_bkd_proofs: " ^ s) (* object costruction *******************************************************) @@ -341,7 +411,7 @@ let proc_obj st = function let ast = proc_proof st v in let count = T.count_steps 0 ast in let text = Printf.sprintf "tactics: %u" count in - T.Theorem (s, t, text) :: ast @ [T.Qed ""] + T.Theorem (Some s, t, "") :: ast @ [T.Qed text] | _ -> failwith "not a theorem" @@ -349,13 +419,16 @@ let proc_obj st = function let acic2procedural ~ids_to_inner_sorts ~ids_to_inner_types ?depth prefix aobj = let st = { - sorts = ids_to_inner_sorts; - types = ids_to_inner_types; - prefix = prefix; - max_depth = depth; - depth = 0; - context = []; - intros = [] + sorts = ids_to_inner_sorts; + types = ids_to_inner_types; + prefix = prefix; + max_depth = depth; + depth = 0; + context = []; + intros = []; + clears = []; + clears_note = ""; + case = [] } in HLog.debug "Procedural: level 2 transformation"; let steps = proc_obj st aobj in