### Install SumOfSquares.jl

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/README.md

Install the SumOfSquares package using Julia's package manager. This is a one-time setup step.

```julia
import Pkg
Pkg.add("SumOfSquares")
```

--------------------------------

### Quadratic Form Example

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/sumofsquares.md

Illustrates a quadratic form $p(x) = x^\top Q x$ and its relation to a positive semidefinite matrix Q. The Cholesky decomposition provides a certificate of nonnegativity.

```math
x_1^2 + 2x_1x_2 + 5x_2^2 + 4x_2x_3 + x_3^2 = x^\top \begin{pmatrix}1 & 1 & 0\\1 & 5 & 2\\0 & 2 & 1\end{pmatrix} x
```

```math
(x_1 + x_2)^2 + (2x_2 + x_3)^2 = x^\top \begin{pmatrix}1 & 1 & 0\\0 & 2 & 1\end{pmatrix}^\top \begin{pmatrix}1 & 1 & 0\\0 & 2 & 1\end{pmatrix} x
```

--------------------------------

### Specifying a Scaled Monomial Basis for a Constraint

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

This example demonstrates how to explicitly set the polynomial basis to `ScaledMonomial` for a sum-of-squares constraint. This can offer numerical advantages in certain cases.

```julia
julia> @constraint(model, α * x^2 + β * y^2 ≥ (α - β) * x * y, basis = ScaledMonomial)
(β)·y² + (-α + β)·xy + (α)·x² is SOS
```

--------------------------------

### Motzkin's Polynomial Example

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/sumofsquares.md

Presents Motzkin's polynomial, which is nonnegative for all x but not a sum of squares. It can still be certified using sum-of-squares programming with a rational decomposition.

```math
x_1^4x_2^2 + x_1^2x_2^4 + 1 - 3x_1^2x_2^2 \geq 0 \quad \forall x
```

--------------------------------

### Polynomial Nonnegativity Example

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/sumofsquares.md

Generalizes polynomial nonnegativity to arbitrary degrees using a vector of monomials X and a symmetric positive semidefinite matrix Q. The Cholesky factorization yields a sum of squares certificate.

```math
x_1^2 + 2x_1^2x_2 + 5x_1^2x_2^2 + 4x_1x_2^2 + x_2^2 = X^\top \begin{pmatrix}1 & 1 & 0\\1 & 5 & 2\\0 & 2 & 1\end{pmatrix} X
```

```math
(x_1 + x_1x_2)^2 + (2x_1x_2 + x_2)^2 = X^\top \begin{pmatrix}1 & 1 & 0\\0 & 2 & 1\end{pmatrix}^\top \begin{pmatrix}1 & 1 & 0\\0 & 2 & 1\end{pmatrix} X
```

--------------------------------

### Get Dual of a Polynomial Constraint

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Retrieves the dual of a polynomial constraint `cref` as a moment series `μ`. This is useful for understanding the dual problem in polynomial optimization.

```julia
μ = dual(cref)
```

--------------------------------

### Get Moment Matrix of a Polynomial Constraint

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Retrieves the moment matrix `ν` for a Sum-of-Squares constraint `cref`. This can be used to check for atomic measures and in polynomial optimization or stability analysis.

```julia
ν = moment_matrix(cref)
```

--------------------------------

### Get Moments of a Polynomial Constraint

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Retrieves the moments of a polynomial constraint `cref` using the `moments` function. This may differ from `dual(cref)` due to how remainders and domains are handled.

```julia
μ = moments(cref)
```

--------------------------------

### Preorder Certificate Types

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Lists the available types for preorder certificates.

```julia
```@docs
SumOfSquares.Certificate.Putinar
SumOfSquares.Certificate.Sparsity.Preorder
```
```

--------------------------------

### Create SOSModel for Automatic Interpretation

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Initialize a JuMP model using `SOSModel` to automatically interpret polynomial nonnegativity constraints as sum-of-squares constraints.

```julia
model = SOSModel(...)
```

--------------------------------

### Preorder Certificates

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Lists the types of preorder certificates available.

```APIDOC
## Preorder Certificates

### Description

These are certificates that are based on preorder properties.

- `SumOfSquares.Certificate.Putinar`
- `SumOfSquares.Certificate.Sparsity.Preorder`
```

--------------------------------

### Set Polynomial Module to SAGE

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Configures the model to use the SAGE cone instead of the Sum-of-Squares cone for inequality constraints between polynomials. This requires importing PolyJuMP.

```julia
import PolyJuMP
PolyJuMP.setpolymodule!(model, PolyJuMP.SAGE)
```

--------------------------------

### Certificate Sparsity Types

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Lists the available types for sparsity in certificates.

```julia
```@docs
SumOfSquares.Certificate.Sparsity.Variable
SumOfSquares.Certificate.Sparsity.Monomial
SumOfSquares.Certificate.Sparsity.SignSymmetry
SumOfSquares.Certificate.Sparsity.XORSpace
```
```

--------------------------------

### Chordal Extension Graph Operations

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Demonstrates various operations on chordal extension graphs, including neighbor retrieval, clique checking, and graph manipulation.

```julia
```@docs
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.neighbors
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.is_clique
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.LabelledGraph
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.add_node!
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.add_edge!
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.add_clique!
SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.completion
```
```

--------------------------------

### Ideal Certificate Types

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Lists the available types for ideal certificates.

```julia
```@docs
SumOfSquares.Certificate.MaxDegree
SumOfSquares.Certificate.FixedBasis
SumOfSquares.Certificate.Newton
SumOfSquares.Certificate.Remainder
SumOfSquares.Certificate.Sparsity.Ideal
SumOfSquares.Certificate.Symmetry.Ideal
```
```

--------------------------------

### Set Default Cone for Diagonally-Dominant Polynomials

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Configure `PolyJuMP.setdefault!` to use the `DSOSCone` for polynomial nonnegativity constraints, enabling diagonally-dominant sum-of-squares interpretations.

```jldoctest
julia> PolyJuMP.setdefault!(model, PolyJuMP.NonNegPoly, DSOSCone)
DSOSCone (alias for NonnegPolyInnerCone{SumOfSquares.DiagonallyDominantConeTriangle})
```

--------------------------------

### Equality Constraint Between Polynomials

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Defines two quadratic polynomials, p and q, and constrains their sum to be equal to 1. This demonstrates the use of `@polyvar` for polynomial variables and `@constraint` for defining polynomial equalities.

```jldoctest
julia> n = 3
3

julia> using DynamicPolynomials

julia> @polyvar x[1:n]
(Variable{DynamicPolynomials.Commutative{DynamicPolynomials.CreationOrder}, Graded{LexOrder}}[x₁, x₂, x₃],)

julia> X = monomials(x, 0:2)
10-element MonomialVector{DynamicPolynomials.Commutative{DynamicPolynomials.CreationOrder}, Graded{LexOrder}}:
 1
 x₃
 x₂
 x₁
 x₃²
 x₂x₃
 x₂²
 x₁x₃
 x₁x₂
 x₁²

julia> using SumOfSquares

julia> model = Model();

julia> @variable(model, p, Poly(X))
(_[1])·1 + (_[2])·x₃ + (_[3])·x₂ + (_[4])·x₁ + (_[5])·x₃² + (_[6])·x₂x₃ + (_[7])·x₂² + (_[8])·x₁x₃ + (_[9])·x₁x₂ + (_[10])·x₁²

julia> @variable(model, q, Poly(X))
(_[11])·1 + (_[12])·x₃ + (_[13])·x₂ + (_[14])·x₁ + (_[15])·x₃² + (_[16])·x₂x₃ + (_[17])·x₂² + (_[18])·x₁x₃ + (_[19])·x₁x₂ + (_[20])·x₁²

julia> @constraint(model, p + q == 1)
(_[1] + _[11] - 1)·1 + (_[2] + _[12])·x₃ + (_[3] + _[13])·x₂ + (_[4] + _[14])·x₁ + (_[5] + _[15])·x₃² + (_[6] + _[16])·x₂x₃ + (_[7] + _[17])·x₂² + (_[8] + _[18])·x₁x₃ + (_[9] + _[19])·x₁x₂ + (_[10] + _[20])·x₁² ∈ PolyJuMP.ZeroPoly()
```

--------------------------------

### Create Sum-of-Squares Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Use `SOSPoly(X)` to create a matrix of sum-of-squares polynomial variables. The resulting polynomial `p` is defined as `X' * Q * X`, where `Q` is a positive semidefinite matrix of variables. This is useful for expressing polynomials as sums of squares.

```jldoctest
julia> @variable(model, [1:2], SOSPoly(X))
```

--------------------------------

### Define Polynomial with Decision Variable Coefficients

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Create a polynomial where coefficients are JuMP decision variables. This demonstrates a flexible way to define polynomials.

```jldoctest variables
julia> @variable(model, α)
α

julia> @variable(model, β)
β

julia> p = α*x^2 + (α+β)*y^2*x + β*y^3
(α)x² + (β)y³ + (α + β)xy²
```

--------------------------------

### Ideal Certificates

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Lists the types of ideal certificates available.

```APIDOC
## Ideal Certificates

### Description

These are certificates that are based on ideal properties.

- `SumOfSquares.Certificate.MaxDegree`
- `SumOfSquares.Certificate.FixedBasis`
- `SumOfSquares.Certificate.Newton`
- `SumOfSquares.Certificate.Remainder`
- `SumOfSquares.Certificate.Sparsity.Ideal`
- `SumOfSquares.Certificate.Symmetry.Ideal`
```

--------------------------------

### Create Quadratic Form Variable with Scaled Monomial Basis

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

This snippet demonstrates creating a quadratic form variable using a scaled monomial basis. It involves defining the monomials, creating the scaled basis, and then defining the polynomial variable.

```julia
X = monomials([x, y], 2)

scaled_basis = SubBasis{ScaledMonomial}(X)

p = @variable(model, variable_type=Poly(scaled_basis))

polynomial(p)
```

--------------------------------

### Set SumOfSquares Module After Model Creation

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Alternatively, call `setpolymodule!` with `SumOfSquares` after creating a standard `Model` to enable automatic interpretation of polynomial nonnegativity as SOS constraints.

```jldoctest
julia> setpolymodule!(model, SumOfSquares)
SumOfSquares
```

--------------------------------

### Set Default Cones for Polynomial Constraints

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Use `PolyJuMP.setdefault!` to specify the default cone for polynomial nonnegativity (`NonNegPoly`) and matrix-of-polynomial nonnegativity (`PosDefPolyMatrix`).

```julia
PolyJuMP.setdefault!(model, PolyJuMP.NonNegPoly, SOSCone)
```

```julia
PolyJuMP.setdefault!(model, PolyJuMP.PosDefPolyMatrix, SOSMatrixCone)
```

--------------------------------

### Sparsity Types

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Defines the different types of sparsity available for certificates.

```APIDOC
## Sparsity Types

### Description

These types represent different ways sparsity can be defined or utilized within certificates.

- `SumOfSquares.Certificate.Sparsity.Variable`
- `SumOfSquares.Certificate.Sparsity.Monomial`
- `SumOfSquares.Certificate.Sparsity.SignSymmetry`
- `SumOfSquares.Certificate.Sparsity.XORSpace`
```

--------------------------------

### Defining a Quadratic Polynomial Constraint

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

This snippet shows how to define a quadratic polynomial constraint using JuMP decision variables and DynamicPolynomials. The constraint is a quadratic form that needs to be proven non-negative.

```julia
julia> using DynamicPolynomials

julia> @polyvar x y
(x, y)

julia> using SumOfSquares

julia> model = SOSModel();

julia> @variable(model, α)
α

julia> @variable(model, β)
β

julia> @constraint(model, α * x^2 + β * y^2 ≥ (α - β) * x * y)
(β)·y² + (-α + β)·xy + (α)·x² is SOS
```

--------------------------------

### Default Max Degree

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Shows the default choice for the `maxdegree` keyword.

```julia
```@docs
SumOfSquares.default_maxdegree
```
```

--------------------------------

### Chordal Extension Graph Operations

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Provides functions for manipulating and querying chordal extension graphs.

```APIDOC
## Chordal Extension Graph Operations

### Description

This section details operations available for chordal extension graphs, used in sparsity computations.

### Functions

- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.neighbors(graph, node)`: Returns the neighbors of a given node.
- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.is_clique(graph, nodes)`: Checks if a set of nodes forms a clique.
- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.LabelledGraph`: Represents a graph with labelled nodes.
- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.add_node!(graph, node)`: Adds a node to the graph.
- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.add_edge!(graph, node1, node2)`: Adds an edge between two nodes.
- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.add_clique!(graph, nodes)`: Adds a clique to the graph.
- `SumOfSquares.Certificate.Sparsity.ChordalExtensionGraph.completion(graph)`: Computes the chordal completion of the graph.
```

--------------------------------

### Create Matrix of Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Declare a matrix of polynomial decision variables using the `@variable` macro with specified dimensions and the `Poly(X)` type.

```jldoctest variables; filter = [r"(Matrix|Vector|DenseAxisArray|SparseAxisArray)\{.*\}" => s"\1{…}"]
julia> @variable(model, [1:3, 1:4], Poly(X))       # Creates a Matrix
3×4 Matrix{…}:
 (_[7])·1 + (_[8])·y + (_[9])·x + (_[10])·y² + (_[11])·xy + (_[12])·x²     …  (_[61])·1 + (_[62])·y + (_[63])·x + (_[64])·y² + (_[65])·xy + (_[66])·x²
 (_[13])·1 + (_[14])·y + (_[15])·x + (_[16])·y² + (_[17])·xy + (_[18])·x²     (_[67])·1 + (_[68])·y + (_[69])·x + (_[70])·y² + (_[71])·xy + (_[72])·x²
 (_[19])·1 + (_[20])·y + (_[21])·x + (_[22])·y² + (_[23])·xy + (_[24])·x²     (_[73])·1 + (_[74])·y + (_[75])·x + (_[76])·y² + (_[77])·xy + (_[78])·x²
```

--------------------------------

### Constrain Polynomial to be Sum-of-Squares

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Use the `@constraint` macro with the `in` syntax to specify that a polynomial `p` must belong to the `SOSCone`.

```jldoctest
julia> @constraint(model, p in SOSCone())
(_[1])·1 + (_[2])·x₃ + (_[3])·x₂ + (_[4])·x₁ + (_[5])·x₃² + (_[6])·x₂x₃ + (_[7])·x₂² + (_[8])·x₁x₃ + (_[9])·x₁x₂ + (_[10])·x₁² is SOS
```

--------------------------------

### Create Univariate Cubic Polynomial Variable with Chebyshev Basis

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Use this snippet to define a polynomial variable of degree 3 using the Chebyshev basis. Ensure the necessary basis and variable types are imported.

```julia
cheby_basis = SubBasis{Chebyshev}(monomials(x, 0:3))

@variable(model, variable_type=Poly(cheby_basis))
```

--------------------------------

### Create SparseAxisArray of Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Declare a SparseAxisArray of polynomial decision variables with a triangular index range using the `@variable` macro.

```jldoctest variables; filter = [r"(Matrix|Vector|DenseAxisArray|SparseAxisArray)\{.*\}" => s"\1{…}"]
julia> @variable(model, [i=1:3, j=i:3], Poly(X))   # Creates a SparseAxisArray
JuMP.Containers.SparseAxisArray{…} with 6 entries:
  [1, 1]  =  (_[139])·1 + (_[140])·y + (_[141])·x + (_[142])·y^2 + (_[143])·x*y + (_[144])·x^2
  [1, 2]  =  (_[145])·1 + (_[146])·y + (_[147])·x + (_[148])·y^2 + (_[149])·x*y + (_[150])·x^2
  [1, 3]  =  (_[151])·1 + (_[152])·y + (_[153])·x + (_[154])·y^2 + (_[155])·x*y + (_[156])·x^2
  [2, 2]  =  (_[157])·1 + (_[158])·y + (_[159])·x + (_[160])·y^2 + (_[161])·x*y + (_[162])·x^2
  [2, 3]  =  (_[163])·1 + (_[164])·y + (_[165])·x + (_[166])·y^2 + (_[167])·x*y + (_[168])·x^2
  [3, 3]  =  (_[169])·1 + (_[170])·y + (_[171])·x + (_[172])·y^2 + (_[173])·x*y + (_[174])·x^2
```

--------------------------------

### Define Polynomial with Quadratic Decision Variable Coefficients

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Define a polynomial where coefficients can be quadratic expressions of JuMP decision variables. This showcases advanced polynomial construction.

```jldoctest variables
julia> p = (3α^2+β)*x^2 + (α*β+2β)*y^2*x + β*y^3
(3 α² + β)x² + (β)y³ + (α*β + 2 β)xy²
```

--------------------------------

### Generate Monomial Basis

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Create a vector of monomials up to a specified degree using the `monomials` function. This is used to define the basis for polynomial variables.

```jldoctest variables
julia> X = monomials([x, y], 0:2)
6-element MonomialVector{DynamicPolynomials.Commutative{DynamicPolynomials.CreationOrder}, Graded{LexOrder}}:
 1
 y
 x
 y²
 xy
 x²
```

--------------------------------

### Create DenseAxisArray of Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Declare a DenseAxisArray of polynomial decision variables with custom index sets using the `@variable` macro.

```jldoctest variables; filter = [r"(Matrix|Vector|DenseAxisArray|SparseAxisArray)\{.*\}" => s"\1{…}"]
julia> @variable(model, [[:a, :b], -2:2], Poly(X)) # Creates a DenseAxisArray
2-dimensional DenseAxisArray{…} with index sets:
    Dimension 1, [:a, :b]
    Dimension 2, -2:2
And data, a 2×5 Matrix{…}:
 (_[79])·1 + (_[80])·y + (_[81])·x + (_[82])·y² + (_[83])·xy + (_[84])·x²  …  (_[127])·1 + (_[128])·y + (_[129])·x + (_[130])·y² + (_[131])·xy + (_[132])·x²
 (_[85])·1 + (_[86])·y + (_[87])·x + (_[88])·y² + (_[89])·xy + (_[90])·x²     (_[133])·1 + (_[134])·y + (_[135])·x + (_[136])·y² + (_[137])·xy + (_[138])·x²
```

--------------------------------

### Declare a Polynomial Decision Variable

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Create a polynomial decision variable `p` parametrized by a polynomial basis `X` within a JuMP model. This involves creating a vector of decision variables and setting `p` as their scalar product with `X`.

```jldoctest variables
julia> using SumOfSquares

julia> model = Model();

julia> @variable(model, p, Poly(X))
(_[1])·1 + (_[2])·y + (_[3])·x + (_[4])·y² + (_[5])·xy + (_[6])·x²
```

--------------------------------

### Define Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Use the `@polyvar` macro to declare polynomial variables. These are distinct from JuMP's decision variables.

```jldoctest variables
julia> using DynamicPolynomials # or TypedPolynomials, pick your favorite

julia> @polyvar x y
(x, y)
```

--------------------------------

### Default Max Degree

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/reference/certificate.md

Provides the default choice for the `maxdegree` keyword.

```APIDOC
## `SumOfSquares.default_maxdegree`

### Description

Returns the default value for the `maxdegree` keyword argument.

### Usage

```julia
default_maxdegree()
```
```

--------------------------------

### Create Diagonally-Dominant Sum-of-Squares Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Use `DSOSPoly(X)` to create diagonally-dominant sum-of-squares polynomial variables. This method generates a diagonally dominant matrix of variables `Q` and sets the polynomial variables to `X' * Q * X`, as described in Ahmadi2017; Definition 3.1.

```julia
DSOSPoly(X)
```

--------------------------------

### Create Scaled Diagonally-Dominant Sum-of-Squares Polynomial Variables

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/variables.md

Use `SDSOSPoly(X)` to create scaled diagonally-dominant sum-of-squares polynomial variables. This approach involves a scaled diagonally dominant matrix of variables `Q`, with the polynomial variables defined by `X' * Q * X`, following Ahmadi2017; Definition 3.2.

```julia
SDSOSPoly(X)
```

--------------------------------

### Define Polynomial Nonnegativity Constraint

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Constrains a polynomial to be nonnegative for all real numbers x and y. This is the default behavior.

```jldoctest
julia> @constraint(model, x^3 - x^2 + 2x*y -y^2 + y^3 >= α)
(-α)·1 + (-1)·y² + (2)·xy + (-1)·x² + (1)·y³ + (1)·x³ is SOS
```

--------------------------------

### Define Polynomial Nonnegativity Constraint on a Specific Domain

Source: https://github.com/jump-dev/sumofsquares.jl/blob/master/docs/src/constraints.md

Constrains a polynomial to be nonnegative for points (x, y) within a specified domain S. The domain is defined using set operations.

```jldoctest
julia> S = @set x >= 0 && y >= 0 && x + y >= 1;

julia> @constraint(model, x^3 - x^2 + 2x*y -y^2 + y^3 >= α, domain = S)
(-α)·1 + (-1)·y² + (2)·xy + (-1)·x² + (1)·y³ + (1)·x³ is SOS
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.