6.7 Semidefinite Optimization¶
Semidefinite optimization is a generalization of conic optimization, allowing the use of matrix variables belonging to the convex cone of positive semidefinite matrices
where \(\Symm^r\) is the set of \(r \times r\) real-valued symmetric matrices.
MOSEK can solve semidefinite optimization problems stated in the primal form,
where the problem has \(p\) symmetric positive semidefinite variables \(\barX_j\in \PSD^{r_j}\) of dimension \(r_j\). The symmetric coefficient matrices \(\barC_j\in \Symm^{r_j}\) and \(\barA_{i,j}\in \Symm^{r_j}\) are used to specify PSD terms in the linear objective and the linear constraints, respectively. The symmetric coefficient matrices \(\barF_{i,j}\in \Symm^{r_j}\) are used to specify PSD terms in the affine conic constraints. Note that \(q\) ((6.22)) is the total dimension of all the cones, i.e. \(q=\text{dim}(\K_1 \times \ldots \times \K_k)\), given there are \(k\) ACCs. We use standard notation for the matrix inner product, i.e., for \(A,B\in \real^{m\times n}\) we have
In addition to the primal form presented above, semidefinite problems can be expressed in their dual form. Constraints in this form are usually called linear matrix inequalities (LMIs). LMIs can be easily specified in MOSEK using the vectorized positive semidefinite cone which is defined as:
Vectorized semidefinite domain:
\[\PSD^{d,\mathrm{vec}} = \left\{(x_1,\ldots,x_{d(d+1)/2})\in \real^n~:~ \mathrm{sMat}(x)\in\PSD^d\right\},\]where \(n=d(d+1)/2\) and,
\[\begin{split}\mathrm{sMat}(x) = \left[\begin{array}{cccc}x_1 & x_2/\sqrt{2} & \cdots & x_{d}/\sqrt{2} \\ x_2/\sqrt{2} & x_{d+1} & \cdots & x_{2d-1}/\sqrt{2} \\ \cdots & \cdots & \cdots & \cdots \\ x_{d}/\sqrt{2} & x_{2d-1}/\sqrt{2} & \cdots & x_{d(d+1)/2}\end{array}\right],\end{split}\]or equivalently
\[\PSD^{d,\mathrm{vec}} = \left\{\mathrm{sVec}(X)~:~X\in\PSD^d\right\},\]where
\[\mathrm{sVec}(X) = (X_{11},\sqrt{2}X_{21},\ldots,\sqrt{2}X_{d1},X_{22},\sqrt{2}X_{32},\ldots,X_{dd}).\]
In other words, the domain consists of vectorizations of the lower-triangular part of a positive semidefinite matrix, with the non-diagonal elements additionally rescaled. LMIs can be expressed by restricting appropriate affine expressions to this cone type.
For other types of cones supported by MOSEK, see Sec. 15.11 (Supported domains) and the other tutorials in this chapter. Different cone types can appear together in one optimization problem.
We demonstrate the setup of semidefinite variables and their coefficient matrices in the following examples:
Sec. 6.7.1 (Example SDO1): A problem with one semidefinite variable and linear and conic constraints.
Sec. 6.7.2 (Example SDO2): A problem with two semidefinite variables with a linear constraint and bound.
Sec. 6.7.3 (Example SDO_LMI: Linear matrix inequalities and the vectorized semidefinite domain): A problem with linear matrix inequalities and the vectorized semidefinite domain.
6.7.1 Example SDO1¶
We consider the simple optimization problem with semidefinite and conic quadratic constraints:
The problem description contains a 3-dimensional symmetric semidefinite variable which can be written explicitly as:
and an affine conic constraint (ACC) \((x_0, x_1, x_2) \in \Q^3\). The objective is to minimize
subject to the two linear constraints
Setting up the linear and conic part
The linear and conic parts (constraints, variables, objective, ACC) are set up using the methods described in the relevant tutorials; Sec. 6.1 (Linear Optimization), Sec. 6.2 (From Linear to Conic Optimization). Here we only discuss the aspects directly involving semidefinite variables.
Appending semidefinite variables
First, we need to declare the number of semidefinite variables in the problem, similarly to the number of linear variables and constraints. This is done with the function Task.appendbarvars.
task.appendbarvars(BARVARDIM)
Appending coefficient matrices
Coefficient matrices \(\barC_j\) and \(\barA_{ij}\) are constructed as weighted combinations of sparse symmetric matrices previously appended with the function Task.appendsparsesymmat.
symc = task.appendsparsesymmat(BARVARDIM[0],
barci,
barcj,
barcval)
syma0 = task.appendsparsesymmat(BARVARDIM[0],
barai[0],
baraj[0],
baraval[0])
syma1 = task.appendsparsesymmat(BARVARDIM[0],
barai[1],
baraj[1],
baraval[1])
The arguments specify the dimension of the symmetric matrix, followed by its description in the sparse triplet format. Only lower-triangular entries should be included. The function produces a unique index of the matrix just entered in the collection of all coefficient matrices defined by the user.
After one or more symmetric matrices have been created using Task.appendsparsesymmat, we can combine them to set up the objective matrix coefficient \(\barC_j\) using Task.putbarcj, which forms a linear combination of one or more symmetric matrices. In this example we form the objective matrix directly, i.e. as a weighted combination of a single symmetric matrix.
task.putbarcj(0, [symc], [1.0])
Similarly, a constraint matrix coefficient \(\barA_{ij}\) is set up by the function Task.putbaraij.
task.putbaraij(0, 0, [syma0], [1.0])
task.putbaraij(1, 0, [syma1], [1.0])
Retrieving the solution
After the problem is solved, we read the solution using Task.getbarxj:
barx = task.getbarxj(mosek.soltype.itr, 0)
The function returns the half-vectorization of \(\barX_j\) (the lower triangular part stacked as a column vector), where the semidefinite variable index \(j\) is passed as an argument.
Source code
import sys
import mosek
# Since the value of infinity is ignored, we define it solely
# for symbolic purposes
inf = 0.0
# Define a stream printer to grab output from MOSEK
def streamprinter(text):
sys.stdout.write(text)
sys.stdout.flush()
def main():
# Create a task object and attach log stream printer
with mosek.Task() as task:
task.set_Stream(mosek.streamtype.log, streamprinter)
# Bound keys for constraints
bkc = [mosek.boundkey.fx,
mosek.boundkey.fx]
# Bound values for constraints
blc = [1.0, 0.5]
buc = [1.0, 0.5]
# Below is the sparse representation of the A
# matrix stored by row.
asub = [[0],
[1, 2]]
aval = [[1.0],
[1.0, 1.0]]
barci = [0, 1, 1, 2, 2]
barcj = [0, 0, 1, 1, 2]
barcval = [2.0, 1.0, 2.0, 1.0, 2.0]
barai = [[0, 1, 2],
[0, 1, 2, 1, 2, 2]]
baraj = [[0, 1, 2],
[0, 0, 0, 1, 1, 2]]
baraval = [[1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0]]
numvar = 3
numcon = len(bkc)
BARVARDIM = [3]
# Append 'numvar' variables.
# The variables will initially be fixed at zero (x=0).
task.appendvars(numvar)
# Append 'numcon' empty constraints.
# The constraints will initially have no bounds.
task.appendcons(numcon)
# Append matrix variables of sizes in 'BARVARDIM'.
# The variables will initially be fixed at zero.
task.appendbarvars(BARVARDIM)
# Set the linear term c_0 in the objective.
task.putcj(0, 1.0)
for j in range(numvar):
# Set the bounds on variable j
# blx[j] <= x_j <= bux[j]
task.putvarbound(j, mosek.boundkey.fr, -inf, +inf)
for i in range(numcon):
# Set the bounds on constraints.
# blc[i] <= constraint_i <= buc[i]
task.putconbound(i, bkc[i], blc[i], buc[i])
# Input row i of A
task.putarow(i, # Constraint (row) index.
asub[i], # Column index of non-zeros in constraint i.
aval[i]) # Non-zero values of row i.
# Add the quadratic cone constraint
task.appendafes(3)
# Diagonal F matrix
task.putafefentrylist(range(3), range(3), [1.0]*3)
task.appendaccseq(task.appendquadraticconedomain(3), 0, None)
symc = task.appendsparsesymmat(BARVARDIM[0],
barci,
barcj,
barcval)
syma0 = task.appendsparsesymmat(BARVARDIM[0],
barai[0],
baraj[0],
baraval[0])
syma1 = task.appendsparsesymmat(BARVARDIM[0],
barai[1],
baraj[1],
baraval[1])
task.putbarcj(0, [symc], [1.0])
task.putbaraij(0, 0, [syma0], [1.0])
task.putbaraij(1, 0, [syma1], [1.0])
# Input the objective sense (minimize/maximize)
task.putobjsense(mosek.objsense.minimize)
# Solve the problem and print summary
task.optimize()
task.solutionsummary(mosek.streamtype.msg)
# Get status information about the solution
prosta = task.getprosta(mosek.soltype.itr)
solsta = task.getsolsta(mosek.soltype.itr)
if (solsta == mosek.solsta.optimal):
xx = task.getxx(mosek.soltype.itr)
barx = task.getbarxj(mosek.soltype.itr, 0)
print("Optimal solution:\nx=%s\nbarx=%s" % (xx, barx))
elif (solsta == mosek.solsta.dual_infeas_cer or
solsta == mosek.solsta.prim_infeas_cer):
print("Primal or dual infeasibility certificate found.\n")
elif solsta == mosek.solsta.unknown:
print("Unknown solution status")
else:
print("Other solution status")
# call the main function
try:
main()
except mosek.MosekException as e:
print("ERROR: %s" % str(e.errno))
if e.msg is not None:
print("\t%s" % e.msg)
sys.exit(1)
except:
import traceback
traceback.print_exc()
sys.exit(1)
6.7.2 Example SDO2¶
We now demonstrate how to define more than one semidefinite variable using the following problem with two matrix variables and two types of constraints:
In our example \(\dim(\barX_1)=3\), \(\dim(\barX_2)=4\), \(b=23\), \(k=-3\) and
are constant symmetric matrices.
Note that this problem does not contain any scalar variables, but they could be added in the same fashion as in Sec. 6.7.1 (Example SDO1).
Other than in Sec. 6.7.1 (Example SDO1) we don’t append coefficient matrices separately but we directly input all nonzeros in each constraint and all nonzeros in the objective at once. Every term of the form \((\barA_{i,j})_{k,l}(\barX_j)_{k,l}\) is determined by four indices \((i,j,k,l)\) and a coefficient value \(v=(\barA_{i,j})_{k,l}\). Here \(i\) is the number of the constraint in which the term appears, \(j\) is the index of the semidefinite variable it involves and \((k,l)\) is the position in that variable. This data is passed in the call to Task.putbarablocktriplet. Note that only the lower triangular part should be specified explicitly, that is one always has \(k\geq l\). Semidefinite terms \((\barC_j)_{k,l}(\barX_j)_{k,l}\) of the objective are specified in the same way in Task.putbarcblocktriplet but only include \((j,k,l)\) and \(v\).
For explanations of other data structures used in the example see Sec. 6.7.1 (Example SDO1).
The code representing the above problem is shown below.
# Make mosek environment
with Env() as env:
# Create a task object and attach log stream printer
with env.Task(0, 0) as task:
# Set log handler for debugging ootput
task.set_Stream(streamtype.log, streamprinter)
# Append two symmetric variables of dimension 3, 4
barvardims = [3, 4]
task.appendbarvars(barvardims)
# Semidefinite part of objective function
task.putbarcblocktriplet(
[0]*len(C1_v) + [1]*len(C2_v), # Which SDP variable (j)
C1_k + C2_k, # Entries: (k,l)->v
C1_l + C2_l,
C1_v + C2_v,
)
# Append two constraints
task.appendcons(2)
# First constraint (equality)
task.putbarablocktriplet(
[0]*(len(A1_v)+len(A2_v)), # Which constraint (i = 0)
[0]*len(A1_v) + [1]*len(A2_v), # Which SDP variable (j)
A1_k + A2_k, # Entries: (k,l)->v
A1_l + A2_l,
A1_v + A2_v,
)
# Second constraint (X2)_{1,2} <= k
task.putbarablocktriplet(
[1], # Which constraint (i = 1)
[1], # Which SDP variable (j = 1)
[1], [0], [0.5] # Entries: (k,l)->v
)
# Set bounds for constraints
task.putconboundlist([0,1], [boundkey.fx, boundkey.up],
[b, -inf],
[b, k])
# Write the problem for human inspection
task.writedata("test.ptf")
# Optimize
task.optimize()
task.solutionsummary(streamtype.msg)
# Get status information about the solution
solsta = task.getsolsta(soltype.itr)
if solsta == solsta.optimal:
# Assuming the optimization succeeded read solution
print("Solution (lower-triangular part vectorized): ")
for i in range(2):
X = task.getbarxj(soltype.itr, i)
print("X{i} = {X}".format(i=i, X=X))
elif (solsta == solsta.dual_infeas_cer or
solsta == solsta.prim_infeas_cer):
print("Primal or dual infeasibility certificate found.\n")
elif solsta == solsta.unknown:
print("Unknown solution status")
else:
print("Other solution status")
6.7.3 Example SDO_LMI: Linear matrix inequalities and the vectorized semidefinite domain¶
The standard form of a semidefinite problem is usually either based on semidefinite variables (primal form) or on linear matrix inequalities (dual form). However, MOSEK allows mixing of these two forms, as shown in (6.25)
The first affine expression is restricted to a linear domain and could also be modelled as a linear constraint (instead of an ACC). The lower triangular part of the linear matrix inequality (second constraint) can be vectorized and restricted to the domaintype.svec_psd_cone. This allows us to express the constraints in (6.25) as the affine conic constraints shown in (6.26).
Vectorization of the LMI is performed as explained in Sec. 15.11 (Supported domains).
Setting up the linear part
The linear parts (objective, constraints, variables) and the semidefinite terms in the linear expressions are defined exactly as shown in the previous examples.
Setting up the affine conic constraints with semidefinite terms
To define the affine conic constraints, we first set up the affine expressions. The \(F\) matrix and the \(g\) vector are defined as usual. Additionally, we specify the coefficients for the semidefinite variables. The semidefinite coefficients shown in (6.26) are setup using the function Task.putafebarfblocktriplet.
task.putafebarfblocktriplet(barfi, barfj, barfk, barfl, barfv)
These affine expressions are then included in their corresponding domains to construct the affine conic constraints. Lastly, the ACCs are appended to the task.
# Append R+ domain and the corresponding ACC
task.appendacc(task.appendrplusdomain(1), [0], None)
# Append SVEC_PSD domain and the corresponding ACC
task.appendacc(task.appendsvecpsdconedomain(3), [1,2,3], None)
Source code
import sys
from numpy import sqrt
import mosek
# Since the value of infinity is ignored, we define it solely
# for symbolic purposes
inf = 0.0
# Define a stream printer to grab output from MOSEK
def streamprinter(text):
sys.stdout.write(text)
sys.stdout.flush()
def main():
# Create a task object and attach log stream printer
with mosek.Task() as task:
task.set_Stream(mosek.streamtype.log, streamprinter)
# Below is the sparse triplet representation of the F matrix.
afeidx = [0, 0, 1, 2, 2, 3]
varidx = [0, 1, 1, 0, 1, 0]
f_val = [-1, -1, 3, sqrt(2), sqrt(2), 3]
g = [0, -1, 0, -1]
barcj = [0, 0]
barck = [0, 1]
barcl = [0, 1]
barcv = [1, 1]
barfi = [0,0]
barfj = [0,0]
barfk = [0,1]
barfl = [0,0]
barfv = [0,1]
numvar = 2
numafe = 4
BARVARDIM = [2]
# Append 'numvar' variables.
# The variables will initially be fixed at zero (x=0).
task.appendvars(numvar)
# Append 'numafe' empty affine expressions.
task.appendafes(numafe)
# Append matrix variables of sizes in 'BARVARDIM'.
# The variables will initially be fixed at zero.
task.appendbarvars(BARVARDIM)
# Set the linear terms in the objective.
task.putcj(0, 1.0)
task.putcj(1, 1.0)
task.putcfix(1.0)
task.putbarcblocktriplet(barcj, barck, barcl, barcv)
for j in range(numvar):
# Set the bounds on variable j
# blx[j] <= x_j <= bux[j]
task.putvarbound(j, mosek.boundkey.fr, -inf, +inf)
# Set up the F matrix of the problem
task.putafefentrylist(afeidx, varidx, f_val)
# Set up the g vector of the problem
task.putafegslice(0, numafe, g)
task.putafebarfblocktriplet(barfi, barfj, barfk, barfl, barfv)
# Append R+ domain and the corresponding ACC
task.appendacc(task.appendrplusdomain(1), [0], None)
# Append SVEC_PSD domain and the corresponding ACC
task.appendacc(task.appendsvecpsdconedomain(3), [1,2,3], None)
# Input the objective sense (minimize/maximize)
task.putobjsense(mosek.objsense.minimize)
# Solve the problem and print summary
task.optimize()
task.solutionsummary(mosek.streamtype.msg)
# Get status information about the solution
prosta = task.getprosta(mosek.soltype.itr)
solsta = task.getsolsta(mosek.soltype.itr)
if (solsta == mosek.solsta.optimal):
xx = task.getxx(mosek.soltype.itr)
barx = task.getbarxj(mosek.soltype.itr, 0)
print("Optimal solution:\nx=%s\nbarx=%s" % (xx, barx))
elif (solsta == mosek.solsta.dual_infeas_cer or
solsta == mosek.solsta.prim_infeas_cer):
print("Primal or dual infeasibility certificate found.\n")
elif solsta == mosek.solsta.unknown:
print("Unknown solution status")
else:
print("Other solution status")
# call the main function
try:
main()
except mosek.MosekException as e:
print("ERROR: %s" % str(e.errno))
if e.msg is not None:
print("\t%s" % e.msg)
sys.exit(1)
except:
import traceback
traceback.print_exc()
sys.exit(1)
