Optimization of the Transport of Substances in Cells

Appendices

Methods of Optimization

4.1.1 Conditional Extremum and Nonlinear Programming

The task for the conditional extremum is formulated as follows:

$$ f\left(x \right) \to \min,\,g_{1} \left(x \right) = 0, \ldots,g_{m} \left(x \right) = 0 $$

where $g_{1} \left(x \right) = 0, \ldots,g_{m} \left(x \right) = 0$—are the constructions that are implied on x.

It can be shown that this problem can be reduced to the optimization of the Lagrangian

$$ L\left({x,\lambda} \right) = f\left(x \right) - \sum\limits_{j = 1}^{m} {\lambda_{j} g_{j} \left(x \right)} $$

on x for a suitable choice of $\lambda_{1},\ldots ,\lambda_{m}$ (Lagrange multipliers). As a result, the conditional extremum search is reduced to the solving a system of a equations:

$$ \frac{\partial f}{{\partial x_{k}}} = \sum\limits_{j = 1}^{m} {\lambda_{j} \frac{{\partial g_{j}}}{{\partial x_{k}}}},g_{1} \left(x \right) = 0, \ldots,g_{m} \left(x \right) = 0. $$

A nonlinear programming problem is formulated in a similar manner

$$ f\left(x \right) \to \min,\,g_{i} \left(x \right) = 0,\,h_{j} \left(x \right) \le 0 $$

where $h_{j} \left(x \right) \le 0$ are restrictions that are formulated as inequalities. The elements of x that satisfy the constraints of the problem are called the feasible solutions. Through the help of additional variables, the problem can be reduced to

$$ f\left(x \right) \to \min,\,g\left(x \right) = 0,h\left(x \right) + z = 0,\,z \ge 0. $$

A special case of nonlinear programming is linear programming, in which the function $f\left(x \right)$ has a special form.

4.1.2 Linear Programming

The mathematical formulation of the problem of linear programming can be represented as

$$ \begin{array}{*{20}l} {\sum\limits_{k = 1}^{n} {a_{ik} x_{k} } \le b_{i} ,i = 1, \ldots ,m,} \\ {x_{k} \ge 0,k = 1, \ldots ,n,} \\ {w = \sum\limits_{k = 1}^{n} {c_{k} x_{k} } \to \hbox{max} } \\ \end{array} $$

Because the solution of linear programming is achieved in the vertex of the permissible polyhedron—their enumeration ensures success within the finite of steps if solution exists. However, the polyhedron often has an astronomical number of vertices. There are special techniques, such as the simplex algorithm, that allow for a meaningful search.

The classical simplex method (proposed by George Dantzig) implements the idea of a targeted search for solutions. The algorithm jumps over the vertices such that it monotonically increases the target function $\left\langle {c,x} \right\rangle$. During each step, the transition to the next vertex is chosen such that the new value of $\left\langle {c,x} \right\rangle$ is better than the last.

The dual to the classical problem

$$ \left\langle {c,x} \right\rangle \to \max,\,Ax \le b,\,x \ge 0, $$

is the problem

$$ \left\langle {b,y} \right\rangle \to \min,\;A^{T} y \ge c,\;y \ge 0. $$

One of the varieties of linear programming problems is the problem of optimal transportation. This problem is formulated as follows: There are m producers and n consumers of a product, which are located at the nodes of the transportation network. Let $x_{ij}$ denote the amount of the product that is carried out of the ith node to the jth node. In addition, $a_{i}$—is the volume of production in the ith node and, $b_{j}$—is the total demand in the jth. The natural restrictions on the traffic volume imply:

$$ \sum\limits_{j}^{{}} {x_{ij}} \le a_{i},\,\sum\limits_{i}^{{}} {x_{ij}} \ge b_{j}.$$

The criterion that is usually used is

$$ \sum\limits_{i,j}^{n} {c_{ij} x_{ij}} \to \min, $$

where $c_{ij}$—is the cost of the transportation of a unit of goods from the ith to the jth node.

4.1.3 Integer Programming

The situations in real systems commonly lead to problems that are different from the linear programming problems because the desired values of the variables must be integers. The solving of these problems through linear programming is possible, but a situation in which the unknown quantities will be integers in the linear programming solution is a rare exception. In general, the integer programming problem cannot be solved by rounding the resulting values of the linear programming solution to integers. In this case, we need more labor-intensive methods. This problem is NP-hard (i.e., its solution requires an exponentially large number of steps). There are several methods for solving such problems. Two of these are the method of branches and bounds and the method of dynamic programming (see below).

An example of an integer programming problem is the knapsack problem (see Sect. 1.4).

If an exact solution is not required, then the problem is essentially simplified through approximate methods, such as the greedy algorithm, swarm intelligence, and genetic algorithms.

4.1.4 The Packing Problem (Backpack)

The problem of optimal one-dimensional packing (or the backpack problem) is formulated as follows: Suppose we have a backpack with a given carrying capacity and a set of objects of different weights and values. We then want to pack the backpack with the maximum objects such that it closes, which means that the sum of the values and weights of packaged objects must be at maximum and within a given limit, respectively.

There are many variations of this problem that are widely used in practice: the optimal filling of containers, the loading of trucks with weight restrictions, the creation of backups on removable media, and the choice of optimal control in a variety of economic and financial transactions.

There are n objects and c _i and a _i are the cost and weight, respectively, of the i-th object. It is then necessary to select a group of items with the maximum total cost and a limited total weight:

$$ \sum\limits_{i} {c_{i} x_{i} } \to \hbox{max} ,\,\sum\limits_{i} {a_{i} x_{i} } \le W, $$

where x _i can take integer values or the values 1 and 0 (an object either exists or does not exist). This task belongs to the NP-hard class of problems, i.e., its solution requires an exponentially large number of steps that depend on the number of objects.

The methods that can be used to approximate the solution to the backpack problem include genetic algorithms, algorithms of ant colonies, and “greedy” algorithms.

These algorithms are characterized by polynomial complexity but only an approximate solution is obtained. These algorithms are often used for other problems of AI.

The “greedy” algorithm for the knapsack problem is as follows:

The first set of items Q is ordered by descending “specific values” (or the weight of the unit price) items such that

$$ \frac{{c_{1}}}{{a_{1}}} \ge \frac{{c_{2}}}{{a_{2}}} \ge\ldots \ge \frac{{c_{n}}}{{a_{n}}} $$

then, starting with an empty set, the sequentially ordered set of objects Q is added to the approximate solution Q’ (which is empty at first);

With each successive addition, the algorithm verifies that the next object does not exceed allowable weight of the backpack;

The process is completed by constructing an approximate solution of the knapsack problem.

The exact solution of the knapsack problem can be obtained by other methods, such as the branch and bound method or the dynamic programming method.

4.1.5 Dynamic Programming

Dynamic programming is a method that can be used to solve complex problems by breaking them into simpler subtasks. It is applicable to problems with optimal substructure that include a set of overlapping subproblems with slightly less complexity than the original. In this case, the computation time can be reduced compared to methods that use an exhaustive search algorithm. As a rule, the solution of the problem requires the solving of some of the tasks (subtasks) and the combination of the solutions of the subproblems into a common solution. Often, many of the subtasks are the same. The dynamic programming approach is to solve each subproblem only once, thereby reducing the amount of computation. This is especially useful in cases in which the number of repeated subproblems is exponentially large.

The method of dynamic programming requires the storage of the results of the subtasks that can be used again in the future. Dynamic programming includes the reformulation of a complex problem as a recursive sequence of simpler subproblems.

An optimal substructure in dynamic programming means that the optimal solution of the smaller subproblems can be used to solve the original problem. For example, the shortest path in the graph from vertex A to vertex B can be found by first calculating the shortest path from all of the vertices that are adjacent to A to B and then, taking into account the weights of the edges between A and its adjacent vertices, to choose the best way to B. In general, we can solve the problem, which has an optimal substructure, by performing the following three steps:

• 1. Split the task into subtasks of smaller size.

• 2. Find the optimal solution of the subproblems recursively by performing the same three-step algorithm.

• 3. Use the obtained solutions for the subproblems to construct the solution for the original problem.

The sub-problems are solved by dividing them into even smaller sub-tasks and so on until a trivial case has to be solved in constant time (i.e., immediately). For example, if we need to find the value of n!, it would be a trivial task to determine 1! = 1 (or 0! = 1).

Overlapping sub-problems in dynamic programming refer to sub-problems that are used to address a number of larger problems. A striking example is the calculation of the Fibonacci sequence. In this case, a simple recursive approach would be to spend time on the computation of the solution of problems (adding numbers) that have already been solved.

To avoid this exponentially difficult problem, the solution to the already solved sub-problems should be stored. Therefore if the same solution is required in a different task, it can simply be obtained from the memory instead of calculated.

Thus, dynamic programming uses the following properties of the problem:

• overlapping sub-problems,

• an optimal substructure, and

• the ability to memorize the solutions to common subtasks.

The method of dynamic programming was developed by Richard Bellman. The basis of this method is the principle of optimality:

The optimal strategy has the property that, whatever the initial state and initial decision, the subsequent decision should determine the optimal strategy with respect to the state resulting from the initial decision.

Some classical problems of dynamic programming

• The task of drafting a distance (Levenshtein distance): given two strings, the minimum number of erasures, additions and substitutions of characters that transform one string into another.

• The problem of calculating Fibonacci numbers.

• The problem of selecting a trajectory.

• The making of a consistent decision.

• The packing problem (knapsack): from an unlimited set of objects with “values” and “weights”, a set of objects has to be selected to maximize the total value of the limited total weight.

4.1.6 Matrix Games

Matrix games are characterized by two players with conflicting interests. If their interests are not completely opposite, the games are called bimatrix.

The matrix game can be described by the matrix gains

$$ {\mathbf{A}} = \left({\begin{array}{*{20}c} {a_{11}} &{a_{12}}&{\ldots} & {a_{1n}} \\ {a_{21}} & {a_{22}}&{\ldots} & {a_{2n}}\\ {\ldots} & {\ldots} & {\ldots} & {\ldots}\\ {a_{m1}} & {a_{m2}} & {\ldots} & {a_{mn}} \\ \end{array}}\right), $$

where the elements of the matrix a _ik are a winning player (winning player is a _ik ).

In some cases, the optimization of a system considers the game against nature. In this case, nature represents the second player, who chooses the strategies that are the worst for the first player. It is often convenient to reduce the control problems in the presence of uncertainty (lack of information) to game problems in which the second player is assigned the properties that characterize the random process for which the information is incomplete.

The matrix game often has no solution in pure strategies. In this case, the solution is sought in the form of mixed strategies, i.e., every player uses all of their strategies with a certain probability.

Controllability of Linear Control Systems

The behavior of a multidimensional linear control system is described by the equations of state and the output:

$$ \begin{aligned} \dot{x}\left(t \right) & = Ax\left(t \right) + Bu\left(t \right),\,x\left(0 \right) = x_{0}, \, and \\ y\left(t \right) & = Cx\left(t \right),\end{aligned} $$

where x is the n-dimensional vector of the state, u is an r-dimensional vector of the control, t is the time, t ∈ [t ₀, t ₁] is the interval of time during which the system functions, y is a k-dimensional vector of the output and A, B, and C and matrices with dimensions of (n × n), (n × r), and (k × n), respectively.

The system is completely controllable if the choice of control action u(t) in the time interval [t ₀, t ₁] makes it possible to transfer the system from any initial state x(t ₀) to an arbitrary predetermined final state x(t ₁).

The system is fully controlled by the output if the choice of control action u(t) in the time interval [t ₀, t ₁] makes it possible to transfer the system from any initial state x(t ₀) to a final state with a predetermined arbitrary value of the output y(t ₁).

The problem is formulated as follows: given known matrices A, B, C of a system of differential equations, is the system completely controllable?

Thecriterionofcontrolbythestate. For the system to be completely controlled by the state, it is necessary and sufficient that the rank of the controllability by the state

$$ W = \left({B,AB,A^{2} B,\ldots,A^{n - 1} B} \right) $$

be equal to the dimension of the state vector $rangW = n$.

Thecriterionforthecontrollabilitybytheoutput. For the system to be completely controlled by the output, it is necessary and sufficient that the rank of the matrix of the controllability of the output

$$ P = \left({CB,CAB,CA^{2} B,\ldots,CA^{n - 1} B} \right) $$

be equal to the dimension of the vector output $rangP = k$.