sig
  type 'a widening_set = FromWto | Predicate of ('-> bool)
  module type G =
    sig
      type t
      module V : Sig.COMPARABLE
      module E : sig type t val src : ChaoticIteration.G.E.t -> V.t end
      val fold_pred_e :
        (ChaoticIteration.G.E.t -> '-> 'a) ->
        ChaoticIteration.G.t -> V.t -> '-> 'a
    end
  module type Data =
    sig
      type t
      type edge
      val join :
        ChaoticIteration.Data.t ->
        ChaoticIteration.Data.t -> ChaoticIteration.Data.t
      val equal : ChaoticIteration.Data.t -> ChaoticIteration.Data.t -> bool
      val analyze :
        ChaoticIteration.Data.edge ->
        ChaoticIteration.Data.t -> ChaoticIteration.Data.t
      val widening :
        ChaoticIteration.Data.t ->
        ChaoticIteration.Data.t -> ChaoticIteration.Data.t
    end
  module Make :
    functor
      (G : G) (D : sig
                     type t
                     type edge = G.E.t
                     val join : t -> t -> t
                     val equal : t -> t -> bool
                     val analyze : edge -> t -> t
                     val widening : t -> t -> t
                   end->
      sig
        module M :
          sig
            type key = G.V.t
            type +'a t
            val empty : 'a t
            val is_empty : 'a t -> bool
            val mem : key -> 'a t -> bool
            val add : key -> '-> 'a t -> 'a t
            val singleton : key -> '-> 'a t
            val remove : key -> 'a t -> 'a t
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val compare : ('-> '-> int) -> 'a t -> 'a t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
            val iter : (key -> '-> unit) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val for_all : (key -> '-> bool) -> 'a t -> bool
            val exists : (key -> '-> bool) -> 'a t -> bool
            val filter : (key -> '-> bool) -> 'a t -> 'a t
            val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
            val cardinal : 'a t -> int
            val bindings : 'a t -> (key * 'a) list
            val min_binding : 'a t -> key * 'a
            val max_binding : 'a t -> key * 'a
            val choose : 'a t -> key * 'a
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
          end
        val recurse :
          ChaoticIteration.G.t ->
          G.V.t WeakTopological.t ->
          (G.V.t -> D.t) ->
          G.V.t ChaoticIteration.widening_set ->
          int -> D.t ChaoticIteration.Make.M.t
      end
end