sig
  module type S =
    sig
      module Poly : Polynomial.S
      type var
      type polynomial_expr =
          Const of Poly.t
        | Var of Sos.S.var
        | Mult_scalar of Poly.Coeff.t * Sos.S.polynomial_expr
        | Add of Sos.S.polynomial_expr * Sos.S.polynomial_expr
        | Sub of Sos.S.polynomial_expr * Sos.S.polynomial_expr
        | Mult of Sos.S.polynomial_expr * Sos.S.polynomial_expr
        | Power of Sos.S.polynomial_expr * int
        | Compose of Sos.S.polynomial_expr * Sos.S.polynomial_expr list
        | Derive of Sos.S.polynomial_expr * int
      val make :
        ?n:int -> ?d:int -> ?homogen:bool -> string -> Sos.S.polynomial_expr
      val const : Poly.t -> Sos.S.polynomial_expr
      val scalar : Poly.Coeff.t -> Sos.S.polynomial_expr
      val monomial : Monomial.t -> Sos.S.polynomial_expr
      val mult_scalar :
        Poly.Coeff.t -> Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val add :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val sub :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val mult :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val power : Sos.S.polynomial_expr -> int -> Sos.S.polynomial_expr
      val compose :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr list -> Sos.S.polynomial_expr
      val derive : Sos.S.polynomial_expr -> int -> Sos.S.polynomial_expr
      val of_list :
        (Monomial.t * Sos.S.polynomial_expr) list -> Sos.S.polynomial_expr
      exception Dimension_error
      val to_list :
        Sos.S.polynomial_expr -> (Monomial.t * Sos.S.polynomial_expr) list
      val nb_vars : Sos.S.polynomial_expr -> int
      val degree : Sos.S.polynomial_expr -> int
      val is_homogeneous : Sos.S.polynomial_expr -> bool
      val param_vars : Sos.S.polynomial_expr -> Sos.S.var list
      val ( !! ) : Poly.t -> Sos.S.polynomial_expr
      val ( ?? ) : int -> Sos.S.polynomial_expr
      val ( ! ) : Poly.Coeff.t -> Sos.S.polynomial_expr
      val ( *. ) :
        Poly.Coeff.t -> Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val ( ~- ) : Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val ( + ) :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val ( - ) :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val ( * ) :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val ( / ) :
        Sos.S.polynomial_expr -> Poly.Coeff.t -> Sos.S.polynomial_expr
      val ( /. ) : Poly.Coeff.t -> Poly.Coeff.t -> Sos.S.polynomial_expr
      val ( ** ) : Sos.S.polynomial_expr -> int -> Sos.S.polynomial_expr
      val ( >= ) :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val ( <= ) :
        Sos.S.polynomial_expr ->
        Sos.S.polynomial_expr -> Sos.S.polynomial_expr
      val pp : Stdlib.Format.formatter -> Sos.S.polynomial_expr -> unit
      val pp_names :
        string list ->
        Stdlib.Format.formatter -> Sos.S.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 : Sos.S.options
      type obj =
          Minimize of Sos.S.polynomial_expr
        | Maximize of Sos.S.polynomial_expr
        | Purefeas
      type values
      type 'a witness = Monomial.t array * 'a array array
      exception Not_linear
      val solve :
        ?options:Sos.S.options ->
        ?solver:Sdp.solver ->
        Sos.S.obj ->
        Sos.S.polynomial_expr list ->
        SdpRet.t * (float * float) * Sos.S.values * float Sos.S.witness list
      val value : Sos.S.polynomial_expr -> Sos.S.values -> Poly.Coeff.t
      val value_poly : Sos.S.polynomial_expr -> Sos.S.values -> Poly.t
      val check :
        ?options:Sos.S.options ->
        ?values:Sos.S.values ->
        Sos.S.polynomial_expr -> float Sos.S.witness -> bool
      val check_round :
        ?options:Sos.S.options ->
        ?values:Sos.S.values ->
        Sos.S.polynomial_expr list ->
        float Sos.S.witness list ->
        (Sos.S.values * Scalar.Q.t Sos.S.witness list) option
    end
  module Make :
    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
  module Q :
    sig
      module Poly :
        sig
          module Coeff :
            sig
              type t = Q.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 = Polynomial.Q.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
  module Float :
    sig
      module Poly :
        sig
          module Coeff :
            sig
              type t = float
              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 = Polynomial.Float.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
end