Fixes

Author: blegat

src/Bridges/Constraint/sos_polynomial.jl

@@ -3,21 +3,20 @@ struct SOSPolynomialBridge{
     F<:MOI.AbstractVectorFunction,
     DT<:SemialgebraicSets.AbstractSemialgebraicSet,
     M, # matrix cone type
+    BT,
     B,
     G<:SA.ExplicitBasis,
     CT<:SOS.Certificate.AbstractIdealCertificate,
-    MT<:MP.AbstractMonomial,
-    MVT<:AbstractVector{MT},
     W<:SA.AlgebraElement,
 } <: MOI.Bridges.Constraint.SetMapBridge{
     T,
     SOS.WeightedSOSCone{M,B,G,W},
-    SOS.SOSPolynomialSet{DT,MB.SubBasis{MB.Monomial,MT,MVT},CT},
+    SOS.SOSPolynomialSet{DT,BT,CT},
     F,
     F,
 }
     constraint::MOI.ConstraintIndex{F,SOS.WeightedSOSCone{M,B,G,W}}
-    set::SOS.SOSPolynomialSet{DT,MB.SubBasis{MB.Monomial,MT,MVT},CT}
+    set::SOS.SOSPolynomialSet{DT,BT,CT}
     new_basis::B
     flat_indices::Union{Int,Base.UnitRange{Int}}
 end
@@ -42,11 +41,11 @@ function _flatten(
 end
 
 function MOI.Bridges.Constraint.bridge_constraint(
-    ::Type{SOSPolynomialBridge{T,F,DT,M,B,G,CT,MT,MVT,W}},
+    ::Type{SOSPolynomialBridge{T,F,DT,M,BT,B,G,CT,W}},
     model::MOI.ModelLike,
     func::MOI.AbstractVectorFunction,
     set::SOS.SOSPolynomialSet{<:SemialgebraicSets.AbstractAlgebraicSet},
-) where {T,F,DT,M,B,G,CT,MT,MVT,W}
+) where {T,F,DT,M,BT,B,G,CT,W}
     @assert MOI.output_dimension(func) == length(set.basis)
     # As `*(::MOI.ScalarAffineFunction{T}, ::S)` is only defined if `S == T`, we
     # need to call `similar`. This is critical since `T` is
@@ -82,7 +81,7 @@ function MOI.Bridges.Constraint.bridge_constraint(
         MOI.Utilities.vectorize(new_coeffs),
         SOS.WeightedSOSCone{M}(new_basis, flat_gram_bases, flat_weights),
     )
-    return SOSPolynomialBridge{T,F,DT,M,B,G,CT,MT,MVT,W}(
+    return SOSPolynomialBridge{T,F,DT,M,BT,B,G,CT,W}(
         constraint,
         set,
         new_basis,
@@ -104,23 +103,22 @@ _eltype(::Type{T}) where T = T
 function MOI.Bridges.Constraint.concrete_bridge_type(
     ::Type{<:SOSPolynomialBridge{T}},
     F::Type{<:MOI.AbstractVectorFunction},
-    ::Type{SOS.SOSPolynomialSet{DT,MB.SubBasis{MB.Monomial,MT,MVT},CT}},
-) where {T,DT<:SemialgebraicSets.AbstractAlgebraicSet,MT,MVT,CT}
+    ::Type{SOS.SOSPolynomialSet{DT,BT,CT}},
+) where {T,DT<:SemialgebraicSets.AbstractAlgebraicSet,BT,CT}
     # promotes VectorOfVariables into VectorAffineFunction, it should be enough
     # for most use cases
     M = SOS.matrix_cone_type(CT)
-    B = MB.SubBasis{MB.Monomial,MT,MVT}
-    W = SA.AlgebraElement{MB.algebra_type(B),T,Vector{T}}
-    R = MA.promote_operation(
+    W = SA.AlgebraElement{MB.algebra_type(BT),T,Vector{T}}
+    B = MA.promote_operation(
         SOS.Certificate.reduced_basis,
         CT,
-        B,
+        BT,
         SemialgebraicSets.similar_type(DT, T),
-        Vector{MB.SubBasis{MB.Monomial,MT,MVT}},
+        Vector{BT},
         Vector{W},
     )
-    G = SOS.Certificate.gram_basis_type(CT, MT)
-    return SOSPolynomialBridge{T,F,DT,M,R,_eltype(G),CT,MT,MVT,W}
+    G = SOS.Certificate.gram_basis_type(CT)
+    return SOSPolynomialBridge{T,F,DT,M,BT,B,_eltype(G),CT,W}
 end
 
 function MOI.Bridges.inverse_map_function(::SOSPolynomialBridge, f)

src/Certificate/Sparsity/ideal.jl

@@ -85,9 +85,8 @@ function SumOfSquares.Certificate.gram_basis(certificate::Ideal, poly)
 end
 function SumOfSquares.Certificate.gram_basis_type(
     ::Type{Ideal{S,C}},
-    ::Type{M},
-) where {S,C,M}
-    return Vector{SumOfSquares.Certificate.gram_basis_type(C, M)}
+) where {S,C}
+    return Vector{SumOfSquares.Certificate.gram_basis_type(C)}
 end
 function SumOfSquares.Certificate.reduced_polynomial(
     certificate::Ideal,

src/Certificate/Symmetry/wedderburn.jl

@@ -77,8 +77,7 @@ function SumOfSquares.matrix_cone_type(::Type{<:Ideal{C}}) where {C}
 end
 function SumOfSquares.Certificate.gram_basis_type(
     ::Type{<:Ideal},
-    ::Type{M},
-) where {M}
+)
     return Vector{Vector{MB.FixedPolynomialBasis}}
 end
 SumOfSquares.Certificate.zero_basis_type(::Type{<:Ideal}) = MB.Monomial

src/Certificate/ideal.jl

@@ -117,7 +117,7 @@ function gram_basis(certificate::MaxDegree, poly)
         certificate.maxdegree,
     )
 end
-function gram_basis_type(::Type{MaxDegree{C,B}}, ::Type{M}) where {C,B,M} # TODO remove `M` it's not needed anymore
+function gram_basis_type(::Type{MaxDegree{C,B}}) where {C,B}
     return MB.explicit_basis_type(B)
 end
 
@@ -141,7 +141,7 @@ end
 function gram_basis(certificate::FixedBasis, _)
     return certificate.basis
 end
-gram_basis_type(::Type{FixedBasis{C,B}}, ::Type) where {C,B} = B
+gram_basis_type(::Type{FixedBasis{C,B}}) where {C,B} = B
 
 """
     struct Newton{
@@ -184,11 +184,11 @@ end
 function gram_basis(certificate::Newton, basis)
     return MB.basis_covering_monomials(
         certificate.basis,
-        monomials_half_newton_polytope(SA.basis(basis), certificate.newton),
+        half_newton_polytope(SA.basis(basis), certificate.newton),
     )
 end
 
-function gram_basis_type(::Type{<:Newton{C,B}}, ::Type{M}) where {C,B,M}
+function gram_basis_type(::Type{<:Newton{C,B}}) where {C,B}
     return MB.explicit_basis_type(B)
 end
 
@@ -233,8 +233,8 @@ function gram_basis(certificate::Remainder, poly)
     return gram_basis(certificate.gram_certificate, poly)
 end
 
-function gram_basis_type(::Type{Remainder{GCT}}, ::Type{M}) where {GCT,M}
-    return gram_basis_type(GCT, M)
+function gram_basis_type(::Type{Remainder{GCT}}) where {GCT}
+    return gram_basis_type(GCT)
 end
 
 cone(certificate::Remainder) = cone(certificate.gram_certificate)

src/Certificate/newton_polytope.jl

@@ -204,7 +204,7 @@ function half_newton_polytope(X::AbstractVector, ::NewtonDegreeBounds{Tuple{}})
     end
 end
 
-function half_newton_polytope(monos::AbstractVector, newton::NewtonFilter)
+function half_newton_polytope(basis::SA.ExplicitBasis, newton::NewtonFilter)
     gram_monos = half_newton_polytope(monos, newton.outer_approximation)
     return post_filter(gram_monos, monos)
 end
@@ -273,21 +273,6 @@ function post_filter(monos, X)
     return monos[findall(keep)]
 end
 
-# FIXME update API with basis, this is a hack
-function monomials_half_newton_polytope(
-    basis::MB.SubBasis{MB.Monomial},
-    newton::AbstractNewtonPolytopeApproximation,
-)
-    return half_newton_polytope(basis.monomials, newton)
-end
-
-function monomials_half_newton_polytope(
-    monos::AbstractVector,
-    newton::AbstractNewtonPolytopeApproximation,
-)
-    return half_newton_polytope(MP.monomial_vector(monos), newton)
-end
-
 struct DegreeBounds{M}
     mindegree::Int
     maxdegree::Int

src/Certificate/preorder.jl

@@ -144,8 +144,8 @@ function multiplier_basis(
 )
     return domain.bases[index.value]
 end
-function multiplier_basis_type(::Type{<:Putinar{MC}}, ::Type{M}) where {MC,M}
-    return gram_basis_type(MC, M)
+function multiplier_basis_type(::Type{<:Putinar{MC}}) where {MC}
+    return gram_basis_type(MC)
 end
 
 function generator(

test/certificate.jl

@@ -204,7 +204,7 @@ function certificate_api(certificate::Certificate.AbstractIdealCertificate)
     ) isa Tuple
     _basis_check(
         Certificate.gram_basis(certificate, basis),
-        Certificate.gram_basis_type(typeof(certificate), MP.monomial_type(x)),
+        Certificate.gram_basis_type(typeof(certificate)),
     )
     zbasis = Certificate.zero_basis(certificate)
     @test zbasis isa SA.AbstractBasis