module Orderings (B : Terms.Blob) = struct
+ module Pp = Pp.Pp(B)
+
type weight = int * (int * int) list;;
let string_of_weight (cw, mw) =
let wr, mr = weight_of_term r in
weight_of_polynomial (wl+wr) (ml@mr)
;;
+
+let compute_goal_weight (_,l, _, _) =
+ let weight_of_polynomial w m =
+ let factor = 2 in
+ w + factor * List.fold_left (fun acc (_,occ) -> acc+occ) 0 m
+ in
+ match l with
+ | Terms.Predicate t ->
+ let w, m = weight_of_term t in
+ weight_of_polynomial w m
+ | Terms.Equation (l,r,_,_) ->
+ let wl, ml = weight_of_term l in
+ let wr, mr = weight_of_term r in
+ let wl = weight_of_polynomial wl ml in
+ let wr = weight_of_polynomial wr mr in
+ - (abs (wl-wr))
+ ;;
(* Riazanov: 3.1.5 pag 38 *)
(* Compare weights normalized in a new way :
) else r
| res -> res
;;
-
+
+ let rec lpo s t =
+ match s,t with
+ | s, t when s = t ->
+ XEQ
+ | Terms.Var _, Terms.Var _ ->
+ XINCOMPARABLE
+ | _, Terms.Var i ->
+ if (List.mem i (Terms.vars_of_term s)) then XGT
+ else XINCOMPARABLE
+ | Terms.Var i,_ ->
+ if (List.mem i (Terms.vars_of_term t)) then XLT
+ else XINCOMPARABLE
+ | Terms.Node (hd1::tl1), Terms.Node (hd2::tl2) ->
+ let rec ge_subterm t ol = function
+ | [] -> (false, ol)
+ | x::tl ->
+ let res = lpo x t in
+ match res with
+ | XGT | XEQ -> (true,res::ol)
+ | o -> ge_subterm t (o::ol) tl
+ in
+ let (res, l_ol) = ge_subterm t [] tl1 in
+ if res then XGT
+ else let (res, r_ol) = ge_subterm s [] tl2 in
+ if res then XLT
+ else begin
+ let rec check_subterms t = function
+ | _,[] -> true
+ | o::ol,_::tl ->
+ if o = XLT then check_subterms t (ol,tl)
+ else false
+ | [], x::tl ->
+ if lpo x t = XLT then check_subterms t ([],tl)
+ else false
+ in
+ match aux_ordering hd1 hd2 with
+ | XGT -> if check_subterms s (r_ol,tl2) then XGT
+ else XINCOMPARABLE
+ | XLT -> if check_subterms t (l_ol,tl1) then XLT
+ else XINCOMPARABLE
+ | XEQ ->
+ let lex = List.fold_left2
+ (fun acc si ti -> if acc = XEQ then lpo si ti else acc)
+ XEQ tl1 tl2
+ in
+ (match lex with
+ | XGT ->
+ if List.for_all (fun x -> lpo s x = XGT) tl2 then XGT
+ else XINCOMPARABLE
+ | XLT ->
+ if List.for_all (fun x -> lpo x t = XLT) tl1 then XLT
+ else XINCOMPARABLE
+ | o -> o)
+ | XINCOMPARABLE -> XINCOMPARABLE
+ | _ -> assert false
+ end
+ | _,_ -> aux_ordering s t
+
+ ;;
+
+let rec lpo_old t1 t2 =
+ match t1, t2 with
+ | t1, t2 when t1 = t2 -> XEQ
+ | t1, (Terms.Var m) ->
+ if List.mem m (Terms.vars_of_term t1) then XGT else XINCOMPARABLE
+ | (Terms.Var m), t2 ->
+ if List.mem m (Terms.vars_of_term t2) then XLT else XINCOMPARABLE
+ | Terms.Node (hd1::tl1), Terms.Node (hd2::tl2) -> (
+ let res =
+ let f o r t =
+ if r then true else
+ match lpo_old t o with
+ | XGT | XEQ -> true
+ | _ -> false
+ in
+ let res1 = List.fold_left (f t2) false tl1 in
+ if res1 then XGT
+ else let res2 = List.fold_left (f t1) false tl2 in
+ if res2 then XLT
+ else XINCOMPARABLE
+ in
+ if res <> XINCOMPARABLE then
+ res
+ else
+ let f o r t =
+ if not r then false else
+ match lpo_old o t with
+ | XGT -> true
+ | _ -> false
+ in
+ match aux_ordering hd1 hd2 with
+ | XGT ->
+ let res = List.fold_left (f t1) true tl2 in
+ if res then XGT
+ else XINCOMPARABLE
+ | XLT ->
+ let res = List.fold_left (f t2) true tl1 in
+ if res then XLT
+ else XINCOMPARABLE
+ | XEQ -> (
+ let lex_res =
+ try
+ List.fold_left2
+ (fun r t1 t2 -> if r <> XEQ then r else lpo_old t1 t2)
+ XEQ tl1 tl2
+ with Invalid_argument _ ->
+ XINCOMPARABLE
+ in
+ match lex_res with
+ | XGT ->
+ if List.fold_left (f t1) true tl2 then XGT
+ else XINCOMPARABLE
+ | XLT ->
+ if List.fold_left (f t2) true tl1 then XLT
+ else XINCOMPARABLE
+ | _ -> XINCOMPARABLE
+ )
+ | _ -> XINCOMPARABLE
+ )
+ | t1, t2 -> aux_ordering t1 t2
+;;
+
let compare_terms x y =
- match nonrec_kbo x y with
- | XINCOMPARABLE -> Terms.Incomparable
- | XGT -> Terms.Gt
- | XLT -> Terms.Lt
- | XEQ -> Terms.Eq
- | _ -> assert false
+ match lpo x y with
+ | XINCOMPARABLE -> Terms.Incomparable
+ | XGT -> Terms.Gt
+ | XLT -> Terms.Lt
+ | XEQ -> Terms.Eq
+ | _ -> assert false
;;
end