type 'a substitution = (int * 'a foterm) list
-type comparison = Lt | Eq | Gt | Incomparable
+type comparison = Lt | Eq | Gt | Incomparable | Invertible
-type rule = SuperpositionRight | SuperpositionLeft | Demodulation
+type rule = Superposition | Demodulation
type direction = Left2Right | Right2Left | Nodir
type position = int list
type 'a passive_clause = int * 'a unit_clause (* weight * equation *)
+let is_eq_clause (_,l,_,_) =
+ match l with
+ | Equation _ -> true
+ | Predicate _ -> false
+;;
+
+let vars_of_term t =
+ let rec aux acc = function
+ | Leaf _ -> acc
+ | Var i -> if (List.mem i acc) then acc else i::acc
+ | Node l -> List.fold_left aux acc l
+ in aux [] t
+;;
module OT =
struct
module M : Map.S with type key = int
= Map.Make(OT)
-type 'a bag = 'a unit_clause M.t
+type 'a bag = int
+ * (('a unit_clause * bool * int) M.t)
+
+ let add_to_bag (_,lit,vl,proof) (id,bag) =
+ let id = id+1 in
+ let clause = (id, lit, vl, proof) in
+ let bag = M.add id (clause,false,0) bag in
+ (id,bag), clause
+ ;;
+
+ let replace_in_bag ((id,_,_,_),_,_ as cl) (max_id,bag) =
+ let bag = M.add id cl bag in
+ (max_id,bag)
+ ;;
+
+ let get_from_bag id (_,bag) =
+ M.find id bag
+ ;;
+
+ let empty_bag = (0,M.empty);;
module type Blob =
sig
val eq : t -> t -> bool
val compare : t -> t -> int
val eqP : t
+ val is_eq: t foterm -> (t foterm* t foterm *t foterm) option
val pp : t -> string
- val embed : t -> t foterm
- val saturate : t -> t -> t foterm * t foterm
+ type input
+ val embed : input -> t foterm
+ val saturate : input -> input -> t foterm * t foterm
end