# 7.4 Conic Exponential Optimization¶

Conic optimization is a generalization of linear optimization, allowing constraints of the type

where \(x^t\) is a subset of the problem variables and \(\K_t\) is a convex cone. Since the set \(\real^n\) of real numbers is also a convex cone, we can simply write a compound conic constraint \(x\in \K\) where \(\K=\K_1\times\cdots\times\K_l\) is a product of smaller cones and \(x\) is the full problem variable.

**MOSEK** can solve conic optimization problems of the form

where the domain restriction, \(x \in \K\), implies that all variables are partitioned into convex cones

In this tutorial we describe how to use the primal exponential cone defined as:

**MOSEK** also supports the dual exponential cone:

For other types of cones supported by **MOSEK** see Sec. 7.2 (Conic Quadratic Optimization), Sec. 7.3 (Power Cone Optimization), Sec. 7.5 (Semidefinite Optimization). See `Domain`

for a list and definitions of available cone types. Different cone types can appear together in one optimization problem.

For example, the following constraint:

describes a convex cone in \(\real^3\) given by the inequalities:

In *Fusion* the coordinates of a cone are not restricted to single variables. They can be arbitrary linear expressions, and an auxiliary variable will be substituted by *Fusion* in a way transparent to the user.

## 7.4.1 Example CEO1¶

Consider the following basic conic exponential problem which involves some linear constraints and an exponential inequality:

The conic form of (7.5) is:

We start by creating the optimization model:

```
with Model('ceo1') as M:
```

We then define the variable `x`

.

```
x = M.variable('x', 3, Domain.unbounded())
```

The linear constraint is defined using the sum operator `Expr.sum`

:

```
# Create the constraint
# x[0] + x[1] + x[2] = 1.0
M.constraint("lc", Expr.sum(x), Domain.equalsTo(1.0))
```

The conic exponential constraint in this case is very simple as it involves just the variable `x`

. The primal exponential cone is referred to via `Domain.inPExpCone`

, and it must be applied to a variable of length 3 or an array of such variables. Note that this is a basic way of defining conic constraints, and that in practice they would have more complicated structure.

```
# Create the conic exponential constraint
expc = M.constraint("expc", x, Domain.inPExpCone())
```

We only need the objective function:

```
# Set the objective function to (x[0] + x[1])
M.objective("obj", ObjectiveSense.Minimize, Expr.sum(x.slice(0,2)))
```

Calling the `Model.solve`

method invokes the solver:

```
M.solve()
```

The primal and dual solution values can be retrieved using `Variable.level`

, `Constraint.level`

and `Variable.dual`

, `Constraint.dual`

, respectively:

```
# Get the linear solution values
solx = x.level()
```

```
# Get conic solution of expc
expcval = expc.level()
expcdual = expc.dual()
```

```
from mosek.fusion import *
with Model('ceo1') as M:
x = M.variable('x', 3, Domain.unbounded())
# Create the constraint
# x[0] + x[1] + x[2] = 1.0
M.constraint("lc", Expr.sum(x), Domain.equalsTo(1.0))
# Create the conic exponential constraint
expc = M.constraint("expc", x, Domain.inPExpCone())
# Set the objective function to (x[0] + x[1])
M.objective("obj", ObjectiveSense.Minimize, Expr.sum(x.slice(0,2)))
# Solve the problem
M.solve()
M.writeTask('ceo1.ptf')
# Get the linear solution values
solx = x.level()
print('x1,x2,x3 = %s' % str(solx))
# Get conic solution of expc
expcval = expc.level()
expcdual = expc.dual()
print('expc levels = %s' % str(expcval))
print('expc dual conic var levels = %s' % str(expcdual))
```