sig
  module W :
    sig
      type t = X.t array
      type word = t
      val mul : t -> t -> t
      val one : t
      val inj : X.t -> t
      val length : t -> int
      val sub : t -> int -> int -> t
      val eq : t -> t -> bool
      val compare : t -> t -> int
      val peq : t -> int -> t -> int -> int -> bool
      val to_string : t -> string
      val included : t -> t -> bool
      val unifier : ?i:int -> t -> t -> int
      val ordered_unifiers : t -> t -> int list
      val ordered_unifiers_bicontext : t -> t -> ((t * t) * (t * t)) list
      val unifiers_bicontext : t -> t -> ((t * t) * (t * t)) list
      module Order :
        sig
          val lexicographic : (X.t -> X.t -> bool) -> t -> t -> bool
          val deglex : (X.t -> X.t -> bool) -> t -> t -> bool
        end
      module Anick :
        sig
          type t = word list
          val empty : t
          val singleton : X.t -> t
          val singletons : X.t list -> t list
          val hd : t -> word
          val tl : t -> t
          val weq : t -> t -> bool
          val eq : t list -> t list -> bool
          val compare : t list -> t list -> int
          val extend : word list -> t list -> t list
          val eval : t -> t
          val length : t -> int
          val to_string : t -> string
        end
    end
  type t =
    Presentation(X).t = {
    generators : X.t list;
    rules : (W.t * W.t) list;
  }
  val make : X.t list -> (W.t * W.t) list -> t
  val orient : (W.t -> W.t -> bool) -> t -> t
  val normalize : t -> W.t -> W.t
  val add_rule : t -> W.t * W.t -> t
  val reduce : t -> t
  val complete : (W.t -> W.t -> bool) -> t -> t
  module Make :
    functor (P : sig val presentation : t end) ->
      sig
        type t = Presentation(X).Make(P).t
        val eq : t -> t -> bool
        val mul : t -> t -> t
        val one : t
        val to_string : t -> string
        val compare : t -> t -> int
      end
end