functor (P : Polynomial.S) ->
  sig
    module Poly :
      sig
        module Coeff :
          sig
            type t = P.Coeff.t
            val compare : t -> t -> int
            val zero : t
            val one : t
            val of_float : float -> t
            val to_float : t -> float
            val of_q : Q.t -> t
            val to_q : t -> Q.t
            val add : t -> t -> t
            val sub : t -> t -> t
            val mult : t -> t -> t
            val div : t -> t -> t
            val pp : Format.formatter -> t -> unit
            val minus_one : t
            val of_int : int -> t
            val neg : t -> t
            val inv : t -> t
            val equal : t -> t -> bool
            val leq : t -> t -> bool
            val geq : t -> t -> bool
            val lt : t -> t -> bool
            val gt : t -> t -> bool
            val sign : t -> int
            val ( ~- ) : t -> t
            val ( + ) : t -> t -> t
            val ( - ) : t -> t -> t
            val ( * ) : t -> t -> t
            val ( / ) : t -> t -> t
            val ( = ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( >= ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( > ) : t -> t -> bool
          end
        type t = P.t
        val of_list : (Monomial.t * Coeff.t) list -> t
        val to_list : t -> (Monomial.t * Coeff.t) list
        val zero : t
        val one : t
        val var : ?c:Coeff.t -> ?d:int -> int -> t
        val const : Coeff.t -> t
        val monomial : Monomial.t -> t
        val mult_scalar : Coeff.t -> t -> t
        val add : t -> t -> t
        val sub : t -> t -> t
        val mult : t -> t -> t
        val power : t -> int -> t
        exception Dimension_error
        val compose : t -> t list -> t
        val derive : t -> int -> t
        val eval : t -> Coeff.t list -> Coeff.t
        val compare : t -> t -> int
        val nb_vars : t -> int
        val degree : t -> int
        val degree_list : t -> int list
        val is_homogeneous : t -> bool
        val is_var : t -> (Coeff.t * int * int) option
        val is_const : t -> Coeff.t option
        val is_monomial : t -> Monomial.t option
        val ( ?? ) : int -> t
        val ( ! ) : Coeff.t -> t
        val ( *. ) : Coeff.t -> t -> t
        val ( ~- ) : t -> t
        val ( + ) : t -> t -> t
        val ( - ) : t -> t -> t
        val ( * ) : t -> t -> t
        val ( / ) : t -> Coeff.t -> t
        val ( /. ) : Coeff.t -> Coeff.t -> t
        val ( ** ) : t -> int -> t
        val pp : Format.formatter -> t -> unit
        val pp_names : string list -> Format.formatter -> t -> unit
        val merge :
          (Monomial.t -> Coeff.t option -> Coeff.t option -> Coeff.t option) ->
          t -> t -> t
        val fold : (Monomial.t -> Coeff.t -> 'a -> 'a) -> t -> 'a -> 'a
      end
    type var
    type polynomial_expr =
        Const of Poly.t
      | Var of var
      | Mult_scalar of Poly.Coeff.t * polynomial_expr
      | Add of polynomial_expr * polynomial_expr
      | Sub of polynomial_expr * polynomial_expr
      | Mult of polynomial_expr * polynomial_expr
      | Power of polynomial_expr * int
      | Compose of polynomial_expr * polynomial_expr list
      | Derive of polynomial_expr * int
    val make : ?n:int -> ?d:int -> ?homogen:bool -> string -> polynomial_expr
    val const : Poly.t -> polynomial_expr
    val scalar : Poly.Coeff.t -> polynomial_expr
    val monomial : Monomial.t -> polynomial_expr
    val mult_scalar : Poly.Coeff.t -> polynomial_expr -> polynomial_expr
    val add : polynomial_expr -> polynomial_expr -> polynomial_expr
    val sub : polynomial_expr -> polynomial_expr -> polynomial_expr
    val mult : polynomial_expr -> polynomial_expr -> polynomial_expr
    val power : polynomial_expr -> int -> polynomial_expr
    val compose : polynomial_expr -> polynomial_expr list -> polynomial_expr
    val derive : polynomial_expr -> int -> polynomial_expr
    val of_list : (Monomial.t * polynomial_expr) list -> polynomial_expr
    exception Dimension_error
    val to_list : polynomial_expr -> (Monomial.t * polynomial_expr) list
    val nb_vars : polynomial_expr -> int
    val degree : polynomial_expr -> int
    val is_homogeneous : polynomial_expr -> bool
    val param_vars : polynomial_expr -> var list
    val ( !! ) : Poly.t -> polynomial_expr
    val ( ?? ) : int -> polynomial_expr
    val ( ! ) : Poly.Coeff.t -> polynomial_expr
    val ( *. ) : Poly.Coeff.t -> polynomial_expr -> polynomial_expr
    val ( ~- ) : polynomial_expr -> polynomial_expr
    val ( + ) : polynomial_expr -> polynomial_expr -> polynomial_expr
    val ( - ) : polynomial_expr -> polynomial_expr -> polynomial_expr
    val ( * ) : polynomial_expr -> polynomial_expr -> polynomial_expr
    val ( / ) : polynomial_expr -> Poly.Coeff.t -> polynomial_expr
    val ( /. ) : Poly.Coeff.t -> Poly.Coeff.t -> polynomial_expr
    val ( ** ) : polynomial_expr -> int -> polynomial_expr
    val ( >= ) : polynomial_expr -> polynomial_expr -> polynomial_expr
    val ( <= ) : polynomial_expr -> polynomial_expr -> polynomial_expr
    val pp : Format.formatter -> polynomial_expr -> unit
    val pp_names : string list -> Format.formatter -> polynomial_expr -> unit
    type options = {
      sdp : Sdp.options;
      verbose : int;
      scale : bool;
      trace_obj : bool;
      dualize : bool;
      monoms : Monomial.t list list;
      pad : float;
      pad_list : float list;
    }
    val default : options
    type obj =
        Minimize of polynomial_expr
      | Maximize of polynomial_expr
      | Purefeas
    type values
    type 'a witness = Monomial.t array * 'a array array
    exception Not_linear
    val solve :
      ?options:options ->
      ?solver:Sdp.solver ->
      obj ->
      polynomial_expr list ->
      SdpRet.t * (float * float) * values * float witness list
    val value : polynomial_expr -> values -> Poly.Coeff.t
    val value_poly : polynomial_expr -> values -> Poly.t
    val check :
      ?options:options ->
      ?values:values -> polynomial_expr -> float witness -> bool
    val check_round :
      ?options:options ->
      ?values:values ->
      polynomial_expr list ->
      float witness list -> (values * Scalar.Q.t witness list) option
  end