| C.ACoFix (id,_,_) -> id
;;
-let test_for_lifting ~ids_to_inner_types =
+let test_for_lifting ~ids_to_inner_types ~ids_to_inner_sorts=
let module C = Cic in
let module C2A = Cic2acic in
(* atomic terms are never lifted, according to my policy *)
function
C.ARel (id,_,_,_) -> false
- | C.AVar (id,_,_) -> false
- | C.AMeta (id,_,_) -> false
+ | C.AVar (id,_,_) ->
+ (try
+ ignore (Hashtbl.find ids_to_inner_types id).C2A.annsynthesized;
+ true;
+ with Not_found -> false)
+ | C.AMeta (id,_,_) ->
+ (try
+ Hashtbl.find ids_to_inner_sorts id = "Prop"
+ with Not_found -> assert false)
| C.ASort (id,_) -> false
| C.AImplicit _ -> raise NotImplemented
| C.AProd (id,_,_,_) -> false
with Not_found -> false)
;;
+(*
let build_args seed l subproofs ~ids_to_inner_types ~ids_to_inner_sorts =
let module C = Cic in
let module K = Content in
- let rec aux l subrpoofs =
+ let rec aux l subproofs =
match l with
[] -> []
| t::l1 ->
hd::(aux l1 subproofs)
in aux l subproofs
;;
+*)
(* transform a proof p into a proof list, concatenating the last
conclude element to the apply_context list, in case context is
let rec serialize seed =
function
- [] -> []
- | p::tl -> (flat seed p)@(serialize seed tl);;
+ [] -> []
+ | a::l -> (flat seed a)@(serialize seed l)
+;;
(* top_down = true if the term is a LAMBDA or a decl *)
let generate_conversion seed top_down id inner_proof ~ids_to_inner_types =
Not_found -> assert false
;;
-let rec build_def_item seed id n t ~ids_to_inner_sorts ~ids_to_inner_types =
+let rec build_subproofs_and_args seed l ~ids_to_inner_types ~ids_to_inner_sorts =
+ let module C = Cic in
+ let module K = Content in
+ let rec aux =
+ function
+ [] -> [],[]
+ | t::l1 ->
+ let subproofs,args = aux l1 in
+ if (test_for_lifting t ~ids_to_inner_types ~ids_to_inner_sorts) then
+ let new_subproof =
+ acic2content
+ seed ~name:"H" ~ids_to_inner_types ~ids_to_inner_sorts t in
+ let new_arg =
+ K.Premise
+ { K.premise_id = gen_id seed;
+ K.premise_xref = new_subproof.K.proof_id;
+ K.premise_binder = new_subproof.K.proof_name;
+ K.premise_n = None
+ } in
+ new_subproof::subproofs,new_arg::args
+ else
+ let hd =
+ (match t with
+ C.ARel (idr,idref,n,b) ->
+ let sort =
+ (try Hashtbl.find ids_to_inner_sorts idr
+ with Not_found -> "Type") in
+ if sort ="Prop" then
+ K.Premise
+ { K.premise_id = gen_id seed;
+ K.premise_xref = idr;
+ K.premise_binder = Some b;
+ K.premise_n = Some n
+ }
+ else (K.Term t)
+ | C.AConst(id,uri,[]) ->
+ let sort =
+ (try Hashtbl.find ids_to_inner_sorts id
+ with Not_found -> "Type") in
+ if sort ="Prop" then
+ K.Lemma
+ { K.lemma_id = gen_id seed;
+ K.lemma_name = UriManager.name_of_uri uri;
+ K.lemma_uri = UriManager.string_of_uri uri
+ }
+ else (K.Term t)
+ | C.AMutConstruct(id,uri,tyno,consno,[]) ->
+ let sort =
+ (try Hashtbl.find ids_to_inner_sorts id
+ with Not_found -> "Type") in
+ if sort ="Prop" then
+ let inductive_types =
+ (match CicEnvironment.get_obj uri with
+ Cic.Constant _ -> assert false
+ | Cic.Variable _ -> assert false
+ | Cic.CurrentProof _ -> assert false
+ | Cic.InductiveDefinition (l,_,_) -> l
+ ) in
+ let (_,_,_,constructors) =
+ List.nth inductive_types tyno in
+ let name,_ = List.nth constructors (consno - 1) in
+ K.Lemma
+ { K.lemma_id = gen_id seed;
+ K.lemma_name = name;
+ K.lemma_uri =
+ UriManager.string_of_uri uri ^ "#xpointer(1/" ^
+ string_of_int (tyno+1) ^ "/" ^ string_of_int consno ^
+ ")"
+ }
+ else (K.Term t)
+ | _ -> (K.Term t)) in
+ subproofs,hd::args
+ in
+ match (aux l) with
+ [p],args ->
+ [{p with K.proof_name = None}],
+ List.map
+ (function
+ K.Premise prem when prem.K.premise_xref = p.K.proof_id ->
+ K.Premise {prem with K.premise_binder = None}
+ | i -> i) args
+ | p,a as c -> c
+
+and
+
+build_def_item seed id n t ~ids_to_inner_sorts ~ids_to_inner_types =
let module K = Content in
try
let sort = Hashtbl.find ids_to_inner_sorts id in
else proof in
let proof'' =
{ proof' with
- K.proof_name = name;
+ K.proof_name = None;
K.proof_context =
((build_def_item seed id n s ids_to_inner_sorts
ids_to_inner_types):> Cic.annterm K.in_proof_context_element)
else raise Not_a_proof
| C.AAppl (id,li) ->
(try rewrite
- seed name id li ids_to_inner_types ids_to_inner_sorts
+ seed name id li ~ids_to_inner_types ~ids_to_inner_sorts
with NotApplicable ->
try inductive
- seed name id li ids_to_inner_types ids_to_inner_sorts
+ seed name id li ~ids_to_inner_types ~ids_to_inner_sorts
with NotApplicable ->
+ let subproofs, args =
+ build_subproofs_and_args
+ seed li ~ids_to_inner_types ~ids_to_inner_sorts in
+(*
let args_to_lift =
List.filter (test_for_lifting ~ids_to_inner_types) li in
let subproofs =
[_] -> List.map aux args_to_lift
| _ -> List.map (aux ~name:"H") args_to_lift in
let args = build_args seed li subproofs
- ~ids_to_inner_types ~ids_to_inner_sorts in
+ ~ids_to_inner_types ~ids_to_inner_sorts in *)
{ K.proof_name = name;
K.proof_id = gen_id seed;
K.proof_context = [];
let pp = List.map2
(fun p (name,_) -> (K.ArgProof (aux ~name p)))
patterns constructors in
- let apply_context,term =
+ let context,term =
(match
- (try Some (Hashtbl.find ids_to_inner_types teid).C2A.annsynthesized
- with Not_found -> None)
+ build_subproofs_and_args
+ seed ~ids_to_inner_types ~ids_to_inner_sorts [te]
with
- Some tety ->
- let p = (aux te) in
- (flat seed p,
- K.Premise
- { K.premise_id = gen_id seed;
- K.premise_xref = p.K.proof_id;
- K.premise_binder = p.K.proof_name;
- K.premise_n = None
- })
- | None -> [],K.Term te) in
+ l,[t] -> l,t
+ | _ -> assert false) in
{ K.proof_name = name;
K.proof_id = gen_id seed;
K.proof_context = [];
- K.proof_apply_context = apply_context;
+ K.proof_apply_context = serialize seed context;
K.proof_conclude =
{ K.conclude_id = gen_id seed;
K.conclude_aref = id;
generate_conversion seed false id t1 ~ids_to_inner_types
in aux ?name t
-and inductive seed name id li ids_to_inner_types ids_to_inner_sorts =
+and inductive seed name id li ~ids_to_inner_types ~ids_to_inner_sorts =
let aux ?name = acic2content seed ~ids_to_inner_types ~ids_to_inner_sorts in
let module C2A = Cic2acic in
let module K = Content in
let no_constructors= List.length constructors in
let args_for_cases, other_args =
split no_constructors tail_args in
- let args_to_lift =
- List.filter (test_for_lifting ~ids_to_inner_types) other_args in
- let subproofs =
- match args_to_lift with
- [_] -> List.map aux args_to_lift
- | _ -> List.map (aux ~name:"H") args_to_lift in
- prerr_endline "****** end subproofs *******"; flush stderr;
- let other_method_args =
- build_args seed other_args subproofs
+ let subproofs,other_method_args =
+ build_subproofs_and_args seed other_args
~ids_to_inner_types ~ids_to_inner_sorts in
-(*
- let rparams,inductive_arg =
- let rec aux =
- function
- [] -> assert false
- | [ia] -> [],ia
- | a::tl -> let (p,ia) = aux tl in (a::p,ia) in
- aux other_method_args in
-*)
prerr_endline "****** end other *******"; flush stderr;
let method_args=
let rec build_method_args =
{ K.proof_name = None;
K.proof_id = gen_id seed;
K.proof_context = [];
- K.proof_apply_context = subproofs;
+ K.proof_apply_context = serialize seed subproofs;
K.proof_conclude =
{ K.conclude_id = gen_id seed;
K.conclude_aref = id;
}
| _ -> raise NotApplicable
-and rewrite seed name id li ids_to_inner_types ids_to_inner_sorts =
+and rewrite seed name id li ~ids_to_inner_types ~ids_to_inner_sorts =
let aux ?name = acic2content seed ~ids_to_inner_types ~ids_to_inner_sorts in
let module C2A = Cic2acic in
let module K = Content in
let uri_str = UriManager.string_of_uri uri in
if uri_str = "cic:/Coq/Init/Logic/eq_ind.con" or
uri_str = "cic:/Coq/Init/Logic/eq_ind_r.con" then
- let subproof = aux (List.nth args 3) in
+ let subproofs,arg =
+ (match
+ build_subproofs_and_args
+ seed ~ids_to_inner_types ~ids_to_inner_sorts [List.nth args 3]
+ with
+ l,[p] -> l,p
+ | _,_ -> assert false) in
let method_args =
let rec ma_aux n = function
[] -> []
| a::tl ->
let hd =
- if n = 0 then
- K.Premise
- { K.premise_id = gen_id seed;
- K.premise_xref = subproof.K.proof_id;
- K.premise_binder = None;
- K.premise_n = None
- }
+ if n = 0 then arg
else
let aid = get_id a in
let asort = (try (Hashtbl.find ids_to_inner_sorts aid)
{ K.proof_name = None;
K.proof_id = gen_id seed;
K.proof_context = [];
- K.proof_apply_context = [subproof];
+ K.proof_apply_context = serialize seed subproofs;
K.proof_conclude =
{ K.conclude_id = gen_id seed;
K.conclude_aref = id;
projects / helm.git / blobdiff