sig
module type Alphabet = StandardSem.Alphabet
module type S = StandardSem.S
module Make :
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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> 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 -> 'a) -> t -> 'a -> '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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
end
type 'a lattice = (A.t, 'a) PLattice.glattice
type 'a t = 'a 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
val bottom : 'a t
val singleton : A.t -> 'a -> '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 : ('a -> 'b) -> 'a t -> 'b t
val mapi : (A.t -> 'a -> 'b) -> 'a t -> 'b t
val project :
project:('a -> A.t * 'b -> 'b) ->
'a -> 'b lattice -> 'b t -> 'b t
val merge :
empty:'a -> merge:(A.t * 'b -> 'a -> 'a) -> 'b t -> 'a
val lcm :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> 'a option) ->
'a t -> 'a t -> 'a MapAA.t
val transfer :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> '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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> 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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare :
('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> 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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
end
type 'a lattice = (A.t, 'a) PLattice.glattice
type 'a t = 'a 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
val bottom : 'a t
val singleton : A.t -> 'a -> '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 : ('a -> 'b) -> 'a t -> 'b t
val mapi : (A.t -> 'a -> 'b) -> 'a t -> 'b t
val project :
project:('a -> A.t * 'b -> 'b) ->
'a -> 'b lattice -> 'b t -> 'b t
val merge :
empty:'a -> merge:(A.t * 'b -> 'a -> 'a) -> 'b t -> 'a
val lcm :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> 'a option) ->
'a t -> 'a t -> 'a MapAA.t
val transfer :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> '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 -> 'a) -> t -> 'a -> '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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei : (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni : (key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
end
type 'a t =
(int, 'a PL.t, ('a PL.lattice, 'a PL.t) LAutomatonRep.info)
LAutomatonRep.Graph.t
type shape = unit t
val lunit : unit PL.lattice
val mapV_A_L_of_mapAV_L : 'a MapAV.t -> 'a A.Map.t MappeI.t
val mapV_A_L_of_mapA_LxV :
('a * int) A.Map.t -> 'a A.Map.t MappeI.t
val mapV_A_L_of_mapA_LxV_list :
('a * int) list A.Map.t -> 'a 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 -> 'a PL.t -> unit) ->
Format.formatter -> 'a t -> unit
val print_dot :
?margin:int ->
?titlestyle:string ->
?vertexstyle:string ->
?edgestyle:string ->
?title:string ->
(Format.formatter -> 'a PL.t -> unit) ->
Format.formatter -> 'a t -> unit
val bottom :
lattice:'a PL.lattice -> partition:'a PL.t -> int -> 'a t
val top :
lattice:'a PL.lattice -> partition:'a PL.t -> int -> 'a t
val allempty :
lattice:'a PL.lattice -> partition:'a 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, 'a 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 -> 'a Powerset.pauto
val determinise_partial : 'a t -> 'a 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 -> 'a -> 'a -> 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 -> 'a MapAV.t
val quotient :
'a t -> LAutomatonRep.partition -> 'a Powerset.pauto
end
val quotient : 'a t -> LAutomatonRep.partition -> 'a t
val map_trans : (int * int -> 'a PL.t -> 'a PL.t) -> 'a t -> 'a t
val iter_trans : (int * int -> 'a 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 -> 'a PL.t -> 'a t
val deriv_right : ?cond:'a PL.t -> 'a t -> int -> 'a t
val look_right : ?cond:'a PL.t -> 'a t -> int -> 'a PL.t
val cons_left : 'a t -> int -> 'a PL.t -> 'a t
val deriv_left : ?cond:'a PL.t -> 'a t -> int -> 'a t
val look_left : ?cond:'a PL.t -> 'a t -> int -> 'a PL.t
val of_regexp :
lattice:'a PL.lattice ->
partition:'a PL.t -> int -> 'a PL.t Regexp.t -> 'a t
module Language :
sig
val look_right : ?cond:'a PL.t -> 'a t -> 'a PL.t
val cons_right : 'a t -> 'a PL.t -> 'a t
val deriv_right : ?cond:'a PL.t -> 'a t -> 'a t
val look_left : ?cond:'a PL.t -> 'a t -> 'a PL.t
val cons_left : 'a t -> 'a PL.t -> 'a t
val deriv_left : ?cond:'a PL.t -> 'a t -> 'a t
val empty :
lattice:'a PL.lattice -> partition:'a PL.t -> 'a t
val letter :
lattice:'a PL.lattice ->
partition:'a PL.t -> 'a PL.t -> 'a t
val word :
lattice:'a PL.lattice ->
partition:'a PL.t -> 'a 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 ->
'a 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:'a PL.lattice ->
partition:'a PL.t -> 'a PL.t Regexp.t -> 'a t
end
val is_prefix :
projection:('a -> PL.A.t * 'b -> '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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare :
('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> 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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
end
type 'a lattice = (A.t, 'a) PLattice.glattice
type 'a t = 'a 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
val bottom : 'a t
val singleton : A.t -> 'a -> '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 : ('a -> 'b) -> 'a t -> 'b t
val mapi : (A.t -> 'a -> 'b) -> 'a t -> 'b t
val project :
project:('a -> A.t * 'b -> 'b) ->
'a -> 'b lattice -> 'b t -> 'b t
val merge :
empty:'a -> merge:(A.t * 'b -> 'a -> 'a) -> 'b t -> 'a
val lcm :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> 'a option) ->
'a t -> 'a t -> 'a MapAA.t
val transfer :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> '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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare :
('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> 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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common :
('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare :
('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val subset :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) ->
'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> 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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold :
(key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare :
('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset :
('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
end
type 'a lattice = (A.t, 'a) PLattice.glattice
type 'a t = 'a 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
val bottom : 'a t
val singleton : A.t -> 'a -> '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 : ('a -> 'b) -> 'a t -> 'b t
val mapi : (A.t -> 'a -> 'b) -> 'a t -> 'b t
val project :
project:('a -> A.t * 'b -> 'b) ->
'a -> 'b lattice -> 'b t -> 'b t
val merge :
empty:'a -> merge:(A.t * 'b -> 'a -> 'a) -> 'b t -> 'a
val lcm :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> 'a option) ->
'a t -> 'a t -> 'a MapAA.t
val transfer :
?coherent:bool ->
meet:(A.t * 'a -> A.t * 'a -> '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 -> 'a) -> t -> 'a -> '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 = 'a 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 -> 'a) -> t -> 'a -> '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 -> '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 -> 'a) -> 'a t -> 'a t -> 'a t
val mergei :
(key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val common : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val commoni :
(key -> 'a -> 'b -> '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 -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val maptoset : 'a t -> Setkey.t
val mapofset : (key -> 'a) -> Setkey.t -> 'a t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val comparei :
(key -> 'a -> 'b -> int) -> 'a t -> 'b t -> int
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equali :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subset : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val subseti :
(key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition :
(key -> 'a -> 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 -> 'a -> unit) ->
Format.formatter -> 'a t -> unit
end
type 'a t =
(int, 'a PL.t,
('a PL.lattice, 'a PL.t) LAutomatonRep.info)
LAutomatonRep.Graph.t
type shape = unit t
val lunit : unit PL.lattice
val mapV_A_L_of_mapAV_L : 'a MapAV.t -> 'a A.Map.t MappeI.t
val mapV_A_L_of_mapA_LxV :
('a * int) A.Map.t -> 'a A.Map.t MappeI.t
val mapV_A_L_of_mapA_LxV_list :
('a * int) list A.Map.t -> 'a 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 -> 'a PL.t -> unit) ->
Format.formatter -> 'a t -> unit
val print_dot :
?margin:int ->
?titlestyle:string ->
?vertexstyle:string ->
?edgestyle:string ->
?title:string ->
(Format.formatter -> 'a PL.t -> unit) ->
Format.formatter -> 'a t -> unit
val bottom :
lattice:'a PL.lattice -> partition:'a PL.t -> int -> 'a t
val top :
lattice:'a PL.lattice -> partition:'a PL.t -> int -> 'a t
val allempty :
lattice:'a PL.lattice -> partition:'a 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, 'a 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 -> 'a Powerset.pauto
val determinise_partial : 'a t -> 'a 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 -> 'a -> 'a -> 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 -> 'a MapAV.t
val quotient :
'a t -> LAutomatonRep.partition -> 'a Powerset.pauto
end
val quotient : 'a t -> LAutomatonRep.partition -> 'a t
val map_trans :
(int * int -> 'a PL.t -> 'a PL.t) -> 'a t -> 'a t
val iter_trans :
(int * int -> 'a 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 -> 'a PL.t -> 'a t
val deriv_right : ?cond:'a PL.t -> 'a t -> int -> 'a t
val look_right : ?cond:'a PL.t -> 'a t -> int -> 'a PL.t
val cons_left : 'a t -> int -> 'a PL.t -> 'a t
val deriv_left : ?cond:'a PL.t -> 'a t -> int -> 'a t
val look_left : ?cond:'a PL.t -> 'a t -> int -> 'a PL.t
val of_regexp :
lattice:'a PL.lattice ->
partition:'a PL.t -> int -> 'a PL.t Regexp.t -> 'a t
module Language :
sig
val look_right : ?cond:'a PL.t -> 'a t -> 'a PL.t
val cons_right : 'a t -> 'a PL.t -> 'a t
val deriv_right : ?cond:'a PL.t -> 'a t -> 'a t
val look_left : ?cond:'a PL.t -> 'a t -> 'a PL.t
val cons_left : 'a t -> 'a PL.t -> 'a t
val deriv_left : ?cond:'a PL.t -> 'a t -> 'a t
val empty :
lattice:'a PL.lattice -> partition:'a PL.t -> 'a t
val letter :
lattice:'a PL.lattice ->
partition:'a PL.t -> 'a PL.t -> 'a t
val word :
lattice:'a PL.lattice ->
partition:'a PL.t -> 'a 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 ->
'a 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:'a PL.lattice ->
partition:'a PL.t -> 'a PL.t Regexp.t -> 'a t
end
val is_prefix :
projection:('a -> PL.A.t * 'b -> '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 = 'a LAuto.t ref
val print :
(Format.formatter -> 'a PL.t -> unit) ->
Format.formatter -> 'a t -> unit
val print_dot :
?margin:int ->
?titlestyle:string ->
?vertexstyle:string ->
?edgestyle:string ->
?title:string ->
(Format.formatter -> 'a PL.t -> unit) ->
Format.formatter -> 'a t -> unit
val get_lattice : 'a t -> 'a PL.lattice
val get_partition : 'a t -> 'a 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:('a -> PL.A.t * 'b -> 'b) ->
'a list -> 'b t -> int -> bool
val bottom :
lattice:'a PL.lattice -> partition:'a PL.t -> int -> 'a t
val top :
lattice:'a PL.lattice -> partition:'a PL.t -> int -> 'a t
val allempty :
lattice:'a PL.lattice -> partition:'a 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 :
('a LAuto.t -> 'a LAuto.t) -> 'a t -> 'a t -> 'a t
module type Operations =
sig
val push : 'a t -> int -> 'a PL.t -> 'a t
val top : ?cond:'a PL.t -> 'a t -> int -> 'a PL.t
val pop : ?cond:'a PL.t -> 'a t -> int -> 'a t * 'a PL.t
val pop_partitioned :
?cond:'a PL.t -> 'a t -> int -> ('a t * 'a) PL.A.Map.t
val drop : 'a t -> int -> 'a t
val queue : 'a t -> int -> 'a PL.t -> 'a t
val firstout : ?cond:'a PL.t -> 'a t -> int -> 'a PL.t
val dequeue : ?cond:'a PL.t -> 'a t -> int -> 'a t * 'a PL.t
val dequeue_partitioned :
?cond:'a PL.t -> 'a t -> int -> ('a t * 'a) PL.A.Map.t
end
module Left : Operations
module Right : Operations
val map_trans : ('a PL.t -> 'a PL.t) -> 'a t -> 'a t
val iter_trans : ('a PL.t -> unit) -> 'a t -> unit
end
type 'a t
val bottom :
'a Scm_manager.manager -> 'a PL.t -> 'a PL.lattice -> 'a t
val top : 'a Scm_manager.manager -> 'a PL.t -> 'a PL.lattice -> 'a t
val create_partition : 'a Scm_manager.manager -> 'a PL.t
val create_lattice : 'a Scm_manager.manager -> 'a PL.lattice
val init_abstr :
'a Scm_manager.manager ->
'a PL.t ->
'a PL.lattice -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t
val is_bottom : 'a Scm_manager.manager -> 'a t -> bool
val is_top : 'a Scm_manager.manager -> 'a t -> bool
val is_leq : 'a Scm_manager.manager -> 'a t -> 'a t -> bool
val is_prefix :
'a Scm_manager.manager -> string list -> 'a t -> int -> bool
val complementary : 'a Scm_manager.manager -> 'a t -> 'a t
val determinise : 'a Scm_manager.manager -> 'a t -> 'a t
val minimise : 'a Scm_manager.manager -> 'a t -> 'a t
val join : 'a Scm_manager.manager -> 'a t -> 'a t -> 'a t
val meet : 'a Scm_manager.manager -> 'a t -> 'a t -> 'a t
val widening :
?initial:bool ->
?final:bool -> 'a Scm_manager.manager -> 'a t -> 'a t -> 'a t
val output_trans :
'a Scm_manager.manager ->
Scm_syn.bexpr ->
Alpha.t ->
int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
val pre_output_trans :
'a Scm_manager.manager ->
Scm_syn.bexpr ->
Alpha.t ->
int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
val input_trans :
'a Scm_manager.manager ->
Scm_syn.bexpr ->
Alpha.t ->
int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
val pre_input_trans :
'a Scm_manager.manager ->
Scm_syn.bexpr ->
Alpha.t ->
int -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
val epsilon_trans :
'a Scm_manager.manager ->
Scm_syn.bexpr -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
val pre_epsilon_trans :
'a Scm_manager.manager ->
Scm_syn.bexpr -> (Scm_syn.var * Scm_syn.iexpr) list -> 'a t -> 'a t
val print :
'a Scm_manager.manager -> Format.formatter -> 'a t -> unit
val print_dot :
?margin:int ->
?titlestyle:string ->
?vertexstyle:string ->
?edgestyle:string ->
?title:string ->
'a Scm_manager.manager -> Format.formatter -> 'a t -> unit
end
end