# Geometric programming

Authors: Helen Wu (ChE345 Spring 2015)

Steward: Dajun Yue and Fengqi You

## Contents |

# Introduction

Geometric programming was introduced in 1967 by Duffin, Peterson and Zener. It is very useful in the applications of a variety of optimization problems, and falls under the general class of signomial problems[1]. It can be used to solve large scale, practical problems by quantifying them into a mathematical optimization model. Geometric programs (GP) are useful in the context of geometric design and models well approximated by power laws. Applications of GP include electrical circuit design and other topics such as finance and statistics[2].

# Model Formulation

## Standard Form

A geometric program is composed of an objective function that is subjected to constraints. All of the components must be in the nature of monomials and posynomials. A monomial is a single term and takes the form of

where the coefficient C>0 and the exponents, . Note that use of “monomial” is different from the meaning in algebra; here, monomials can have negative exponents. A posynomial takes the form of the sum of one or more monomials:

A geometric program in standard form looks like this:

where *f _{i}* are posynomials,

*g*are monomials, and

_{i}*x*are optimization variables. The objective must be to minimize a posynomial. Often times the geometric program must be reformulated into standard form. If presented with a maximizing problem, the inverse can be taken to convert it into a minimizing problem[2].

_{i}## Example

Consider the following example problem:

with variables .

The equivalent standard form GP is as follows

# Solution Approaches

In order to solve a GP, there are many factors to consider. The GP must be in a specific form in order to solve, and we must determine the feasibility of the problem.

## Convex Form

In order to solve a geometric program, it must be reformulated into a nonlinear, convex optimization problem via a change in variables. By applying a logarithmic transformation, GP can be seen as an extension of linear programming. Setting *y _{i}* = log

*x*results in the following GP:

_{i}

By transforming the GP into this form, it can be solved more efficiently[2].

## Feasibility

In order to solve the GP, the problem must be feasible. If it is not feasible, then no optimal solution will be found. In this case, at least one constraint must be relaxed. This can be done by adding a new scalar variable, *s*, to find a value x̂ that is “close to feasible.” The GP now looks like this:

This problem can be solved to find the optimal values of x̄ and s̄. S̄ is indicative of how feasible the original GP is. For example. If s̄=1, then x̄ is feasible for the original problem. If s̄ is greater than 1, then we set x̂ equal to x̄.

Solvers also may use a trade-off analysis of the GP, where the constraints are varied to see how they may affect the optimal solution. This results in a “perturbed” GP, and can be modeled as:

Instead of having the constraints less than or equal to 1 or equal to 1, it is instead replaced with parameters *u* and *v* which are positive constants. If *u* is greater than one, then the inequality constraint is loosened; if *u* is less than 1, then the inequality constraint is tightened. Solving this perturbed model for different values of *u* and *v* allows analysis on how these values relate to the optimal solution. An optimal trade-off curve can be formed by plotting *p(u,v)* versus *u _{i}*, with all other

*u*and

_{i}*v*equal to one. This will display the “optimal trade-off” of the

_{j}*i*th inequality constraint and objective.

Similarly, a sensitivity analysis allows the examination of how small changes in the constraints affects the optimal solution[2].

## Generalized GP

In the case that the polynomials are taken to a fractional power, they can be handled by introducing a new variable and a bounding constraint. If, for example, *f _{1}* and

*f*are posynomials taken to a fractional power, then we can introduce new variables

_{2}*t*and

_{1}*t*which represent the upper bounds of the posynomials. We can set

_{2}

Adding these new variables will now make the problem compatible with GP[2].

## Methods

There have been many different methods that have been proposed to solve different types of GPs, and all have their own advantages and disadvantages. Some examples include:

- To solve a engineering optimization problem, Coello and Cortés created a method using a genetic algorithm with an artificial immune system. A limitation of this method includes that you can only obtain local optima solutions.
- To solve a Lipschitzian problem, Horst and Tuy created an analytical approach. A limitation of this method is that it is only feasible for problems that contain variables that can be reduced by analytical techniques.
- Sherali and Tuncbilek proposed a reformulation-linearization technique. This technique linearizes the problem by adding new variables, and creates new constraints. A limitation of this method is that it requires a long trial-and-error process and therefore can be harder to use.
- Li and Chang suggested using the approach of a using a logarithmic transformation of the problem, followed by a piecewise-linearization. This method is easy to implement, and can be used to calculate global minima. However, a limitation is that the addition of extra binary variables may cause it to become very complex.

Huang and Kao expand on the Li and Chang's proposed method of a logarithmic piecewise-linearization, and attempt to reduce the number of binary variables. Considering the posynomial function This process includes the following steps:

- Considering posynomial function , take the logarithm to get .
- The expression can be represented in a different way to obtain "break points" which are used to linearize the problem. Here, can also be expressed as

where are the break points, and

where are the break points for . Refer to Figures 1 and 2. - Let represent a set of binary variables where . Then, the following will be true:

,

. - Rewriting the expressions in the way allows us to calculate the slopes of the piecewise-linearization function. The slope between points and can be calculated as:

where . - A similar process is used when linearizing . Let represent a set of binary variables where . Then, the following will be true:

,

Therefore the slope between points and can be calculated as:

,

where . - By rewriting all these expressions, the number of binary variables is reduced, and the GP may be simpler to solve[1].

# Illustrative Example

Here is an example taken from a paper written by Huang and Kao regarding their method[1].

Given this problem, we can set:

and .

Assuming that we would like to calculate three break points for within the upper and lower bounds of which are [0, 4.3455]. Following the method previously explained, the break points, can be calculated in the following way:

The slopes can then be calculated:

We can also rewrite the expressions of as:

and we can express as:

where and

Now we can use the same method to calculate the break points of within the range of [1,5].

.
The slopes are then calculated as:

We can also rewrite the expressions of as:

and we can express as:

where and

The problem then becomes

This new problem now has 8 binary variables, rather than the 16 binary variables originally using Li and Chang's approach described above. The answer to this problem is with a minimal value of 9.446[1].

# Applications

There are many different applications of GPs in different fields. Here are some examples:

- Engineering
- Membrane separation process design
- Chemical equilibrium problems
- Statistical mechanics
- Minimum weight design
- Entropy maximization
- Optimizing nuclear systems
- Structural design

- Other
- Regional planning of economic models
- Inventory models in management science
- Transportation planning
- Maximizing reliability[3]

# Conclusion

In conclusion, geometric programming is a very powerful type of application that can be used to solve a variety of different optimization problems. There are many different methods to solve GPs, and it depends on the different constraints and conditions for the specific GP. Although it may be difficult to quantify a problem into a GP, doing so can be very useful to get an approximate answer, if not an exact answer, which still can be valuable. This kind of programming has applications across a variety of fields from engineering to economics, and will continue to be useful in the future as more problems are formatted into GPs.

# References

1. Huang, C. H.; Kao, H. Y. (2009). An effective linear approximation method for geometric programming problems. IEEE Conference Publications. 1743-1746.

2. Boyd, S.; Kim, S. J.; Vandenberghe, L.; Hassibi, A. (2007). A tutorial on geometric programming. Springer Science+Business Media, LLC, 1-11.

3. Ecker, J. G. (1980). Geometric programming: methods, computations and applications. Society for Industrial and Applied Mathematics, 22(3), 338-341, 351- 352.