- 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
- try match Hashtbl.find st.types id with
- | {A.annsynthesized = st; A.annexpected = Some et} -> Some (st, et)
- | {A.annsynthesized = st; A.annexpected = None} -> Some (st, st)
- with Not_found -> None
-with Invalid_argument _ -> failwith "A2P.get_inner_types"
-
-let get_inner_sort st v =
-try
- let id = Ut.id_of_annterm v in
- try Hashtbl.find st.sorts id
- 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 (cic bo) Un.empty_ugraph in
- ty
-with e -> failwith (msg ^ ": " ^ Printexc.to_string e)
-
-(* proof construction *******************************************************)
-
-let unused_premise = "UNUSED"
-
-let convert st ?name v =
- match get_inner_types st v with
- | None -> []
- | Some (st, et) ->
- let cst, cet = cic st, cic et in
- if PER.alpha_equivalence cst cet then [] else
- let e = Cn.mk_pattern 0 (T.mk_arel 1 "") in
- match name with
- | None -> [T.Change (st, et, None, e, "")]
- | Some id -> [T.Change (st, et, Some (id, id), e, ""); T.ClearBody (id, "")]
-
-let get_intro = function
- | C.Anonymous -> unused_premise
- | C.Name s -> s
-
-let mk_intros st script =
-try
- if st.intros = [] then script else
- let count = List.length st.intros in
- T.Intros (Some count, List.rev st.intros, "") :: script
-with Invalid_argument _ -> failwith "A2P.mk_intros"
-
-let rec mk_arg st = function
- | C.ARel (_, _, _, name) as what -> convert st ~name what, what
- | what -> [], what
-
-and mk_fwd_rewrite st dtext name tl direction =
- assert (List.length tl = 6);
- let what, where, predicate = List.nth tl 5, List.nth tl 3, List.nth tl 2 in
- let e = Cn.mk_pattern 1 predicate in
- match where with
- | C.ARel (_, _, _, premise) ->
- let script, what = mk_arg st what in
- T.Rewrite (direction, what, Some (premise, name), e, dtext) :: script
- | _ -> assert false
-
-and mk_rewrite st dtext script t what qs tl direction =
- assert (List.length tl = 5);
- let predicate = List.nth tl 2 in
- let e = Cn.mk_pattern 1 predicate in
- List.rev script @ convert st t @
- [T.Rewrite (direction, what, None, e, dtext); T.Branch (qs, "")]
-
-and mk_fwd_proof st dtext name = function
- | C.AAppl (_, hd :: tl) as v ->
- if is_fwd_rewrite_right hd tl then mk_fwd_rewrite st dtext name tl true else
- if is_fwd_rewrite_left hd tl then mk_fwd_rewrite st dtext name tl false else
- let ty = get_type "TC1" st hd in
- begin match get_inner_types st v with
- | Some (ity, _) ->
- let qs = [[T.Id ""]; mk_proof (next st) v] in
- [T.Branch (qs, ""); T.Cut (name, ity, dtext)]
- | _ ->
- let (classes, rc) as h = Cl.classify st.context ty in
- let text = Printf.sprintf "%u %s" (List.length classes) (Cl.to_string h) in
- [T.LetIn (name, v, dtext ^ text)]
- end
- | C.AMutCase _ -> assert false
- | C.ACast _ -> assert false
- | v ->
- match get_inner_types st v with
- | Some (ity, _) ->
- let qs = [[T.Id ""]; mk_proof (next st) v] in
- [T.Branch (qs, ""); T.Cut (name, ity, dtext)]
- | _ ->
- [T.LetIn (name, v, dtext)]
-
-and mk_proof st = function
- | C.ALambda (_, name, v, t) ->
- let entry = Some (name, C.Decl (cic v)) in
- let intro = get_intro name in
- mk_proof (add st entry intro) t
- | C.ALetIn (_, name, v, t) as what ->
- let proceed, dtext = test_depth st in
- let script = if proceed then
- let entry = Some (name, C.Def (cic v, None)) in
- let intro = get_intro name in
- let q = mk_proof (next (add st entry intro)) t in
- List.rev_append (mk_fwd_proof st dtext intro v) q
- else
- [T.Apply (what, dtext)]
- in
- mk_intros st script
- | C.ARel _ as what ->
- let _, dtext = test_depth st in
- let text = "assumption" in
- let script = [T.Apply (what, dtext ^ text)] in
- mk_intros st script
- | C.AMutConstruct _ as what ->
- let _, dtext = test_depth st in
- let script = [T.Apply (what, dtext)] in
- mk_intros st script
- | C.AAppl (_, hd :: tl) as t ->
- 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 decurry = List.length classes - List.length tl in
- if decurry <> 0 then begin
- let msg = Printf.sprintf "Decurry: %i\nTerm: %s\nContext: %s"
- decurry (Pp.ppterm (cic t)) (Pp.ppcontext st.context)