functor (Alpha : Alphabet->
  sig
    module Alpha :
      sig
        type t = Alpha.t
        val from_string : string -> t
        val compare : t -> t -> int
        val print : Format.formatter -> t -> unit
      end
    module AlphaSep : PLattice.Alphabet
    module PL :
      sig
        module A :
          sig
            type t = AlphaSep.t
            val sep : t
            module Set :
              sig
                type elt = t
                type t = AlphaSep.Set.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            module Map :
              sig
                type key = t
                type 'a t = 'AlphaSep.Map.t
                module Setkey :
                  sig
                    type elt = t
                    type t = Set.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                val repr : 'a t -> (key, 'a) Mappe.map
                val obj : (key, 'a) Mappe.map -> 'a t
                val is_empty : 'a t -> bool
                val empty : 'a t
                val add : key -> '-> 'a t -> 'a t
                val find : key -> 'a t -> 'a
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val addmap : 'a t -> 'a t -> 'a t
                val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val combine :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val interset : 'a t -> Setkey.t -> 'a t
                val diffset : 'a t -> Setkey.t -> 'a t
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val maptoset : 'a t -> Setkey.t
                val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                val comparei :
                  (key -> '-> '-> int) -> 'a t -> 'b t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val equali :
                  (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val subseti :
                  (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                val max_key : 'a t -> key
                val choose : 'a t -> key * 'a
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  ?firstbind:(unit, Format.formatter, unit) format ->
                  ?sepbind:(unit, Format.formatter, unit) format ->
                  ?lastbind:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> key -> unit) ->
                  (Format.formatter -> '-> unit) ->
                  Format.formatter -> 'a t -> unit
              end
          end
        module SetAA :
          sig
            type elt = A.t * A.t
            type t
            val repr : t -> elt Sette.set
            val obj : elt Sette.set -> t
            module Ord : sig type t = elt val compare : t -> t -> int end
            val empty : t
            val is_empty : t -> bool
            val mem : elt -> t -> bool
            val add : elt -> t -> t
            val singleton : elt -> t
            val remove : elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val compare : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val fold : (elt -> '-> 'a) -> t -> '-> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val filter : (elt -> bool) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val max_elt : t -> elt
            val choose : t -> elt
            val print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              (Format.formatter -> elt -> unit) ->
              Format.formatter -> t -> unit
          end
        module MapAA :
          sig
            type key = A.t * A.t
            type 'a t
            module Setkey :
              sig
                type elt = A.t * A.t
                type t = SetAA.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            val repr : 'a t -> (key, 'a) Mappe.map
            val obj : (key, 'a) Mappe.map -> 'a t
            val is_empty : 'a t -> bool
            val empty : 'a t
            val add : key -> '-> 'a t -> 'a t
            val find : key -> 'a t -> 'a
            val remove : key -> 'a t -> 'a t
            val mem : key -> 'a t -> bool
            val addmap : 'a t -> 'a t -> 'a t
            val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
            val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val combine :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val interset : 'a t -> Setkey.t -> 'a t
            val diffset : 'a t -> Setkey.t -> 'a t
            val iter : (key -> '-> unit) -> 'a t -> unit
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('-> '-> int) -> 'a t -> 'b t -> int
            val comparei : (key -> '-> '-> int) -> 'a t -> 'b t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
            val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
            val max_key : 'a t -> key
            val choose : 'a t -> key * 'a
            val print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              ?firstbind:(unit, Format.formatter, unit) format ->
              ?sepbind:(unit, Format.formatter, unit) format ->
              ?lastbind:(unit, Format.formatter, unit) format ->
              (Format.formatter -> key -> unit) ->
              (Format.formatter -> '-> unit) ->
              Format.formatter -> 'a t -> unit
          end
        type 'a lattice = (A.t, 'a) PLattice.glattice
        type 'a t = 'A.Map.t
        val sep : 'a lattice -> 'a t
        val is_sep : 'a t -> bool
        val print :
          ?first:(unit, Format.formatter, unit) format ->
          ?sep:(unit, Format.formatter, unit) format ->
          ?last:(unit, Format.formatter, unit) format ->
          ?firstbind:(unit, Format.formatter, unit) format ->
          ?sepbind:(unit, Format.formatter, unit) format ->
          ?lastbind:(unit, Format.formatter, unit) format ->
          (Format.formatter -> A.t -> unit) ->
          (Format.formatter -> '-> unit) ->
          Format.formatter -> 'a t -> unit
        val bottom : 'a t
        val singleton : A.t -> '-> 'a t
        val normalize : 'a lattice -> 'a t -> 'a t
        val is_bottom : 'a lattice -> 'a t -> bool
        val is_leq : 'a lattice -> 'a t -> 'a t -> bool
        val is_eq : 'a lattice -> 'a t -> 'a t -> bool
        val meet : 'a lattice -> 'a t -> 'a t -> 'a t
        val join : 'a lattice -> 'a t -> 'a t -> 'a t
        val widening : 'a lattice -> partition:'a t -> 'a t -> 'a t -> 'a t
        val map : ('-> 'b) -> 'a t -> 'b t
        val mapi : (A.t -> '-> 'b) -> 'a t -> 'b t
        val project :
          project:('-> A.t * '-> 'b) -> '-> 'b lattice -> 'b t -> 'b t
        val merge : empty:'-> merge:(A.t * '-> '-> 'a) -> 'b t -> 'a
        val lcm :
          ?coherent:bool ->
          meet:(A.t * '-> A.t * '-> 'a option) ->
          'a t -> 'a t -> 'MapAA.t
        val transfer :
          ?coherent:bool ->
          meet:(A.t * '-> A.t * '-> 'a option) ->
          'a lattice -> 'a t -> 'a t -> 'a t
      end
    module Langage :
      sig
        module A :
          sig
            type t = AlphaSep.t
            val sep : t
            module Set :
              sig
                type elt = t
                type t = AlphaSep.Set.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            module Map :
              sig
                type key = t
                type 'a t = 'AlphaSep.Map.t
                module Setkey :
                  sig
                    type elt = t
                    type t = Set.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                val repr : 'a t -> (key, 'a) Mappe.map
                val obj : (key, 'a) Mappe.map -> 'a t
                val is_empty : 'a t -> bool
                val empty : 'a t
                val add : key -> '-> 'a t -> 'a t
                val find : key -> 'a t -> 'a
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val addmap : 'a t -> 'a t -> 'a t
                val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val combine :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val interset : 'a t -> Setkey.t -> 'a t
                val diffset : 'a t -> Setkey.t -> 'a t
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val maptoset : 'a t -> Setkey.t
                val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                val comparei :
                  (key -> '-> '-> int) -> 'a t -> 'b t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val equali :
                  (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val subseti :
                  (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                val max_key : 'a t -> key
                val choose : 'a t -> key * 'a
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  ?firstbind:(unit, Format.formatter, unit) format ->
                  ?sepbind:(unit, Format.formatter, unit) format ->
                  ?lastbind:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> key -> unit) ->
                  (Format.formatter -> '-> unit) ->
                  Format.formatter -> 'a t -> unit
              end
          end
        module PL :
          sig
            module A :
              sig
                type t = AlphaSep.t
                val sep : t
                module Set :
                  sig
                    type elt = t
                    type t = AlphaSep.Set.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                module Map :
                  sig
                    type key = t
                    type 'a t = 'AlphaSep.Map.t
                    module Setkey :
                      sig
                        type elt = t
                        type t = Set.t
                        val repr : t -> elt Sette.set
                        val obj : elt Sette.set -> t
                        module Ord :
                          sig type t = elt val compare : t -> t -> int end
                        val empty : t
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val remove : elt -> t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val compare : t -> t -> int
                        val equal : t -> t -> bool
                        val subset : t -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val cardinal : t -> int
                        val elements : t -> elt list
                        val min_elt : t -> elt
                        val max_elt : t -> elt
                        val choose : t -> elt
                        val print :
                          ?first:(unit, Format.formatter, unit) format ->
                          ?sep:(unit, Format.formatter, unit) format ->
                          ?last:(unit, Format.formatter, unit) format ->
                          (Format.formatter -> elt -> unit) ->
                          Format.formatter -> t -> unit
                      end
                    val repr : 'a t -> (key, 'a) Mappe.map
                    val obj : (key, 'a) Mappe.map -> 'a t
                    val is_empty : 'a t -> bool
                    val empty : 'a t
                    val add : key -> '-> 'a t -> 'a t
                    val find : key -> 'a t -> 'a
                    val remove : key -> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val addmap : 'a t -> 'a t -> 'a t
                    val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val mergei :
                      (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val commoni :
                      (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val combine :
                      (key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    val interset : 'a t -> Setkey.t -> 'a t
                    val diffset : 'a t -> Setkey.t -> 'a t
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : ('-> 'b) -> 'a t -> 'b t
                    val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val maptoset : 'a t -> Setkey.t
                    val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                    val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                    val comparei :
                      (key -> '-> '-> int) -> 'a t -> 'b t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val equali :
                      (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                    val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val subseti :
                      (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                    val max_key : 'a t -> key
                    val choose : 'a t -> key * 'a
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      ?firstbind:(unit, Format.formatter, unit) format ->
                      ?sepbind:(unit, Format.formatter, unit) format ->
                      ?lastbind:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> key -> unit) ->
                      (Format.formatter -> '-> unit) ->
                      Format.formatter -> 'a t -> unit
                  end
              end
            module SetAA :
              sig
                type elt = A.t * A.t
                type t = PL.SetAA.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            module MapAA :
              sig
                type key = A.t * A.t
                type 'a t = 'PL.MapAA.t
                module Setkey :
                  sig
                    type elt = A.t * A.t
                    type t = SetAA.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                val repr : 'a t -> (key, 'a) Mappe.map
                val obj : (key, 'a) Mappe.map -> 'a t
                val is_empty : 'a t -> bool
                val empty : 'a t
                val add : key -> '-> 'a t -> 'a t
                val find : key -> 'a t -> 'a
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val addmap : 'a t -> 'a t -> 'a t
                val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val combine :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val interset : 'a t -> Setkey.t -> 'a t
                val diffset : 'a t -> Setkey.t -> 'a t
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val maptoset : 'a t -> Setkey.t
                val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                val comparei :
                  (key -> '-> '-> int) -> 'a t -> 'b t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val equali :
                  (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val subseti :
                  (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                val max_key : 'a t -> key
                val choose : 'a t -> key * 'a
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  ?firstbind:(unit, Format.formatter, unit) format ->
                  ?sepbind:(unit, Format.formatter, unit) format ->
                  ?lastbind:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> key -> unit) ->
                  (Format.formatter -> '-> unit) ->
                  Format.formatter -> 'a t -> unit
              end
            type 'a lattice = (A.t, 'a) PLattice.glattice
            type 'a t = 'A.Map.t
            val sep : 'a lattice -> 'a t
            val is_sep : 'a t -> bool
            val print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              ?firstbind:(unit, Format.formatter, unit) format ->
              ?sepbind:(unit, Format.formatter, unit) format ->
              ?lastbind:(unit, Format.formatter, unit) format ->
              (Format.formatter -> A.t -> unit) ->
              (Format.formatter -> '-> unit) ->
              Format.formatter -> 'a t -> unit
            val bottom : 'a t
            val singleton : A.t -> '-> 'a t
            val normalize : 'a lattice -> 'a t -> 'a t
            val is_bottom : 'a lattice -> 'a t -> bool
            val is_leq : 'a lattice -> 'a t -> 'a t -> bool
            val is_eq : 'a lattice -> 'a t -> 'a t -> bool
            val meet : 'a lattice -> 'a t -> 'a t -> 'a t
            val join : 'a lattice -> 'a t -> 'a t -> 'a t
            val widening :
              'a lattice -> partition:'a t -> 'a t -> 'a t -> 'a t
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (A.t -> '-> 'b) -> 'a t -> 'b t
            val project :
              project:('-> A.t * '-> 'b) ->
              '-> 'b lattice -> 'b t -> 'b t
            val merge :
              empty:'-> merge:(A.t * '-> '-> 'a) -> 'b t -> 'a
            val lcm :
              ?coherent:bool ->
              meet:(A.t * '-> A.t * '-> 'a option) ->
              'a t -> 'a t -> 'MapAA.t
            val transfer :
              ?coherent:bool ->
              meet:(A.t * '-> A.t * '-> 'a option) ->
              'a lattice -> 'a t -> 'a t -> 'a t
          end
        module SetAV :
          sig
            type elt = A.t * int
            type t
            val repr : t -> elt Sette.set
            val obj : elt Sette.set -> t
            module Ord : sig type t = elt val compare : t -> t -> int end
            val empty : t
            val is_empty : t -> bool
            val mem : elt -> t -> bool
            val add : elt -> t -> t
            val singleton : elt -> t
            val remove : elt -> t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val compare : t -> t -> int
            val equal : t -> t -> bool
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val fold : (elt -> '-> 'a) -> t -> '-> 'a
            val for_all : (elt -> bool) -> t -> bool
            val exists : (elt -> bool) -> t -> bool
            val filter : (elt -> bool) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val max_elt : t -> elt
            val choose : t -> elt
            val print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              (Format.formatter -> elt -> unit) ->
              Format.formatter -> t -> unit
          end
        module MapAV :
          sig
            type key = A.t * int
            type 'a t
            module Setkey :
              sig
                type elt = A.t * int
                type t = SetAV.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            val repr : 'a t -> (key, 'a) Mappe.map
            val obj : (key, 'a) Mappe.map -> 'a t
            val is_empty : 'a t -> bool
            val empty : 'a t
            val add : key -> '-> 'a t -> 'a t
            val find : key -> 'a t -> 'a
            val remove : key -> 'a t -> 'a t
            val mem : key -> 'a t -> bool
            val addmap : 'a t -> 'a t -> 'a t
            val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
            val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
            val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val combine :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a t -> 'b t -> 'c t
            val interset : 'a t -> Setkey.t -> 'a t
            val diffset : 'a t -> Setkey.t -> 'a t
            val iter : (key -> '-> unit) -> 'a t -> unit
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val maptoset : 'a t -> Setkey.t
            val mapofset : (key -> 'a) -> Setkey.t -> 'a t
            val compare : ('-> '-> int) -> 'a t -> 'b t -> int
            val comparei : (key -> '-> '-> int) -> 'a t -> 'b t -> int
            val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val equali : (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
            val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
            val subseti : (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
            val max_key : 'a t -> key
            val choose : 'a t -> key * 'a
            val print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              ?firstbind:(unit, Format.formatter, unit) format ->
              ?sepbind:(unit, Format.formatter, unit) format ->
              ?lastbind:(unit, Format.formatter, unit) format ->
              (Format.formatter -> key -> unit) ->
              (Format.formatter -> '-> unit) ->
              Format.formatter -> 'a t -> unit
          end
        type 'a t =
            (int, 'PL.t, ('PL.lattice, 'PL.t) LAutomatonRep.info)
            LAutomatonRep.Graph.t
        type shape = unit t
        val lunit : unit PL.lattice
        val mapV_A_L_of_mapAV_L : 'MapAV.t -> 'A.Map.t MappeI.t
        val mapV_A_L_of_mapA_LxV : ('a * int) A.Map.t -> 'A.Map.t MappeI.t
        val mapV_A_L_of_mapA_LxV_list :
          ('a * int) list A.Map.t -> 'A.Map.t MappeI.t
        val check_sep : 'a t -> string -> unit
        val auto_check : 'a t -> 'a t -> string -> unit
        val add_state :
          'a t -> int -> ?initial:bool -> ?final:bool -> int -> 'a t
        val del_state : 'a t -> int -> 'a t
        val reachability : 'a t -> 'a t
        val coreachability : 'a t -> 'a t
        val print :
          (Format.formatter -> 'PL.t -> unit) ->
          Format.formatter -> 'a t -> unit
        val print_dot :
          ?margin:int ->
          ?titlestyle:string ->
          ?vertexstyle:string ->
          ?edgestyle:string ->
          ?title:string ->
          (Format.formatter -> 'PL.t -> unit) ->
          Format.formatter -> 'a t -> unit
        val bottom :
          lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
        val top : lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
        val allempty :
          lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
        val is_bottom : 'a t -> bool
        val is_top : 'a t -> bool
        val is_empty : 'a t -> int -> bool
        val is_allempty : 'a t -> bool
        val is_deterministic : ?check:bool -> 'a t -> bool
        val is_minimal : 'a t -> bool
        val shape : 'a t -> unit t
        val dimension : 'a t -> int
        module Powerset :
          sig
            type 'a pauto =
                (int, 'PL.t, LAutomatonRep.pinfo) LAutomatonRep.Graph.t
            val add_pvertex :
              'a t -> 'a pauto ref -> ?id:int -> SetteI.t -> int
          end
        module Det :
          sig
            val raise_exit_if_vertex_not_deterministic :
              'a t -> int -> succ:SetteI.t -> unit
            val is_vertex_deterministic : 'a t -> int -> bool
            val is_pvertex_deterministic : 'a t -> SetteI.t -> bool
            val succ_pvertex : 'a t -> SetteI.t -> ('a * SetteI.t) A.Map.t
            val determinise : 'a t -> 'Powerset.pauto
            val determinise_partial : 'a t -> 'Powerset.pauto
          end
        val determinise : 'a t -> 'a t
        val determinise_partial : 'a t -> 'a t
        module Bisim :
          sig
            val letters_after_pvertex : 'a t -> SetteI.t -> A.Set.t
            val succ_pvertex_by_letter :
              'a t ->
              LAutomatonRep.partition ->
              SetteI.t -> A.t -> SetteI.t ref MappeI.t * SetteI.t
          end
        val bisimulation_shape :
          ?depth:int ->
          'a t -> LAutomatonRep.partition -> LAutomatonRep.partition
        module Simulation :
          sig
            val succ_vertex_det : 'a t -> int -> ('a * int) A.Map.t
            val simulate_initial :
              ((A.t -> 'a * int -> 'a * int -> bool) ->
               ('a * int) A.Map.t -> ('a * int) A.Map.t -> bool) ->
              (A.t -> '-> '-> bool) -> 'a t -> 'a t -> bool
            val succ_vertex_nondet : 'a t -> int -> ('a * int) list A.Map.t
            exception Abort
            val simulation_initial : 'a t -> 'a t -> LAutomatonRep.simulation
            val simulation_nondet :
              ?depth:int ->
              'a t ->
              'a t -> LAutomatonRep.simulation -> LAutomatonRep.simulation
          end
        val is_leq : 'a t -> 'a t -> bool
        val is_eq : 'a t -> 'a t -> bool
        module Quotient :
          sig
            val succ_pvertex : 'a t -> int MappeI.t -> SetteI.t -> 'MapAV.t
            val quotient :
              'a t -> LAutomatonRep.partition -> 'Powerset.pauto
          end
        val quotient : 'a t -> LAutomatonRep.partition -> 'a t
        val map_trans : (int * int -> 'PL.t -> 'PL.t) -> 'a t -> 'a t
        val iter_trans : (int * int -> 'PL.t -> unit) -> 'a t -> unit
        val minimise : 'a t -> 'a t
        val canonicalise : 'a t -> 'a t
        val union : 'a t -> 'a t -> 'a t
        val complementary : 'a t -> 'a t
        module Inter :
          sig val inter : 'a t -> 'a t -> 'a t * int LAutomaton.HashII.t end
        val inter : 'a t -> 'a t -> 'a t
        val union_list : 'a t list -> 'a t
        val union_array : 'a t array -> 'a t
        val inter_list : 'a t list -> 'a t
        val inter_array : 'a t array -> 'a t
        val cons_right : 'a t -> int -> 'PL.t -> 'a t
        val deriv_right : ?cond:'PL.t -> 'a t -> int -> 'a t
        val look_right : ?cond:'PL.t -> 'a t -> int -> 'PL.t
        val cons_left : 'a t -> int -> 'PL.t -> 'a t
        val deriv_left : ?cond:'PL.t -> 'a t -> int -> 'a t
        val look_left : ?cond:'PL.t -> 'a t -> int -> 'PL.t
        val of_regexp :
          lattice:'PL.lattice ->
          partition:'PL.t -> int -> 'PL.t Regexp.t -> 'a t
        module Language :
          sig
            val look_right : ?cond:'PL.t -> 'a t -> 'PL.t
            val cons_right : 'a t -> 'PL.t -> 'a t
            val deriv_right : ?cond:'PL.t -> 'a t -> 'a t
            val look_left : ?cond:'PL.t -> 'a t -> 'PL.t
            val cons_left : 'a t -> 'PL.t -> 'a t
            val deriv_left : ?cond:'PL.t -> 'a t -> 'a t
            val empty : lattice:'PL.lattice -> partition:'PL.t -> 'a t
            val letter :
              lattice:'PL.lattice -> partition:'PL.t -> 'PL.t -> 'a t
            val word :
              lattice:'PL.lattice ->
              partition:'PL.t -> 'PL.t list -> 'a t
            val transpose : 'a t -> 'a t
            module Concat :
              sig
                val merge_trans :
                  'a t ->
                  LAutomaton.Graph.vertex * LAutomaton.Graph.vertex ->
                  'PL.t -> 'a t
                val merge_final_initial :
                  'a t -> SetteI.t -> SetteI.t -> 'a t
              end
            val concat : 'a t -> 'a t -> 'a t
            val concat_list : 'a t list -> 'a t
            val concat_array : 'a t array -> 'a t
            val star : 'a t -> 'a t
            val plus : 'a t -> 'a t
            val of_regexp :
              lattice:'PL.lattice ->
              partition:'PL.t -> 'PL.t Regexp.t -> 'a t
          end
        val is_prefix :
          projection:('-> PL.A.t * '-> 'b) ->
          'a list -> 'b t -> int -> bool
        val widening_shape : ('a t -> 'a t) -> 'a t -> 'a t -> 'a t
        module Abstract :
          sig
            val partition_std :
              ?initial:bool -> ?final:bool -> 'a t -> LAutomaton.partition
            val partition_refine :
              ?forward:bool ->
              ?backward:bool ->
              'a t -> LAutomaton.partition -> LAutomaton.partition
            val standard :
              ?initial:bool ->
              ?final:bool -> forward:int -> backward:int -> 'a t -> 'a t
          end
      end
    module NQueues :
      sig
        module PL :
          sig
            module A :
              sig
                type t = AlphaSep.t
                val sep : t
                module Set :
                  sig
                    type elt = t
                    type t = AlphaSep.Set.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                module Map :
                  sig
                    type key = t
                    type 'a t = 'AlphaSep.Map.t
                    module Setkey :
                      sig
                        type elt = t
                        type t = Set.t
                        val repr : t -> elt Sette.set
                        val obj : elt Sette.set -> t
                        module Ord :
                          sig type t = elt val compare : t -> t -> int end
                        val empty : t
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val remove : elt -> t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val compare : t -> t -> int
                        val equal : t -> t -> bool
                        val subset : t -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val cardinal : t -> int
                        val elements : t -> elt list
                        val min_elt : t -> elt
                        val max_elt : t -> elt
                        val choose : t -> elt
                        val print :
                          ?first:(unit, Format.formatter, unit) format ->
                          ?sep:(unit, Format.formatter, unit) format ->
                          ?last:(unit, Format.formatter, unit) format ->
                          (Format.formatter -> elt -> unit) ->
                          Format.formatter -> t -> unit
                      end
                    val repr : 'a t -> (key, 'a) Mappe.map
                    val obj : (key, 'a) Mappe.map -> 'a t
                    val is_empty : 'a t -> bool
                    val empty : 'a t
                    val add : key -> '-> 'a t -> 'a t
                    val find : key -> 'a t -> 'a
                    val remove : key -> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val addmap : 'a t -> 'a t -> 'a t
                    val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val mergei :
                      (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val commoni :
                      (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val combine :
                      (key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    val interset : 'a t -> Setkey.t -> 'a t
                    val diffset : 'a t -> Setkey.t -> 'a t
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : ('-> 'b) -> 'a t -> 'b t
                    val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val maptoset : 'a t -> Setkey.t
                    val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                    val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                    val comparei :
                      (key -> '-> '-> int) -> 'a t -> 'b t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val equali :
                      (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                    val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val subseti :
                      (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                    val max_key : 'a t -> key
                    val choose : 'a t -> key * 'a
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      ?firstbind:(unit, Format.formatter, unit) format ->
                      ?sepbind:(unit, Format.formatter, unit) format ->
                      ?lastbind:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> key -> unit) ->
                      (Format.formatter -> '-> unit) ->
                      Format.formatter -> 'a t -> unit
                  end
              end
            module SetAA :
              sig
                type elt = A.t * A.t
                type t = PL.SetAA.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            module MapAA :
              sig
                type key = A.t * A.t
                type 'a t = 'PL.MapAA.t
                module Setkey :
                  sig
                    type elt = A.t * A.t
                    type t = SetAA.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                val repr : 'a t -> (key, 'a) Mappe.map
                val obj : (key, 'a) Mappe.map -> 'a t
                val is_empty : 'a t -> bool
                val empty : 'a t
                val add : key -> '-> 'a t -> 'a t
                val find : key -> 'a t -> 'a
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val addmap : 'a t -> 'a t -> 'a t
                val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val combine :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val interset : 'a t -> Setkey.t -> 'a t
                val diffset : 'a t -> Setkey.t -> 'a t
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val maptoset : 'a t -> Setkey.t
                val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                val comparei :
                  (key -> '-> '-> int) -> 'a t -> 'b t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val equali :
                  (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val subseti :
                  (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                val max_key : 'a t -> key
                val choose : 'a t -> key * 'a
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  ?firstbind:(unit, Format.formatter, unit) format ->
                  ?sepbind:(unit, Format.formatter, unit) format ->
                  ?lastbind:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> key -> unit) ->
                  (Format.formatter -> '-> unit) ->
                  Format.formatter -> 'a t -> unit
              end
            type 'a lattice = (A.t, 'a) PLattice.glattice
            type 'a t = 'A.Map.t
            val sep : 'a lattice -> 'a t
            val is_sep : 'a t -> bool
            val print :
              ?first:(unit, Format.formatter, unit) format ->
              ?sep:(unit, Format.formatter, unit) format ->
              ?last:(unit, Format.formatter, unit) format ->
              ?firstbind:(unit, Format.formatter, unit) format ->
              ?sepbind:(unit, Format.formatter, unit) format ->
              ?lastbind:(unit, Format.formatter, unit) format ->
              (Format.formatter -> A.t -> unit) ->
              (Format.formatter -> '-> unit) ->
              Format.formatter -> 'a t -> unit
            val bottom : 'a t
            val singleton : A.t -> '-> 'a t
            val normalize : 'a lattice -> 'a t -> 'a t
            val is_bottom : 'a lattice -> 'a t -> bool
            val is_leq : 'a lattice -> 'a t -> 'a t -> bool
            val is_eq : 'a lattice -> 'a t -> 'a t -> bool
            val meet : 'a lattice -> 'a t -> 'a t -> 'a t
            val join : 'a lattice -> 'a t -> 'a t -> 'a t
            val widening :
              'a lattice -> partition:'a t -> 'a t -> 'a t -> 'a t
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (A.t -> '-> 'b) -> 'a t -> 'b t
            val project :
              project:('-> A.t * '-> 'b) ->
              '-> 'b lattice -> 'b t -> 'b t
            val merge :
              empty:'-> merge:(A.t * '-> '-> 'a) -> 'b t -> 'a
            val lcm :
              ?coherent:bool ->
              meet:(A.t * '-> A.t * '-> 'a option) ->
              'a t -> 'a t -> 'MapAA.t
            val transfer :
              ?coherent:bool ->
              meet:(A.t * '-> A.t * '-> 'a option) ->
              'a lattice -> 'a t -> 'a t -> 'a t
          end
        module LAuto :
          sig
            module A :
              sig
                type t = AlphaSep.t
                val sep : t
                module Set :
                  sig
                    type elt = t
                    type t = AlphaSep.Set.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                module Map :
                  sig
                    type key = t
                    type 'a t = 'AlphaSep.Map.t
                    module Setkey :
                      sig
                        type elt = t
                        type t = Set.t
                        val repr : t -> elt Sette.set
                        val obj : elt Sette.set -> t
                        module Ord :
                          sig type t = elt val compare : t -> t -> int end
                        val empty : t
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val remove : elt -> t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val compare : t -> t -> int
                        val equal : t -> t -> bool
                        val subset : t -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val cardinal : t -> int
                        val elements : t -> elt list
                        val min_elt : t -> elt
                        val max_elt : t -> elt
                        val choose : t -> elt
                        val print :
                          ?first:(unit, Format.formatter, unit) format ->
                          ?sep:(unit, Format.formatter, unit) format ->
                          ?last:(unit, Format.formatter, unit) format ->
                          (Format.formatter -> elt -> unit) ->
                          Format.formatter -> t -> unit
                      end
                    val repr : 'a t -> (key, 'a) Mappe.map
                    val obj : (key, 'a) Mappe.map -> 'a t
                    val is_empty : 'a t -> bool
                    val empty : 'a t
                    val add : key -> '-> 'a t -> 'a t
                    val find : key -> 'a t -> 'a
                    val remove : key -> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val addmap : 'a t -> 'a t -> 'a t
                    val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val mergei :
                      (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val commoni :
                      (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val combine :
                      (key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    val interset : 'a t -> Setkey.t -> 'a t
                    val diffset : 'a t -> Setkey.t -> 'a t
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : ('-> 'b) -> 'a t -> 'b t
                    val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val maptoset : 'a t -> Setkey.t
                    val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                    val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                    val comparei :
                      (key -> '-> '-> int) -> 'a t -> 'b t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val equali :
                      (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                    val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val subseti :
                      (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                    val max_key : 'a t -> key
                    val choose : 'a t -> key * 'a
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      ?firstbind:(unit, Format.formatter, unit) format ->
                      ?sepbind:(unit, Format.formatter, unit) format ->
                      ?lastbind:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> key -> unit) ->
                      (Format.formatter -> '-> unit) ->
                      Format.formatter -> 'a t -> unit
                  end
              end
            module PL :
              sig
                module A :
                  sig
                    type t = AlphaSep.t
                    val sep : t
                    module Set :
                      sig
                        type elt = t
                        type t = AlphaSep.Set.t
                        val repr : t -> elt Sette.set
                        val obj : elt Sette.set -> t
                        module Ord :
                          sig type t = elt val compare : t -> t -> int end
                        val empty : t
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val remove : elt -> t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val compare : t -> t -> int
                        val equal : t -> t -> bool
                        val subset : t -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val cardinal : t -> int
                        val elements : t -> elt list
                        val min_elt : t -> elt
                        val max_elt : t -> elt
                        val choose : t -> elt
                        val print :
                          ?first:(unit, Format.formatter, unit) format ->
                          ?sep:(unit, Format.formatter, unit) format ->
                          ?last:(unit, Format.formatter, unit) format ->
                          (Format.formatter -> elt -> unit) ->
                          Format.formatter -> t -> unit
                      end
                    module Map :
                      sig
                        type key = t
                        type 'a t = 'AlphaSep.Map.t
                        module Setkey :
                          sig
                            type elt = t
                            type t = Set.t
                            val repr : t -> elt Sette.set
                            val obj : elt Sette.set -> t
                            module Ord :
                              sig
                                type t = elt
                                val compare : t -> t -> int
                              end
                            val empty : t
                            val is_empty : t -> bool
                            val mem : elt -> t -> bool
                            val add : elt -> t -> t
                            val singleton : elt -> t
                            val remove : elt -> t -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val compare : t -> t -> int
                            val equal : t -> t -> bool
                            val subset : t -> t -> bool
                            val iter : (elt -> unit) -> t -> unit
                            val fold : (elt -> '-> 'a) -> t -> '-> 'a
                            val for_all : (elt -> bool) -> t -> bool
                            val exists : (elt -> bool) -> t -> bool
                            val filter : (elt -> bool) -> t -> t
                            val partition : (elt -> bool) -> t -> t * t
                            val cardinal : t -> int
                            val elements : t -> elt list
                            val min_elt : t -> elt
                            val max_elt : t -> elt
                            val choose : t -> elt
                            val print :
                              ?first:(unit, Format.formatter, unit) format ->
                              ?sep:(unit, Format.formatter, unit) format ->
                              ?last:(unit, Format.formatter, unit) format ->
                              (Format.formatter -> elt -> unit) ->
                              Format.formatter -> t -> unit
                          end
                        val repr : 'a t -> (key, 'a) Mappe.map
                        val obj : (key, 'a) Mappe.map -> 'a t
                        val is_empty : 'a t -> bool
                        val empty : 'a t
                        val add : key -> '-> 'a t -> 'a t
                        val find : key -> 'a t -> 'a
                        val remove : key -> 'a t -> 'a t
                        val mem : key -> 'a t -> bool
                        val addmap : 'a t -> 'a t -> 'a t
                        val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                        val mergei :
                          (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                        val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                        val commoni :
                          (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                        val combine :
                          (key -> 'a option -> 'b option -> 'c option) ->
                          'a t -> 'b t -> 'c t
                        val interset : 'a t -> Setkey.t -> 'a t
                        val diffset : 'a t -> Setkey.t -> 'a t
                        val iter : (key -> '-> unit) -> 'a t -> unit
                        val map : ('-> 'b) -> 'a t -> 'b t
                        val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                        val fold :
                          (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                        val maptoset : 'a t -> Setkey.t
                        val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                        val compare :
                          ('-> '-> int) -> 'a t -> 'b t -> int
                        val comparei :
                          (key -> '-> '-> int) -> 'a t -> 'b t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'b t -> bool
                        val equali :
                          (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                        val subset :
                          ('-> '-> bool) -> 'a t -> 'b t -> bool
                        val subseti :
                          (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                        val max_key : 'a t -> key
                        val choose : 'a t -> key * 'a
                        val print :
                          ?first:(unit, Format.formatter, unit) format ->
                          ?sep:(unit, Format.formatter, unit) format ->
                          ?last:(unit, Format.formatter, unit) format ->
                          ?firstbind:(unit, Format.formatter, unit) format ->
                          ?sepbind:(unit, Format.formatter, unit) format ->
                          ?lastbind:(unit, Format.formatter, unit) format ->
                          (Format.formatter -> key -> unit) ->
                          (Format.formatter -> '-> unit) ->
                          Format.formatter -> 'a t -> unit
                      end
                  end
                module SetAA :
                  sig
                    type elt = A.t * A.t
                    type t = PL.SetAA.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                module MapAA :
                  sig
                    type key = A.t * A.t
                    type 'a t = 'PL.MapAA.t
                    module Setkey :
                      sig
                        type elt = A.t * A.t
                        type t = SetAA.t
                        val repr : t -> elt Sette.set
                        val obj : elt Sette.set -> t
                        module Ord :
                          sig type t = elt val compare : t -> t -> int end
                        val empty : t
                        val is_empty : t -> bool
                        val mem : elt -> t -> bool
                        val add : elt -> t -> t
                        val singleton : elt -> t
                        val remove : elt -> t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val compare : t -> t -> int
                        val equal : t -> t -> bool
                        val subset : t -> t -> bool
                        val iter : (elt -> unit) -> t -> unit
                        val fold : (elt -> '-> 'a) -> t -> '-> 'a
                        val for_all : (elt -> bool) -> t -> bool
                        val exists : (elt -> bool) -> t -> bool
                        val filter : (elt -> bool) -> t -> t
                        val partition : (elt -> bool) -> t -> t * t
                        val cardinal : t -> int
                        val elements : t -> elt list
                        val min_elt : t -> elt
                        val max_elt : t -> elt
                        val choose : t -> elt
                        val print :
                          ?first:(unit, Format.formatter, unit) format ->
                          ?sep:(unit, Format.formatter, unit) format ->
                          ?last:(unit, Format.formatter, unit) format ->
                          (Format.formatter -> elt -> unit) ->
                          Format.formatter -> t -> unit
                      end
                    val repr : 'a t -> (key, 'a) Mappe.map
                    val obj : (key, 'a) Mappe.map -> 'a t
                    val is_empty : 'a t -> bool
                    val empty : 'a t
                    val add : key -> '-> 'a t -> 'a t
                    val find : key -> 'a t -> 'a
                    val remove : key -> 'a t -> 'a t
                    val mem : key -> 'a t -> bool
                    val addmap : 'a t -> 'a t -> 'a t
                    val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val mergei :
                      (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                    val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val commoni :
                      (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val combine :
                      (key -> 'a option -> 'b option -> 'c option) ->
                      'a t -> 'b t -> 'c t
                    val interset : 'a t -> Setkey.t -> 'a t
                    val diffset : 'a t -> Setkey.t -> 'a t
                    val iter : (key -> '-> unit) -> 'a t -> unit
                    val map : ('-> 'b) -> 'a t -> 'b t
                    val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                    val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                    val maptoset : 'a t -> Setkey.t
                    val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                    val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                    val comparei :
                      (key -> '-> '-> int) -> 'a t -> 'b t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val equali :
                      (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                    val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                    val subseti :
                      (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                    val max_key : 'a t -> key
                    val choose : 'a t -> key * 'a
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      ?firstbind:(unit, Format.formatter, unit) format ->
                      ?sepbind:(unit, Format.formatter, unit) format ->
                      ?lastbind:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> key -> unit) ->
                      (Format.formatter -> '-> unit) ->
                      Format.formatter -> 'a t -> unit
                  end
                type 'a lattice = (A.t, 'a) PLattice.glattice
                type 'a t = 'A.Map.t
                val sep : 'a lattice -> 'a t
                val is_sep : 'a t -> bool
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  ?firstbind:(unit, Format.formatter, unit) format ->
                  ?sepbind:(unit, Format.formatter, unit) format ->
                  ?lastbind:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> A.t -> unit) ->
                  (Format.formatter -> '-> unit) ->
                  Format.formatter -> 'a t -> unit
                val bottom : 'a t
                val singleton : A.t -> '-> 'a t
                val normalize : 'a lattice -> 'a t -> 'a t
                val is_bottom : 'a lattice -> 'a t -> bool
                val is_leq : 'a lattice -> 'a t -> 'a t -> bool
                val is_eq : 'a lattice -> 'a t -> 'a t -> bool
                val meet : 'a lattice -> 'a t -> 'a t -> 'a t
                val join : 'a lattice -> 'a t -> 'a t -> 'a t
                val widening :
                  'a lattice -> partition:'a t -> 'a t -> 'a t -> 'a t
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (A.t -> '-> 'b) -> 'a t -> 'b t
                val project :
                  project:('-> A.t * '-> 'b) ->
                  '-> 'b lattice -> 'b t -> 'b t
                val merge :
                  empty:'-> merge:(A.t * '-> '-> 'a) -> 'b t -> 'a
                val lcm :
                  ?coherent:bool ->
                  meet:(A.t * '-> A.t * '-> 'a option) ->
                  'a t -> 'a t -> 'MapAA.t
                val transfer :
                  ?coherent:bool ->
                  meet:(A.t * '-> A.t * '-> 'a option) ->
                  'a lattice -> 'a t -> 'a t -> 'a t
              end
            module SetAV :
              sig
                type elt = A.t * int
                type t = Langage.SetAV.t
                val repr : t -> elt Sette.set
                val obj : elt Sette.set -> t
                module Ord : sig type t = elt val compare : t -> t -> int end
                val empty : t
                val is_empty : t -> bool
                val mem : elt -> t -> bool
                val add : elt -> t -> t
                val singleton : elt -> t
                val remove : elt -> t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val compare : t -> t -> int
                val equal : t -> t -> bool
                val subset : t -> t -> bool
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val for_all : (elt -> bool) -> t -> bool
                val exists : (elt -> bool) -> t -> bool
                val filter : (elt -> bool) -> t -> t
                val partition : (elt -> bool) -> t -> t * t
                val cardinal : t -> int
                val elements : t -> elt list
                val min_elt : t -> elt
                val max_elt : t -> elt
                val choose : t -> elt
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> elt -> unit) ->
                  Format.formatter -> t -> unit
              end
            module MapAV :
              sig
                type key = A.t * int
                type 'a t = 'Langage.MapAV.t
                module Setkey :
                  sig
                    type elt = A.t * int
                    type t = SetAV.t
                    val repr : t -> elt Sette.set
                    val obj : elt Sette.set -> t
                    module Ord :
                      sig type t = elt val compare : t -> t -> int end
                    val empty : t
                    val is_empty : t -> bool
                    val mem : elt -> t -> bool
                    val add : elt -> t -> t
                    val singleton : elt -> t
                    val remove : elt -> t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val compare : t -> t -> int
                    val equal : t -> t -> bool
                    val subset : t -> t -> bool
                    val iter : (elt -> unit) -> t -> unit
                    val fold : (elt -> '-> 'a) -> t -> '-> 'a
                    val for_all : (elt -> bool) -> t -> bool
                    val exists : (elt -> bool) -> t -> bool
                    val filter : (elt -> bool) -> t -> t
                    val partition : (elt -> bool) -> t -> t * t
                    val cardinal : t -> int
                    val elements : t -> elt list
                    val min_elt : t -> elt
                    val max_elt : t -> elt
                    val choose : t -> elt
                    val print :
                      ?first:(unit, Format.formatter, unit) format ->
                      ?sep:(unit, Format.formatter, unit) format ->
                      ?last:(unit, Format.formatter, unit) format ->
                      (Format.formatter -> elt -> unit) ->
                      Format.formatter -> t -> unit
                  end
                val repr : 'a t -> (key, 'a) Mappe.map
                val obj : (key, 'a) Mappe.map -> 'a t
                val is_empty : 'a t -> bool
                val empty : 'a t
                val add : key -> '-> 'a t -> 'a t
                val find : key -> 'a t -> 'a
                val remove : key -> 'a t -> 'a t
                val mem : key -> 'a t -> bool
                val addmap : 'a t -> 'a t -> 'a t
                val merge : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val mergei : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
                val common : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val commoni : (key -> '-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val combine :
                  (key -> 'a option -> 'b option -> 'c option) ->
                  'a t -> 'b t -> 'c t
                val interset : 'a t -> Setkey.t -> 'a t
                val diffset : 'a t -> Setkey.t -> 'a t
                val iter : (key -> '-> unit) -> 'a t -> unit
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val maptoset : 'a t -> Setkey.t
                val mapofset : (key -> 'a) -> Setkey.t -> 'a t
                val compare : ('-> '-> int) -> 'a t -> 'b t -> int
                val comparei :
                  (key -> '-> '-> int) -> 'a t -> 'b t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val equali :
                  (key -> '-> '-> bool) -> 'a t -> 'b t -> bool
                val subset : ('-> '-> bool) -> 'a t -> 'b t -> bool
                val subseti :
                  (key -> '-> '-> bool) -> 'a t -> 'b 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 min_key : 'a t -> key
                val max_key : 'a t -> key
                val choose : 'a t -> key * 'a
                val print :
                  ?first:(unit, Format.formatter, unit) format ->
                  ?sep:(unit, Format.formatter, unit) format ->
                  ?last:(unit, Format.formatter, unit) format ->
                  ?firstbind:(unit, Format.formatter, unit) format ->
                  ?sepbind:(unit, Format.formatter, unit) format ->
                  ?lastbind:(unit, Format.formatter, unit) format ->
                  (Format.formatter -> key -> unit) ->
                  (Format.formatter -> '-> unit) ->
                  Format.formatter -> 'a t -> unit
              end
            type 'a t =
                (int, 'PL.t, ('PL.lattice, 'PL.t) LAutomatonRep.info)
                LAutomatonRep.Graph.t
            type shape = unit t
            val lunit : unit PL.lattice
            val mapV_A_L_of_mapAV_L : 'MapAV.t -> 'A.Map.t MappeI.t
            val mapV_A_L_of_mapA_LxV :
              ('a * int) A.Map.t -> 'A.Map.t MappeI.t
            val mapV_A_L_of_mapA_LxV_list :
              ('a * int) list A.Map.t -> 'A.Map.t MappeI.t
            val check_sep : 'a t -> string -> unit
            val auto_check : 'a t -> 'a t -> string -> unit
            val add_state :
              'a t -> int -> ?initial:bool -> ?final:bool -> int -> 'a t
            val del_state : 'a t -> int -> 'a t
            val reachability : 'a t -> 'a t
            val coreachability : 'a t -> 'a t
            val print :
              (Format.formatter -> 'PL.t -> unit) ->
              Format.formatter -> 'a t -> unit
            val print_dot :
              ?margin:int ->
              ?titlestyle:string ->
              ?vertexstyle:string ->
              ?edgestyle:string ->
              ?title:string ->
              (Format.formatter -> 'PL.t -> unit) ->
              Format.formatter -> 'a t -> unit
            val bottom :
              lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
            val top :
              lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
            val allempty :
              lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
            val is_bottom : 'a t -> bool
            val is_top : 'a t -> bool
            val is_empty : 'a t -> int -> bool
            val is_allempty : 'a t -> bool
            val is_deterministic : ?check:bool -> 'a t -> bool
            val is_minimal : 'a t -> bool
            val shape : 'a t -> unit t
            val dimension : 'a t -> int
            module Powerset :
              sig
                type 'a pauto =
                    (int, 'PL.t, LAutomatonRep.pinfo) LAutomatonRep.Graph.t
                val add_pvertex :
                  'a t -> 'a pauto ref -> ?id:int -> SetteI.t -> int
              end
            module Det :
              sig
                val raise_exit_if_vertex_not_deterministic :
                  'a t -> int -> succ:SetteI.t -> unit
                val is_vertex_deterministic : 'a t -> int -> bool
                val is_pvertex_deterministic : 'a t -> SetteI.t -> bool
                val succ_pvertex :
                  'a t -> SetteI.t -> ('a * SetteI.t) A.Map.t
                val determinise : 'a t -> 'Powerset.pauto
                val determinise_partial : 'a t -> 'Powerset.pauto
              end
            val determinise : 'a t -> 'a t
            val determinise_partial : 'a t -> 'a t
            module Bisim :
              sig
                val letters_after_pvertex : 'a t -> SetteI.t -> A.Set.t
                val succ_pvertex_by_letter :
                  'a t ->
                  LAutomatonRep.partition ->
                  SetteI.t -> A.t -> SetteI.t ref MappeI.t * SetteI.t
              end
            val bisimulation_shape :
              ?depth:int ->
              'a t -> LAutomatonRep.partition -> LAutomatonRep.partition
            module Simulation :
              sig
                val succ_vertex_det : 'a t -> int -> ('a * int) A.Map.t
                val simulate_initial :
                  ((A.t -> 'a * int -> 'a * int -> bool) ->
                   ('a * int) A.Map.t -> ('a * int) A.Map.t -> bool) ->
                  (A.t -> '-> '-> bool) -> 'a t -> 'a t -> bool
                val succ_vertex_nondet :
                  'a t -> int -> ('a * int) list A.Map.t
                exception Abort
                val simulation_initial :
                  'a t -> 'a t -> LAutomatonRep.simulation
                val simulation_nondet :
                  ?depth:int ->
                  'a t ->
                  'a t ->
                  LAutomatonRep.simulation -> LAutomatonRep.simulation
              end
            val is_leq : 'a t -> 'a t -> bool
            val is_eq : 'a t -> 'a t -> bool
            module Quotient :
              sig
                val succ_pvertex :
                  'a t -> int MappeI.t -> SetteI.t -> 'MapAV.t
                val quotient :
                  'a t -> LAutomatonRep.partition -> 'Powerset.pauto
              end
            val quotient : 'a t -> LAutomatonRep.partition -> 'a t
            val map_trans : (int * int -> 'PL.t -> 'PL.t) -> 'a t -> 'a t
            val iter_trans : (int * int -> 'PL.t -> unit) -> 'a t -> unit
            val minimise : 'a t -> 'a t
            val canonicalise : 'a t -> 'a t
            val union : 'a t -> 'a t -> 'a t
            val complementary : 'a t -> 'a t
            module Inter :
              sig
                val inter : 'a t -> 'a t -> 'a t * int LAutomaton.HashII.t
              end
            val inter : 'a t -> 'a t -> 'a t
            val union_list : 'a t list -> 'a t
            val union_array : 'a t array -> 'a t
            val inter_list : 'a t list -> 'a t
            val inter_array : 'a t array -> 'a t
            val cons_right : 'a t -> int -> 'PL.t -> 'a t
            val deriv_right : ?cond:'PL.t -> 'a t -> int -> 'a t
            val look_right : ?cond:'PL.t -> 'a t -> int -> 'PL.t
            val cons_left : 'a t -> int -> 'PL.t -> 'a t
            val deriv_left : ?cond:'PL.t -> 'a t -> int -> 'a t
            val look_left : ?cond:'PL.t -> 'a t -> int -> 'PL.t
            val of_regexp :
              lattice:'PL.lattice ->
              partition:'PL.t -> int -> 'PL.t Regexp.t -> 'a t
            module Language :
              sig
                val look_right : ?cond:'PL.t -> 'a t -> 'PL.t
                val cons_right : 'a t -> 'PL.t -> 'a t
                val deriv_right : ?cond:'PL.t -> 'a t -> 'a t
                val look_left : ?cond:'PL.t -> 'a t -> 'PL.t
                val cons_left : 'a t -> 'PL.t -> 'a t
                val deriv_left : ?cond:'PL.t -> 'a t -> 'a t
                val empty :
                  lattice:'PL.lattice -> partition:'PL.t -> 'a t
                val letter :
                  lattice:'PL.lattice ->
                  partition:'PL.t -> 'PL.t -> 'a t
                val word :
                  lattice:'PL.lattice ->
                  partition:'PL.t -> 'PL.t list -> 'a t
                val transpose : 'a t -> 'a t
                module Concat :
                  sig
                    val merge_trans :
                      'a t ->
                      LAutomaton.Graph.vertex * LAutomaton.Graph.vertex ->
                      'PL.t -> 'a t
                    val merge_final_initial :
                      'a t -> SetteI.t -> SetteI.t -> 'a t
                  end
                val concat : 'a t -> 'a t -> 'a t
                val concat_list : 'a t list -> 'a t
                val concat_array : 'a t array -> 'a t
                val star : 'a t -> 'a t
                val plus : 'a t -> 'a t
                val of_regexp :
                  lattice:'PL.lattice ->
                  partition:'PL.t -> 'PL.t Regexp.t -> 'a t
              end
            val is_prefix :
              projection:('-> PL.A.t * '-> 'b) ->
              'a list -> 'b t -> int -> bool
            val widening_shape : ('a t -> 'a t) -> 'a t -> 'a t -> 'a t
            module Abstract :
              sig
                val partition_std :
                  ?initial:bool ->
                  ?final:bool -> 'a t -> LAutomaton.partition
                val partition_refine :
                  ?forward:bool ->
                  ?backward:bool ->
                  'a t -> LAutomaton.partition -> LAutomaton.partition
                val standard :
                  ?initial:bool ->
                  ?final:bool -> forward:int -> backward:int -> 'a t -> 'a t
              end
          end
        type 'a t = 'LAuto.t ref
        val print :
          (Format.formatter -> 'PL.t -> unit) ->
          Format.formatter -> 'a t -> unit
        val print_dot :
          ?margin:int ->
          ?titlestyle:string ->
          ?vertexstyle:string ->
          ?edgestyle:string ->
          ?title:string ->
          (Format.formatter -> 'PL.t -> unit) ->
          Format.formatter -> 'a t -> unit
        val get_lattice : 'a t -> 'PL.lattice
        val get_partition : 'a t -> 'PL.t
        val f_determinise : 'a t -> 'a t
        val f_minimise : 'a t -> 'a t
        val determinise : 'a t -> unit
        val minimise : 'a t -> unit
        val canonicalize : 'a t -> unit
        val complementary : 'a t -> 'a t
        val is_prefix :
          projection:('-> PL.A.t * '-> 'b) ->
          'a list -> 'b t -> int -> bool
        val bottom :
          lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
        val top : lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
        val allempty :
          lattice:'PL.lattice -> partition:'PL.t -> int -> 'a t
        val is_bottom : 'a t -> bool
        val is_top : 'a t -> bool
        val is_allempty : 'a t -> bool
        val is_leq : ?det:bool -> 'a t -> 'a t -> bool
        val is_eq : ?det:bool -> 'a t -> 'a t -> bool
        val is_empty : 'a t -> int -> bool
        val join : 'a t -> 'a t -> 'a t
        val meet : 'a t -> 'a t -> 'a t
        val widening_shape :
          ('LAuto.t -> 'LAuto.t) -> 'a t -> 'a t -> 'a t
        module type Operations =
          sig
            val push : 'a t -> int -> 'PL.t -> 'a t
            val top : ?cond:'PL.t -> 'a t -> int -> 'PL.t
            val pop : ?cond:'PL.t -> 'a t -> int -> 'a t * 'PL.t
            val pop_partitioned :
              ?cond:'PL.t -> 'a t -> int -> ('a t * 'a) PL.A.Map.t
            val drop : 'a t -> int -> 'a t
            val queue : 'a t -> int -> 'PL.t -> 'a t
            val firstout : ?cond:'PL.t -> 'a t -> int -> 'PL.t
            val dequeue : ?cond:'PL.t -> 'a t -> int -> 'a t * 'PL.t
            val dequeue_partitioned :
              ?cond:'PL.t -> 'a t -> int -> ('a t * 'a) PL.A.Map.t
          end
        module Left : Operations
        module Right : Operations
        val map_trans : ('PL.t -> 'PL.t) -> 'a t -> 'a t
        val iter_trans : ('PL.t -> unit) -> 'a t -> unit
      end
    type 'a t
    val bottom : 'Scm_manager.manager -> 'PL.t -> 'PL.lattice -> 'a t
    val top : 'Scm_manager.manager -> 'PL.t -> 'PL.lattice -> 'a t
    val create_partition : 'Scm_manager.manager -> 'PL.t
    val create_lattice : 'Scm_manager.manager -> 'PL.lattice
    val init_abstr :
      'Scm_manager.manager ->
      'PL.t -> 'PL.lattice -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t
    val is_bottom : 'Scm_manager.manager -> 'a t -> bool
    val is_top : 'Scm_manager.manager -> 'a t -> bool
    val is_leq : 'Scm_manager.manager -> 'a t -> 'a t -> bool
    val is_prefix :
      'Scm_manager.manager -> string list -> 'a t -> int -> bool
    val complementary : 'Scm_manager.manager -> 'a t -> 'a t
    val determinise : 'Scm_manager.manager -> 'a t -> 'a t
    val minimise : 'Scm_manager.manager -> 'a t -> 'a t
    val join : 'Scm_manager.manager -> 'a t -> 'a t -> 'a t
    val meet : 'Scm_manager.manager -> 'a t -> 'a t -> 'a t
    val widening :
      ?initial:bool ->
      ?final:bool -> 'Scm_manager.manager -> 'a t -> 'a t -> 'a t
    val output_trans :
      'Scm_manager.manager ->
      Scm_syn.bexpr ->
      Alpha.t -> int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
    val pre_output_trans :
      'Scm_manager.manager ->
      Scm_syn.bexpr ->
      Alpha.t -> int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
    val input_trans :
      'Scm_manager.manager ->
      Scm_syn.bexpr ->
      Alpha.t -> int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
    val pre_input_trans :
      'Scm_manager.manager ->
      Scm_syn.bexpr ->
      Alpha.t -> int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
    val epsilon_trans :
      'Scm_manager.manager ->
      Scm_syn.bexpr -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
    val pre_epsilon_trans :
      'Scm_manager.manager ->
      Scm_syn.bexpr -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
    val print : 'Scm_manager.manager -> Format.formatter -> 'a t -> unit
    val print_dot :
      ?margin:int ->
      ?titlestyle:string ->
      ?vertexstyle:string ->
      ?edgestyle:string ->
      ?title:string ->
      'Scm_manager.manager -> Format.formatter -> 'a t -> unit
  end