sig
  val is_rewrite : Parsetree.relation -> bool
  val is_not_rewrite : Parsetree.relation -> bool
  val is_commutative : Parsetree.relation -> bool
  val is_associative : Parsetree.relation -> bool
  val is_involutive : Parsetree.relation -> bool
  val is_absorbing : Parsetree.relation -> bool
  val is_neutral : Parsetree.relation -> bool
  val is_idempotent : Parsetree.relation -> bool
  val is_inverse : Parsetree.relation -> bool
  val is_distributive : Parsetree.relation -> bool
  val is_nilpotent : Parsetree.relation -> bool
  val has_commutative : Parsetree.relations -> bool
  val has_associative : Parsetree.relations -> bool
  val has_idempotent : Parsetree.relations -> bool
  val has_absorbing : Parsetree.relations -> bool
  val has_absorbent : Parsetree.relations -> bool
  val has_neutral : Parsetree.relations -> bool
  val has_nilpotent : Parsetree.relations -> bool
  val has_idempotent_and_nilpotent : Parsetree.relations -> bool
  val get_relation_list : Parsetree.relations -> Parsetree.relation list
  val find_relation :
    (Parsetree.relation -> bool) ->
    Parsetree.relation list -> Parsetree.relation
  val rewrite :
    Parsetree.relations -> (Parsetree.pattern * Parsetree.expression) list
  val commutative : Parsetree.relations -> Longident.t option
  val associative : Parsetree.relations -> Parsetree.relation_side option
  val absorbent :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val absorbing :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val neutral :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val neutral_left :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val neutral_right :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val neutral_both :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val nilpotent :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator) option
  val idempotent : Parsetree.relations -> Parsetree.relation_side option
  val inverse :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator *
     Parsetree.generator option)
    option
  val distributive :
    Parsetree.relations ->
    (Parsetree.relation_side * Parsetree.generator *
     Parsetree.generator option * Parsetree.distributivity_direction)
    list
  val is_neutral_generator :
    Parsetree.generator -> Parsetree.relations -> bool
  val precedence : Parsetree.relation -> int
  val compare_side :
    Parsetree.relation_side -> Parsetree.relation_side -> int
  val eq_side : Parsetree.relation_side -> Parsetree.relation_side -> bool
  val compare_generator : Parsetree.generator -> Parsetree.generator -> int
  val eq_generator : Parsetree.generator -> Parsetree.generator -> bool
  val compare_relation :
    (Parsetree.relation -> int) ->
    Parsetree.relation -> Parsetree.relation -> int
  val sort_rels :
    (Parsetree.relation -> int) ->
    Parsetree.relation list -> Parsetree.relation list
  val sort_relations :
    (Parsetree.relation -> int) -> Parsetree.relations -> Parsetree.relations
  module RelOrd :
    sig type t = Parsetree.relation val compare : t -> t -> int end
  module RelMap :
    sig
      type key = Parsetree.relation
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val mem : key -> 'a t -> bool
      val add : key -> '-> 'a t -> 'a t
      val singleton : key -> '-> 'a t
      val remove : key -> 'a t -> 'a t
      val merge :
        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val for_all : (key -> '-> bool) -> 'a t -> bool
      val exists : (key -> '-> bool) -> 'a t -> bool
      val filter : (key -> '-> bool) -> 'a t -> 'a t
      val partition : (key -> '-> bool) -> 'a t -> 'a t * 'a t
      val cardinal : 'a t -> int
      val bindings : 'a t -> (key * 'a) list
      val min_binding : 'a t -> key * 'a
      val max_binding : 'a t -> key * 'a
      val choose : 'a t -> key * 'a
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
      val map : ('-> 'b) -> 'a t -> 'b t
      val mapi : (key -> '-> 'b) -> 'a t -> 'b t
    end
  module RelSet :
    sig
      type elt = Parsetree.relation
      type t
      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 split : elt -> t -> t * bool * t
      val map : (elt -> elt) -> t -> t
      val map_filter : (elt -> elt option) -> t -> t
      val find : (elt -> bool) -> t -> elt
      val find_opt : (elt -> 'a option) -> t -> 'a option
      val of_list : elt list -> t
      val of_list_map : ('-> elt) -> 'a list -> t
      val fprintf : t Useful.fprintf
      val union_map : ('-> t) -> 'a list -> t
    end
end