exception ListTooShort;;
exception RelToHiddenHypothesis;;
+let syntactic_equality_add_time = ref 0.0;;
let type_of_aux'_add_time = ref 0.0;;
let number_new_type_of_aux'_double_work = ref 0;;
let number_new_type_of_aux' = ref 0;;
| C.Rel _
| C.Meta _
| C.Sort _
- | C.Implicit -> true
+ | C.Implicit _ -> true
| C.Cast (te,ty) ->
does_not_occur n te && does_not_occur n ty
| C.Prod (name,so,dest) ->
(function None -> None | Some t -> Some (head_beta_reduce t)) l
)
| C.Sort _ as t -> t
- | C.Implicit -> assert false
+ | C.Implicit _ -> assert false
| C.Cast (te,ty) ->
C.Cast (head_beta_reduce te, head_beta_reduce ty)
| C.Prod (n,s,t) ->
_ -> false
;;
+let xxx_syntactic_equality t t' =
+ let t1 = Sys.time () in
+ let res = syntactic_equality t t' in
+ let t2 = Sys.time () in
+ syntactic_equality_add_time := !syntactic_equality_add_time +. t2 -. t1 ;
+ res
+;;
+
+
let rec split l n =
match (l,n) with
(l,0) -> ([], l)
in
(* Checks suppressed *)
CicSubstitution.lift_meta l ty
- | C.Sort s -> C.Sort C.Type (*CSC manca la gestione degli universi!!! *)
- | C.Implicit -> raise (Impossible 21)
+ | C.Sort (C.Type t) -> (* TASSI: CONSTRAINT *)
+ let t' = CicUniv.fresh() in
+ if not (CicUniv.add_gt t' t ) then
+ assert false (* t' is fresh! an error in CicUniv *)
+ else
+ C.Sort (C.Type t')
+ | C.Sort _ -> C.Sort (C.Type (CicUniv.fresh())) (* TASSI: CONSTRAINT *)
+ | C.Implicit _ -> raise (Impossible 21)
| C.Cast (te,ty) ->
(* Let's visit all the subterms that will not be visited later *)
let _ = type_of_aux context te (Some (head_beta_reduce ty)) in
sort_of_prod context (name,s) (sort1,sort2)
| C.Lambda (n,s,t) ->
(* Let's visit all the subterms that will not be visited later *)
- let _ = type_of_aux context s None in
+ let _ = type_of_aux context s None in
let expected_target_type =
match expectedty with
None -> None
| _ -> assert false
in
Some ty
- in
+ in
let type2 =
type_of_aux ((Some (n,(C.Decl s)))::context) t expected_target_type
in
let t_typ =
(* Checks suppressed *)
type_of_aux ((Some (n,(C.Def (s,Some ty))))::context) t None
- in
+ in (* CicSubstitution.subst s t_typ *)
if does_not_occur 1 t_typ then
(* since [Rel 1] does not occur in typ, substituting any term *)
(* in place of [Rel 1] is equivalent to delifting once *)
- CicSubstitution.subst C.Implicit t_typ
+ CicSubstitution.subst (C.Implicit None) t_typ
else
C.LetIn (n,s,t_typ)
| C.Appl (he::tl) when List.length tl > 0 ->
+ (*
let expected_hetype =
(* Inefficient, the head is computed twice. But I know *)
- (* of no other solution. *)
+ (* of no other solution. *)
(head_beta_reduce
(R.whd context (xxx_type_of_aux' metasenv context he)))
- in
- let hetype = type_of_aux context he (Some expected_hetype) in
+ in
+ let hetype = type_of_aux context he (Some expected_hetype) in
+ let tlbody_and_type =
+ let rec aux =
+ function
+ _,[] -> []
+ | C.Prod (n,s,t),he::tl ->
+ (he, type_of_aux context he (Some (head_beta_reduce s)))::
+ (aux (R.whd context (S.subst he t), tl))
+ | _ -> assert false
+ in
+ aux (expected_hetype, tl) *)
+ let hetype = R.whd context (type_of_aux context he None) in
let tlbody_and_type =
let rec aux =
function
(aux (R.whd context (S.subst he t), tl))
| _ -> assert false
in
- aux (expected_hetype, tl)
+ aux (hetype, tl)
in
eat_prods context hetype tlbody_and_type
| C.Appl _ -> raise (NotWellTyped "Appl: no arguments")
None ->
(* No expected type *)
{synthesized = synthesized' ; expected = None}, synthesized
- | Some ty when syntactic_equality synthesized' ty ->
+ | Some ty when xxx_syntactic_equality synthesized' ty ->
(* The expected type is synthactically equal to *)
(* the synthesized type. Let's forget it. *)
{synthesized = synthesized' ; expected = None}, synthesized
let t1' = CicReduction.whd context t1 in
let t2' = CicReduction.whd ((Some (name,C.Decl s))::context) t2 in
match (t1', t2') with
- (C.Sort s1, C.Sort s2)
- when (s2 = C.Prop or s2 = C.Set) -> (* different from Coq manual!!! *)
+ (C.Sort _, C.Sort s2)
+ when (s2 = C.Prop or s2 = C.Set or s2 = C.CProp) ->
+ (* different from Coq manual!!! *)
C.Sort s2
- | (C.Sort s1, C.Sort s2) -> C.Sort C.Type (*CSC manca la gestione degli universi!!! *)
+ | (C.Sort (C.Type t1), C.Sort (C.Type t2)) ->
+ (* TASSI: CONSRTAINTS: the same in cictypechecker,cicrefine *)
+ let t' = CicUniv.fresh() in
+ if not (CicUniv.add_ge t' t1) || not (CicUniv.add_ge t' t2) then
+ assert false ; (* not possible, error in CicUniv *)
+ C.Sort (C.Type t')
+ | (C.Sort _,C.Sort (C.Type t1)) ->
+ (* TASSI: CONSRTAINTS: the same in cictypechecker,cicrefine *)
+ C.Sort (C.Type t1) (* c'e' bisogno di un fresh? *)
+ | (C.Meta _, C.Sort _) -> t2'
+ | (C.Meta _, (C.Meta (_,_) as t))
+ | (C.Sort _, (C.Meta (_,_) as t)) when CicUtil.is_closed t ->
+ t2'
| (_,_) ->
raise
(NotWellTyped
projects / helm.git / blobdiff