struct
module IDX = Index.Index(B)
module Unif = FoUnif.Founif(B)
- module Subst = FoSubst.Subst(B)
+ module Subst = FoSubst (*.Subst(B)*)
module Order = Orderings.Orderings(B)
module Utils = FoUtils.Utils(B)
module Pp = Pp.Pp(B)
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
in
aux pos ctx t
;;
+
+ let vars_of_term t =
+ let rec aux acc = function
+ | Terms.Leaf _ -> acc
+ | Terms.Var i -> if (List.mem i acc) then acc else i::acc
+ | Terms.Node l -> List.fold_left aux acc l
+ in aux [] t
+ ;;
let build_clause bag filter rule t subst vl id id2 pos dir =
let proof = Terms.Step(rule,id,id2,dir,pos,subst) in
| t -> Terms.Predicate t
in
let bag, uc =
- Utils.add_to_bag bag (0, literal, vl, proof)
+ Utils.add_to_bag bag (0, literal, vars_of_term t, proof)
in
Some (bag, uc)
else
(* 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 =
- debug ("Demodulating : " ^ (Pp.pp_unit_clause (id, literal, vl, pr)));
+ (* debug ("Demodulating : " ^ (Pp.pp_unit_clause (id, literal, vl, pr)));*)
let t =
match literal with
| Terms.Predicate t -> t
else Some (bag, clause)
;;
- let rec keep_simplified (alist,atable) bag newc =
- match newc with
- | [] -> bag, (alist,atable)
- | hd::tl ->
- (match simplify atable bag hd with
- | None -> keep_simplified (alist,atable) bag tl
- | Some (bag, clause) ->
- let ctable = IDX.index_unit_clause IDX.DT.empty clause in
- let bag, newa, alist, atable =
- List.fold_left
- (fun (bag, newa, alist, atable) c ->
- let bag, c1 = demodulate bag c ctable in
- if (c1 == c) then
- bag, newa, c :: alist, IDX.index_unit_clause atable c
- else
- bag, c :: newa, alist, atable)
- (bag,[],[],IDX.DT.empty) alist
- in
- keep_simplified (alist, atable) bag newa)
+ let one_pass_simplification new_clause (alist,atable) bag =
+ match simplify atable bag new_clause with
+ | None -> None (* new_clause has been discarded *)
+ | Some (bag, clause) ->
+ let ctable = IDX.index_unit_clause IDX.DT.empty clause in
+ let bag, alist, atable =
+ List.fold_left
+ (fun (bag, alist, atable as acc) c ->
+ match simplify ctable bag c with
+ |None -> acc (* an active clause as been discarded *)
+ |Some (bag, c1) ->
+ bag, c :: alist, IDX.index_unit_clause atable c)
+ (bag,[],IDX.DT.empty) alist
+ in
+ Some (clause, bag, (alist,atable))
;;
+ let simplification_step ~new_cl cl (alist,atable) bag new_clause =
+ let atable1 =
+ if new_cl then atable else
+ IDX.index_unit_clause atable cl
+ in
+ (* Simplification of new_clause with : *
+ * - actives and cl if new_clause is not cl *
+ * - only actives otherwise *)
+ match simplify atable1 bag new_clause with
+ | None -> (Some cl, None) (* new_clause has been discarded *)
+ | Some (bag, clause) ->
+ (* Simplification of each active clause with clause *
+ * which is the simplified form of new_clause *)
+ let ctable = IDX.index_unit_clause IDX.DT.empty clause in
+ let bag, newa, alist, atable =
+ List.fold_left
+ (fun (bag, newa, alist, atable as acc) c ->
+ match simplify ctable bag c with
+ |None -> acc (* an active clause as been discarded *)
+ |Some (bag, c1) ->
+ if (c1 == c) then
+ bag, newa, c :: alist,
+ IDX.index_unit_clause atable c
+ else
+ bag, c1 :: newa, alist, atable)
+ (bag,[],[],IDX.DT.empty) alist
+ in
+ if new_cl then
+ (Some cl, Some (clause, (alist,atable), newa, bag))
+ else
+ (* if new_clause is not cl, we simplify cl with clause *)
+ match simplify ctable bag cl with
+ | None ->
+ (* cl has been discarded *)
+ (None, Some (clause, (alist,atable), newa, bag))
+ | Some (bag,cl1) ->
+ (Some cl1, Some (clause, (alist,atable), newa, bag))
+ ;;
+
+ let keep_simplified cl (alist,atable) bag =
+ let rec keep_simplified_aux ~new_cl cl (alist,atable) bag newc =
+ if new_cl then
+ match simplification_step ~new_cl cl (alist,atable) bag cl with
+ | (None, _) -> assert false
+ | (Some _, None) -> None
+ | (Some _, Some (clause, (alist,atable), newa, bag)) ->
+ keep_simplified_aux ~new_cl:(cl!=clause) clause (alist,atable)
+ bag (newa@newc)
+ else
+ match newc with
+ | [] -> Some (cl, bag, (alist,atable))
+ | hd::tl ->
+ match simplification_step ~new_cl cl
+ (alist,atable) bag hd with
+ | (None,None) -> assert false
+ | (Some _,None) ->
+ keep_simplified_aux ~new_cl cl (alist,atable) bag tl
+ | (None, Some _) -> None
+ | (Some cl1, Some (clause, (alist,atable), newa, bag)) ->
+ let alist,atable =
+ (clause::alist, IDX.index_unit_clause atable clause)
+ in
+ keep_simplified_aux ~new_cl:(cl!=cl1) cl1 (alist,atable)
+ bag (newa@tl)
+ in
+ keep_simplified_aux ~new_cl:true cl (alist,atable) bag []
+ ;;
+
(* this is like simplify but raises Success *)
let simplify_goal maxvar table bag clause =
let bag, clause = demodulate bag clause table in
(* the current equation is normal w.r.t. demodulation with atable
* (and is not the identity) *)
let infer_right bag maxvar current (alist,atable) =
- (* We demodulate actives clause with current *)
+ (* We demodulate actives clause with current until all *
+ * active clauses are reduced w.r.t each other *)
+ (* let bag, (alist,atable) = keep_simplified (alist,atable) bag [current] in *)
let ctable = IDX.index_unit_clause IDX.DT.empty current in
- let bag, (alist, atable) =
+ (* let bag, (alist, atable) =
let bag, alist =
HExtlib.filter_map_acc (simplify ctable) bag alist
in
bag, (alist, List.fold_left IDX.index_unit_clause IDX.DT.empty alist)
- in
+ in*)
debug "Simplified active clauses with fact";
(* We superpose active clauses with current *)
let bag, maxvar, new_clauses =