;;
-
-
let print_subst ?(prefix="\n") subst =
String.concat prefix
(List.map
| Eq -> "="
| Incomparable -> "I"
+type environment = Cic.metasenv * Cic.context * CicUniv.universe_graph
+
module OrderedTerm =
struct
type t = Cic.term
| C.Meta _ as t -> TermSet.singleton t
| C.Appl l ->
List.fold_left (fun res t -> TermSet.union res (aux t)) TermSet.empty l
+ | C.Lambda(n,s,t) ->
+ TermSet.union (aux s) (aux t)
+ | C.Prod(n,s,t) ->
+ TermSet.union (aux s) (aux t)
+ | C.LetIn(n,s,ty,t) ->
+ TermSet.union (aux s) (TermSet.union (aux ty) (aux t))
| t -> TermSet.empty (* TODO: maybe add other cases? *)
in
aux term
;;
+let rec remove_local_context =
+ function
+ | Cic.Meta (i,_) -> Cic.Meta (i,[])
+ | Cic.Appl l ->
+ Cic.Appl(List.map remove_local_context l)
+ | t -> t
+
(************************* rpo ********************************)
let number = [
| C.Cast (t1, t2)
| C.Lambda (_, t1, t2)
| C.Prod (_, t1, t2)
- | C.LetIn (_, t1, t2) ->
+ | C.LetIn (_, t1, _, t2) ->
let w1 = aux t1 in
let w2 = aux t2 in
w1 + w2 + 1
module IntSet = Set.Make(OrderedInt)
-let compute_equality_weight ty left right =
+let goal_symbols = ref TermSet.empty
+
+let set_of_map m =
+ TermMap.fold (fun k _ s -> TermSet.add k s) m TermSet.empty
+;;
+
+let set_goal_symbols term =
+ let m = symbols_of_term term in
+ goal_symbols := (set_of_map m)
+;;
+
+let symbols_of_eq (ty,left,right,_) =
+ let sty = set_of_map (symbols_of_term ty) in
+ let sl = set_of_map (symbols_of_term left) in
+ let sr = set_of_map (symbols_of_term right) in
+ TermSet.union sty (TermSet.union sl sr)
+;;
+
+let distance sgoal seq =
+ let s = TermSet.diff seq sgoal in
+ TermSet.cardinal s
+;;
+
+let compute_equality_weight (ty,left,right,o) =
+ let factor = 2 in
+ match o with
+ | Lt ->
+ let w, m = (weight_of_term
+ ~consider_metas:true ~count_metas_occurrences:false right) in
+ w + (factor * (List.length m)) ;
+ | Le -> assert false
+ | Gt ->
+ let w, m = (weight_of_term
+ ~consider_metas:true ~count_metas_occurrences:false left) in
+ w + (factor * (List.length m)) ;
+ | Ge -> assert false
+ | Eq
+ | Incomparable ->
+ let w1, m1 = (weight_of_term
+ ~consider_metas:true ~count_metas_occurrences:false right) in
+ let w2, m2 = (weight_of_term
+ ~consider_metas:true ~count_metas_occurrences:false left) in
+ w1 + w2 + (factor * (List.length m1)) + (factor * (List.length m2))
+;;
+
+let compute_equality_weight e =
+ let w = compute_equality_weight e in
+ let d = 0 in (* distance !goal_symbols (symbols_of_eq e) in *)
+(*
+ prerr_endline (Printf.sprintf "dist %s --- %s === %d"
+ (String.concat ", " (List.map (CicPp.ppterm) (TermSet.elements
+ !goal_symbols)))
+ (String.concat ", " (List.map (CicPp.ppterm) (TermSet.elements
+ (symbols_of_eq e))))
+ d
+ );
+*)
+ w + d
+;;
+
+(* old
+let compute_equality_weight (ty,left,right,o) =
let metasw = ref 0 in
let weight_of t =
let w, m = (weight_of_term
~consider_metas:true ~count_metas_occurrences:false t) in
- metasw := !metasw + (2 * (List.length m)) ;
+ metasw := !metasw + (1 * (List.length m)) ;
w
in
(* Warning: the following let cannot be expanded since it forces the
right evaluation order!!!! *)
- let w = (weight_of ty) + (weight_of left) + (weight_of right) in
+ let w = (weight_of ty) + (weight_of left) + (weight_of right) in
+ (* let w = weight_of (Cic.Appl [ty;left;right]) in *)
w + !metasw
;;
-
+*)
(* returns a "normalized" version of the polynomial weight wl (with type
* weight list), i.e. a list sorted ascending by meta number,
| (m, _, n) when m > 0 && n > 0 ->
Incomparable
| _ -> assert false
-
;;
if t = t' then t else
begin
let simpl_order = !compare_terms t t' in
- if debug then
- prerr_endline ("comparing "^(CicPp.ppterm t)^(CicPp.ppterm t'));
+ debug_print (lazy ("comparing "^(CicPp.ppterm t)^(CicPp.ppterm t')));
if simpl_order = Gt then (if debug then prerr_endline "GT";t')
else (if debug then prerr_endline "NO_GT";t)
end
;;
-type equality_sign = Negative | Positive;;
-
-let string_of_sign = function
- | Negative -> "Negative"
- | Positive -> "Positive"
-;;
-
-
type pos = Left | Right
let string_of_pos = function
| Right -> "Right"
;;
+let metas_of_term t =
+ List.map fst (CicUtil.metas_of_term t)
+;;
-let eq_ind_URI () = LibraryObjects.eq_ind_URI ~eq:(LibraryObjects.eq_URI ())
-let eq_ind_r_URI () = LibraryObjects.eq_ind_r_URI ~eq:(LibraryObjects.eq_URI ())
-let sym_eq_URI () = LibraryObjects.sym_eq_URI ~eq:(LibraryObjects.eq_URI ())
-let eq_XURI () =
- let s = UriManager.string_of_uri (LibraryObjects.eq_URI ()) in
- UriManager.uri_of_string (s ^ "#xpointer(1/1/1)")
-let trans_eq_URI () = LibraryObjects.trans_eq_URI ~eq:(LibraryObjects.eq_URI ())