exception Success of B.t Terms.bag * int * B.t Terms.unit_clause
let debug s =
- () (* prerr_endline s *)
+ () (* prerr_endline s *)
;;
let rec list_first f = function
let rec aux pos ctx = function
| Terms.Leaf _ as t -> f t pos ctx
| Terms.Var _ -> None
- | Terms.Node l as t->
+ | Terms.Node l as t->
match f t pos ctx with
| Some _ as x -> x
| None ->
let newside = Subst.apply_subst subst newside in
let o = Order.compare_terms newside side in
(* Riazanov, pp. 45 (ii) *)
- if o = Terms.Lt then
+ if o = Terms.Lt then
Some (context newside, subst, varlist, id, pos, dir)
else
((*prerr_endline ("Filtering: " ^
(IDX.ClauseSet.elements cands)
;;
- (* XXX: possible optimization, if the literal has a "side" already
- * in normal form we should not traverse it again *)
- let demodulate_once bag (id, literal, vl, pr) table =
+ let demodulate_once ~jump_to_right bag (id, literal, vl, pr) table =
(* debug ("Demodulating : " ^ (Pp.pp_unit_clause (id, literal, vl, pr)));*)
- let t =
- match literal with
- | Terms.Predicate t -> t
- | Terms.Equation (l,r,ty,_) -> Terms.Node [ Terms.Leaf B.eqP; ty; l; r ]
- in
- match first_position [] (fun x -> x) t (demod table vl) with
- | None -> None
- | Some (newt, subst, varlist, id2, pos, dir) ->
- build_clause bag (fun _ -> true) Terms.Demodulation
- newt subst varlist id id2 pos dir
+ match literal with
+ | Terms.Predicate t -> assert false
+ | Terms.Equation (l,r,ty,_) ->
+ let left_position = if jump_to_right then None else
+ first_position [2]
+ (fun x -> Terms.Node [ Terms.Leaf B.eqP; ty; x; r ]) l
+ (demod table vl)
+ in
+ match left_position with
+ | Some (newt, subst, varlist, id2, pos, dir) ->
+ begin
+ match build_clause bag (fun _ -> true) Terms.Demodulation
+ newt subst varlist id id2 pos dir
+ with
+ | None -> assert false
+ | Some x -> Some (x,false)
+ end
+ | None ->
+ match first_position
+ [3] (fun x -> Terms.Node [ Terms.Leaf B.eqP; ty; l; x ]) r
+ (demod table vl)
+ with
+ | None -> None
+ | Some (newt, subst, varlist, id2, pos, dir) ->
+ match build_clause bag (fun _ -> true)
+ Terms.Demodulation newt subst varlist id id2 pos dir
+ with
+ | None -> assert false
+ | Some x -> Some (x,true)
;;
- let rec demodulate bag clause table =
- match demodulate_once bag clause table with
+ let rec demodulate ~jump_to_right bag clause table =
+ match demodulate_once ~jump_to_right bag clause table with
| None -> bag, clause
- | Some (bag, clause) -> demodulate bag clause table
+ | Some ((bag, clause),r) -> demodulate ~jump_to_right:r
+ bag clause table
+ ;;
+
+ let demodulate bag clause table = demodulate ~jump_to_right:false
+ bag clause table
;;
(* move away *)
bag (newa@tl)
in
keep_simplified_aux ~new_cl:true cl (alist,atable) bag []
- ;;
-
+ ;;
+
+ let are_alpha_eq cl1 cl2 =
+ let get_term (_,lit,_,_) =
+ match lit with
+ | Terms.Predicate _ -> assert false
+ | Terms.Equation (l,r,ty,_) ->
+ Terms.Node [Terms.Leaf B.eqP; ty; l ; r]
+ in
+ try ignore(Unif.alpha_eq (get_term cl1) (get_term cl2)) ; true
+ with FoUnif.UnificationFailure _ -> false
+;;
+
(* this is like simplify but raises Success *)
- let simplify_goal maxvar table bag clause =
+ let simplify_goal maxvar table bag g_actives clause =
let bag, clause = demodulate bag clause table in
if (is_identity_clause clause)
then raise (Success (bag, maxvar, clause))
else match is_subsumed ~unify:true bag maxvar clause table with
- | None -> bag, clause
+ | None ->
+ if List.exists (are_alpha_eq clause) g_actives then None
+ else Some (bag, clause)
| Some ((bag,maxvar),c) ->
debug "Goal subsumed";
raise (Success (bag,maxvar,c))
in
debug "Another superposition";
let new_clauses = new_clauses @ additional_new_clauses in
+ debug (Printf.sprintf "Demodulating %d clauses"
+ (List.length new_clauses));
let bag, new_clauses =
HExtlib.filter_map_acc (simplify atable maxvar) bag new_clauses
in
let infer_left bag maxvar goal (_alist, atable) =
(* We superpose the goal with active clauses *)
- let bag, maxvar, new_goals =
+ let bag, maxvar, new_goals =
superposition_with_table bag maxvar goal atable
in
- (* We demodulate the goal with active clauses *)
+ debug "Superposed goal with active clauses";
+ (* We simplify the new goals with active clauses *)
let bag, new_goals =
List.fold_left
(fun (bag, acc) g ->
- let bag, g = demodulate bag g atable in
- bag, g :: acc)
+ match simplify_goal maxvar atable bag [] g with
+ | None -> assert false
+ | Some (bag,g) -> bag,g::acc)
(bag, []) new_goals
in
+ debug "Simplified new goals with active clauses";
bag, maxvar, List.rev new_goals
;;
projects / helm.git / blobdiff