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)));*)
match literal with
| Terms.Predicate t -> assert false
| Terms.Equation (l,r,ty,_) ->
- match first_position [2]
- (fun x -> Terms.Node [ Terms.Leaf B.eqP; ty; x; r ]) l
- (demod table vl)
- with
+ 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) ->
- build_clause bag (fun _ -> true) Terms.Demodulation
- newt subst varlist id 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
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 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 *)
- let is_identity_clause = function
+ let is_identity_clause ~unify = function
| _, Terms.Equation (_,_,_,Terms.Eq), _, _ -> true
- | _, Terms.Predicate _, _, _ -> assert false
+ | _, Terms.Equation (l,r,_,_), vl, proof when unify ->
+ (try ignore(Unif.unification vl [] l r); true
+ with FoUnif.UnificationFailure _ -> false)
+ | _, Terms.Predicate _, _, _ -> assert false
| _ -> false
;;
bag, maxvar, res
;;
+
+ let rewrite_eq ~unify l r ty vl table =
+ let retrieve = if unify then IDX.DT.retrieve_unifiables
+ else IDX.DT.retrieve_generalizations in
+ let lcands = retrieve table l in
+ let rcands = retrieve table r in
+ let f b c =
+ let id, dir, l, r, vl =
+ match c with
+ | (d, (id,Terms.Equation (l,r,ty,_),vl,_))-> id, d, l, r, vl
+ |_ -> assert false
+ in
+ let reverse = (dir = Terms.Left2Right) = b in
+ let l, r, proof_rewrite_dir = if reverse then l,r,Terms.Left2Right
+ else r,l, Terms.Right2Left in
+ (id,proof_rewrite_dir,Terms.Node [ Terms.Leaf B.eqP; ty; l; r ], vl)
+ in
+ let cands1 = List.map (f true) (IDX.ClauseSet.elements lcands) in
+ let cands2 = List.map (f false) (IDX.ClauseSet.elements rcands) in
+ let t = Terms.Node [ Terms.Leaf B.eqP; ty; l; r ] in
+ let locked_vars = if unify then [] else vl in
+ let rec aux = function
+ | [] -> None
+ | (id2,dir,c,vl1)::tl ->
+ try
+ let subst,vl1 = Unif.unification (vl@vl1) locked_vars c t in
+ Some (id2, dir, subst)
+ with FoUnif.UnificationFailure _ -> aux tl
+ in
+ aux (cands1 @ cands2)
+ ;;
+
let is_subsumed ~unify bag maxvar (id, lit, vl, _) table =
match lit with
| Terms.Predicate _ -> assert false
| Terms.Equation (l,r,ty,_) ->
- let retrieve = if unify then IDX.DT.retrieve_unifiables
- else IDX.DT.retrieve_generalizations in
- let lcands = retrieve table l in
- let rcands = retrieve table r in
- let f b c =
- let id, dir, l, r, vl =
- match c with
- | (d, (id,Terms.Equation (l,r,ty,_),vl,_))-> id, d, l, r, vl
- |_ -> assert false
- in
- let reverse = (dir = Terms.Left2Right) = b in
- let l, r, proof_rewrite_dir = if reverse then l,r,Terms.Left2Right
- else r,l, Terms.Right2Left in
- (id,proof_rewrite_dir,Terms.Node [ Terms.Leaf B.eqP; ty; l; r ], vl)
- in
- let cands1 = List.map (f true) (IDX.ClauseSet.elements lcands) in
- let cands2 = List.map (f false) (IDX.ClauseSet.elements rcands) in
- let t = Terms.Node [ Terms.Leaf B.eqP; ty; l; r ] in
- let locked_vars = if unify then [] else vl in
- let rec aux = function
- | [] -> None
- | (id2,dir,c,vl1)::tl ->
- try
- let subst,vl1 = Unif.unification (vl@vl1) locked_vars c t in
- let id_t = Terms.Node [ Terms.Leaf B.eqP; ty; r; r ] in
- build_new_clause bag maxvar (fun _ -> true)
- Terms.Superposition id_t subst [] id id2 [2] dir
- with FoUnif.UnificationFailure _ -> aux tl
- in
- aux (cands1 @ cands2)
+ match rewrite_eq ~unify l r ty vl table with
+ | None -> None
+ | Some (id2, dir, subst) ->
+ let id_t = Terms.Node [ Terms.Leaf B.eqP; ty; r; r ] in
+ build_new_clause bag maxvar (fun _ -> true)
+ Terms.Superposition id_t subst [] id id2 [2] dir
;;
+(*
+ let rec deeply_subsumed ~unify bag maxvar (id, lit, vl, _) table =
+ match lit with
+ | Terms.Predicate _ -> assert false
+ | Terms.Equation (l,r,ty,_) ->
+ (match is_subsumed ~unify bag maxvar (id, lit, vl, _) table with
+ | Some((bag,maxvar),c) -> Some((bag,maxvar),c)
+ | None ->
+ match l,r with ->
+ Var i, _ ->
+ ;;
+*)
+
+
(* demodulate and check for subsumption *)
let simplify table maxvar bag clause =
let bag, clause = demodulate bag clause table in
- if is_identity_clause clause then None
+ if is_identity_clause ~unify:false clause then None
else
match is_subsumed ~unify:false bag maxvar clause table with
| None -> Some (bag, clause)
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)
+ if (is_identity_clause ~unify:true 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 bag, maxvar, new_goals =
superposition_with_table bag maxvar goal atable
in
- prerr_endline "Superposed goal with active clauses";
- (* 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
- prerr_endline "Demodulated goal with active clauses";
+ debug "Simplified new goals with active clauses";
bag, maxvar, List.rev new_goals
;;
projects / helm.git / blobdiff