+++ /dev/null
-(* Copyright (C) 2000, HELM Team.
- *
- * This file is part of HELM, an Hypertextual, Electronic
- * Library of Mathematics, developed at the Computer Science
- * Department, University of Bologna, Italy.
- *
- * HELM is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * HELM is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HELM; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA.
- *
- * For details, see the HELM World-Wide-Web page,
- * http://cs.unibo.it/helm/.
- *)
-
-exception NotImplemented;;
-
-let fresh_id seed ids_to_terms ids_to_father_ids =
- fun father t ->
- let res = "i" ^ string_of_int !seed in
- incr seed ;
- Hashtbl.add ids_to_father_ids res father ;
- Hashtbl.add ids_to_terms res t ;
- res
-;;
-
-exception NotEnoughElements;;
-exception NameExpected;;
-
-(*CSC: cut&paste da cicPp.ml *)
-(* get_nth l n returns the nth element of the list l if it exists or *)
-(* raises NotEnoughElements if l has less than n elements *)
-let rec get_nth l n =
- match (n,l) with
- (1, he::_) -> he
- | (n, he::tail) when n > 1 -> get_nth tail (n-1)
- | (_,_) -> raise NotEnoughElements
-;;
-
-let acic_of_cic_context' seed ids_to_terms ids_to_father_ids ids_to_inner_sorts
- ids_to_inner_types metasenv context t
-=
- let module T = CicTypeChecker in
- let module C = Cic in
- let fresh_id' = fresh_id seed ids_to_terms ids_to_father_ids in
- let rec aux computeinnertypes father context tt =
- let fresh_id'' = fresh_id' father tt in
- let aux' = aux true (Some fresh_id'') in
- (* First of all we compute the inner type and the inner sort *)
- (* of the term. They may be useful in what follows. *)
- (*CSC: This is a very inefficient way of computing inner types *)
- (*CSC: and inner sorts: very deep terms have their types/sorts *)
- (*CSC: computed again and again. *)
- let string_of_sort =
- function
- C.Sort C.Prop -> "Prop"
- | C.Sort C.Set -> "Set"
- | C.Sort C.Type -> "Type"
- | _ -> assert false
- in
- let ainnertype,innertype,innersort =
-(*CSC: Here we need the algorithm for Coscoy's double type-inference *)
-(*CSC: (expected type + inferred type). Just for now we use the usual *)
-(*CSC: type-inference, but the result is very poort. As a very weak *)
-(*CSC: patch, I apply whd to the computed type. Full beta *)
-(*CSC: reduction would be a much better option. *)
- let innertype =
- CicReduction.whd context (T.type_of_aux' metasenv context tt)
- in
- let innersort = T.type_of_aux' metasenv context innertype in
- let ainnertype =
- if computeinnertypes then
- Some (aux false (Some fresh_id'') context innertype)
- else
- None
- in
- ainnertype, innertype, string_of_sort innersort
- in
- let add_inner_type id =
- match ainnertype with
- None -> ()
- | Some ainnertype -> Hashtbl.add ids_to_inner_types id ainnertype
- in
- match tt with
- C.Rel n ->
- let id =
- match get_nth context n with
- (Some (C.Name s,_)) -> s
- | _ -> raise NameExpected
- in
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- C.ARel (fresh_id'', n, id)
- | C.Var uri ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- C.AVar (fresh_id'', uri)
- | C.Meta (n,l) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- C.AMeta (fresh_id'', n,
- (List.map
- (function None -> None | Some t -> Some (aux' context t)) l))
- | C.Sort s -> C.ASort (fresh_id'', s)
- | C.Implicit -> C.AImplicit (fresh_id'')
- | C.Cast (v,t) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- if innersort = "Prop" then
- add_inner_type fresh_id'' ;
- C.ACast (fresh_id'', aux' context v, aux' context t)
- | C.Prod (n,s,t) ->
- Hashtbl.add ids_to_inner_sorts fresh_id''
- (string_of_sort innertype) ;
- C.AProd
- (fresh_id'', n, aux' context s,
- aux' ((Some (n, C.Decl s))::context) t)
- | C.Lambda (n,s,t) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- if innersort = "Prop" then
- begin
- let father_is_lambda =
- match father with
- None -> false
- | Some father' ->
- match Hashtbl.find ids_to_terms father' with
- C.Lambda _ -> true
- | _ -> false
- in
- if not father_is_lambda then
- add_inner_type fresh_id''
- end ;
- C.ALambda
- (fresh_id'',n, aux' context s,
- aux' ((Some (n, C.Decl s)::context)) t)
- | C.LetIn (n,s,t) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- C.ALetIn
- (fresh_id'', n, aux' context s,
- aux' ((Some (n, C.Def s))::context) t)
- | C.Appl l ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- if innersort = "Prop" then
- add_inner_type fresh_id'' ;
- C.AAppl (fresh_id'', List.map (aux' context) l)
- | C.Const (uri,cn) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- C.AConst (fresh_id'', uri, cn)
- | C.Abst _ -> raise NotImplemented
- | C.MutInd (uri,cn,tyno) -> C.AMutInd (fresh_id'', uri, cn, tyno)
- | C.MutConstruct (uri,cn,tyno,consno) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- C.AMutConstruct (fresh_id'', uri, cn, tyno, consno)
- | C.MutCase (uri, cn, tyno, outty, term, patterns) ->
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- if innersort = "Prop" then
- add_inner_type fresh_id'' ;
- C.AMutCase (fresh_id'', uri, cn, tyno, aux' context outty,
- aux' context term, List.map (aux' context) patterns)
- | C.Fix (funno, funs) ->
- let tys =
- List.map (fun (name,_,ty,_) -> Some (C.Name name, C.Decl ty)) funs
- in
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- if innersort = "Prop" then
- add_inner_type fresh_id'' ;
- C.AFix (fresh_id'', funno,
- List.map
- (fun (name, indidx, ty, bo) ->
- (name, indidx, aux' context ty, aux' (tys@context) bo)
- ) funs
- )
- | C.CoFix (funno, funs) ->
- let tys =
- List.map (fun (name,ty,_) -> Some (C.Name name, C.Decl ty)) funs in
- Hashtbl.add ids_to_inner_sorts fresh_id'' innersort ;
- if innersort = "Prop" then
- add_inner_type fresh_id'' ;
- C.ACoFix (fresh_id'', funno,
- List.map
- (fun (name, ty, bo) ->
- (name, aux' context ty, aux' (tys@context) bo)
- ) funs
- )
- in
- aux true None context t
-;;
-
-let acic_of_cic_context metasenv context t =
- let ids_to_terms = Hashtbl.create 503 in
- let ids_to_father_ids = Hashtbl.create 503 in
- let ids_to_inner_sorts = Hashtbl.create 503 in
- let ids_to_inner_types = Hashtbl.create 503 in
- let seed = ref 0 in
- acic_of_cic_context' seed ids_to_terms ids_to_father_ids ids_to_inner_sorts
- ids_to_inner_types metasenv context t,
- ids_to_terms, ids_to_father_ids, ids_to_inner_sorts, ids_to_inner_types
-;;
-
-exception Found of (Cic.name * Cic.context_entry) list;;
-
-let acic_object_of_cic_object obj =
- let module C = Cic in
- let ids_to_terms = Hashtbl.create 503 in
- let ids_to_father_ids = Hashtbl.create 503 in
- let ids_to_inner_sorts = Hashtbl.create 503 in
- let ids_to_inner_types = Hashtbl.create 503 in
- let ids_to_conjectures = Hashtbl.create 11 in
- let ids_to_hypotheses = Hashtbl.create 127 in
- let hypotheses_seed = ref 0 in
- let conjectures_seed = ref 0 in
- let seed = ref 0 in
- let acic_term_of_cic_term_context' =
- acic_of_cic_context' seed ids_to_terms ids_to_father_ids ids_to_inner_sorts
- ids_to_inner_types in
- let acic_term_of_cic_term' = acic_term_of_cic_term_context' [] [] in
- let aobj =
- match obj with
- C.Definition (id,bo,ty,params) ->
- let abo = acic_term_of_cic_term' bo in
- let aty = acic_term_of_cic_term' ty
- in
- C.ADefinition ("mettereaposto",id,abo,aty,(Cic.Actual params))
- | C.Axiom (id,ty,params) -> raise NotImplemented
- | C.Variable (id,bo,ty) -> raise NotImplemented
- | C.CurrentProof (id,conjectures,bo,ty) ->
- let aconjectures =
- List.map
- (function (i,canonical_context,term) as conjecture ->
- let cid = "c" ^ string_of_int !conjectures_seed in
- Hashtbl.add ids_to_conjectures cid conjecture ;
- incr conjectures_seed ;
- let acanonical_context =
- let rec aux =
- function
- [] -> []
- | hyp::tl ->
- let hid = "h" ^ string_of_int !hypotheses_seed in
- Hashtbl.add ids_to_hypotheses hid hyp ;
- incr hypotheses_seed ;
- match hyp with
- (Some (n,C.Decl t)) ->
- let at =
- acic_term_of_cic_term_context' conjectures tl t
- in
- (hid,Some (n,C.ADecl at))::(aux tl)
- | (Some (n,C.Def t)) ->
- let at =
- acic_term_of_cic_term_context' conjectures tl t
- in
- (hid,Some (n,C.ADef at))::(aux tl)
- | None -> (hid,None)::(aux tl)
- in
- aux canonical_context
- in
- let aterm =
- acic_term_of_cic_term_context' conjectures canonical_context term
- in
- (cid,i,acanonical_context,aterm)
- ) conjectures in
- let abo = acic_term_of_cic_term_context' conjectures [] bo in
- let aty = acic_term_of_cic_term_context' conjectures [] ty in
- C.ACurrentProof ("mettereaposto",id,aconjectures,abo,aty)
- | C.InductiveDefinition (tys,params,paramsno) -> raise NotImplemented
- in
- aobj,ids_to_terms,ids_to_father_ids,ids_to_inner_sorts,ids_to_inner_types,
- ids_to_conjectures,ids_to_hypotheses
-;;
projects / helm.git / blobdiff