A mathematical programming viewpoint for solving the ultimate pit problem

EUROPEAN JOURNAL

OF OPERATIONAL RESEARCH

European Journal of Operational Research 107 (1998) 96-107

Theory and Methodology

A mathematical programming viewpoint for solving the ultimate pit problem

Robert Underwood a**, Boleslaw Tolwinski b a Department of Mathematical and Computer Sciences, Colorado School of Mines, Golden, CO 80401-1887, USA

b Operations Research Experts, Golden, CO, USA

Received 20 February 1996; accepted 12 November 1996

Abstract

In 1965 Helmut Lerchs and Ingo Grossmann presented to the mining community an algorithm to find the optimum design for an open pit mine. In their words, “the objective is to design the contour of a pit so as to maximize the difference between total mine value of the ore extracted and the total extraction cost of ore and waste”. They modeled the problem in graph theoretic terms and showed that an optimal solution of the ultimate pit problem is equivalent to finding the maximum closure of their graph based model. In this paper, we develop a network flow algorithm based on the dual to solve the same problem. We show how this algorithm is closely related to Lerchs and Grossmann’s and how the steps in their algorithm can be viewed in mathematical programming terms. This analysis adds insight to the algorithm of Lerchs and Grossmann and shows where it can be made more efficient. As in the case Lerchs and Grossmann, our algorithm allows us to use very efficient data structures based on graphs that represent the data and constraints. @ 1998 Elsevier Science B.V.

Keyworak: Mathematical programming; Network programming; Graph theory; Mine planning

1. Introduction

A problem of central concern to the mining industry is to determine the most profitable material which can be feasibly removed from an open pit mine. They approach the problem by first taking samples of the ore from bore holes and then applying geostatistical techniques to estimate the ore’s distribution in terms of quality and quantity. From this information they construct a block model of the distribution. This is done by partitioning the ore body into blocks and assigning to each block a grade of ore and a value to the block which reflects the value of the ore contained in the

??Corresponding author. Fax: +l 303 273 3875, e-mail: [email protected]

block less the costs associated with its removal. Many engineering issues can be addressed by analyzing this block model. For instance, the engineer may be con- cerned with the grade or quality of ore that should be removed or the rate at which the ore should be removed in order to satisfy milling requirements (see [lo] ). He may want to know the size and shape of the ore body at its completion. Finding the best final pit is referred to as the ‘ultimate pit problem’, and it is this issue on which we will focus in this paper.

An ultimate pit is a collection of blocks which can be most profitably removed while obeying restrictions on the slope of the mine’s walls. A simple two di- mensional example of a block model (which can be thought of as a vertical cross section of an open pit mine) is portrayed in Fig. 1. The shaded portion in-

0377-2217/98/$19.00 @ 1998 Elsevier Science B.V. All rights reserved. PII SO377-2217(97)00141-O

R. Underwood, B. Tolwinski/European Journal of Operational Research 107 (1998) 96-107 97

Fig. 1. An example of a block model.

dicates an ultimate pit of square blocks where the pit slope is 459 The block (3,3) is not profitable to remove because the value of the blocks ( 1,l) and (2,2) is -2 which is more than the value, +l, of the block itself. Notice that there are two degrees of shading. The darkly shaded region represents the smallest ultimate pit. The pit which includes the lightly shaded region has the same value. However, the lightly shaded region has a total value of zero, and therefore, con- tributes nothing.

The ultimate pit problem has been studied from a variety of viewpoints. One straight forward approach found in [4] is to use moving cones. If the material inside a cone (made up of slopes corresponding to the physical restriction on the pit’s slopes) contains a profitable amount of ore, then the material inside the cone is removed. The process is repeated until no more profitable cones of material exist. Questions arise when two or more cones intersect and the combined material is profitable to remove but the material in the individual cones is not profitable. Algorithms based on this approach can lead to suboptimal answers. While the basic work of [4] has been modified (e.g. [ 51) , there is still no algorithm using this approach which has been proven to converge to an optimal an- swer. However, the algorithms are fast and intuitively appealing.

Another approach has been to view the problem in a graph theoretic setting. The pioneers of this viewpoint are Helmut Lerchs and Ingo Grossmann in [ 71. More recently Zhao [ 121 has also developed a graph based method.

Lerchs and Grossmann argue that the ultimate pit problem can be cast as as one of finding the maximal valued closure of a directed graph. In their paper [ 71,

they prove that the algorithm will converge to an optimal solution. A detailed analysis of this algorithm with helpful examples can be found in [ 21. The algorithm has been successfully implemented by a variety of people, most notably Whittle in [ 111.

Another school of thought has been to look at the problem from a mathematical programming viewpoint as in [ 81 and [ 63. While these algorithms have nice convergence properties, as they currently stand, they cannot be readily implemented for realistically sized mines. The data storage requirements are too immense.

In this paper we show how the graph theoretic and mathematical programming viewpoints can be blended. As a result we see how the well established convergence properties and insights from the mathematical programming viewpoint can be combined with the very efficient data structures emanating from the graph theoretic viewpoint. Consider Lerchs and Grossmann’s approach to finding the ultimate pit. At each step of the algorithm, it ignores some of the pit slope requirements, and as a consequence is able to find a profitable pit. As the algorithm progresses, the pits selected violate fewer slope requirements. When the algorithm finally obtains a feasible pit, it can be shown that the pit is also optimal. It is our observation that this approach closely resembles the logic of a dual simplex algorithm which also moves towards feasibility while maintaining ‘optimality conditions’.

The structure of the paper is as follows. In Section 2, we will discuss the mathematical programming model. In Section 3, we present our dual simplex approach and an example is provided to guide the reader through the logic. The Lerchs-Grossmann algorithm is explained from the dual simplex viewpoint in Section 4. In the last section, we go over our empirical experiences.

2. The mathematical programming model of the ultimate pit problem

In the description of our mathematical programming formulation for the ultimate pit problem, we will refer to a representation of a block model as a graph. Let each block considered for extraction correspond to a node in a graph. The collection of nodes will be denoted by X. We will assume that the elements in X are ordered and that the value of node i E X is given by ui.

98 R. Underwood, B. Tolwinski/European Journal of Operational Research 107 (1998) %-I07

If the node j must be removed before node i, we say that i depends on node j. The dependency of node i on node j will be represented by the arc (i, j). The collection of all arcs representing the dependency of ore blocks within the mine shall be denoted by A. In this manner, our mine is represented by the directed graph G = (X, A). In the example depicted in Fig. 1, consider the block located in the fourth column of the third row with a value of +2. It depends on the blocks in the shaded (dark and light) cone above it. Thus, there would be arcs from the block (node) at the bottom of the cone to each of the overlying blocks in the cone. In general all of these eight arcs would be included in A. In the case where the shape of the block naturally provides the correct angle as in our simple example, only the immediate predecessors need be considered. Regrettably, for more complex slope angles all of the overlying blocks may need to be included. Further- more, different rock characteristics may lead to mul- tiple slope angles within the same pit. Dependencies are found for each of the other blocks in the model in the same way. For our mathematical program, we need the following additional notation. If the block represented by node i is to be removed, we will say that the binary value of the node is i = 1. When the block represented by node xi is not slated for removal, the binary value is xi = 0.

Suppose node i depends on node j, i.e. (i, j) E A. In order for i to be removed, j must also be removed. If xi = 1, we want Xj to also be 1. Hence, we will require that -Xj + Xi 6 0. Rather than actually restrict the variables to assume the binary values of 0 or 1, following the standard approach found in [ 31, we will bound the variables. Thus, we assume 0 < xi < 1. In Theorem 3.1, we will show that the proposed mathematical programming formulation will guarantee that for the optimal solution the variables xi only take on the values 0 or 1.

We will represent the accessibility constraints as follows. Let n = 1x1 and m = JAI. Consider an m x n matrix E where each row of E corresponds to an arc in A and each column corresponds to a node in X. For the row corresponding to (i, j), we require that E be - 1 in the column corresponding to node j and 1 in the column corresponding to node i. All other components in this row are defined to be 0. Let

x= (Xl,%,...,Xn)

be in R”. In this manner, all of the accessibility constraints can be represented by

Ex Q 0,

where 0 on the right hand side is the m-vector of all 0’s. The boundedness constraints simply become

O<Zx<l,

where 0 is the n-vector of O’s, 1 is the n-vector of l’s, and I is the n x n identity matrix. For a choice of x, the corresponding value of the blocks removed is

z = vrx,

wherev= (ut,u2 ,..., L’,). Thus, the linear programming formulation of the

ultimate pit problem is:

Max vTx

s.t. Ex < 0,

Ix < 1,

(1)

(2)

x 2 0.

This program will be referred to as the primal problem. We will solve the primal problem, (l)-(2), using

a dual viewpoint. With this in mind set b = [0, l] where 0 E Rm and 1 E R”. Let f be a vector in Rm+n where the first m components are indexed in accord with arcs (i, j) E A and the last n components are indexed in accord with the nodes i in X. Later we will see that f represents flows for a minimum cost flow program. Using this notation the dual cost which we wish to minimize is z = fTb. The dual program can now be stated as

Min fTb (3)

set. [ETZ] f 2 v, f 2 0. (4)

The dual program can be easily converted into the form of a minimum cost flow problem by adding n surplus variables to make the constraints equality and adding a redundant extra row to (4) to balance the flows. In the case of this formulation, we will require that f in lRm+2n and b = [O,,l,,O,], where 0, E KY”, 1, E EP, and On E R”. The vector 0, corresponds to costs for the surplus variables. The dual constraints become


M= tT [ _$ $1 , f= [;I =uI, (5)

f20, where 1 E IF, the identity matrices are n x n, and ue = - CL1 ui. The program given by (3) and (5) is a balanced minimal cost network flow program. Since the last row in (5) is redundant, to make the system have full rank we add an artificial variable fa and a corresponding column to M. We let M’ = [M le,,+l I, where e,+l E Wntl consists of all O’s except for a 1 in the last position and let f' = ( f, fa) . The cost for the artificial variable will set to 0 since any feasible flow must have fa = 0. Hence, if we set b’ = (b,O) we have fab = fTb. The revised system becomes

Min fmb’ (6)

s.t. M’f’ = v’, f’ 2 0.

The effect of the preceding model is to add an artificial node corresponding to the last row of M’ in equation (6) and an artificial arc corresponding to the last column. We will label this artificial node as 0 and refer to it as the root node. The artificial arc will be referred to as the root arc and denoted (0, r) . Define X’ = X U (0). Likewise, the set of arcs will be ex- tended by introducing the arcs (i, 0) from node i to the artificial node 0 for all nodes i E X, and the arcs (0, j) from node 0 to node j E X. In later arguments we will use the notation

Ai,={(l,O),...,(n,O)),

) ,...,(O,n)}, A,,, = { CO,1

and

A’ = A U Ai, u Am u ((0, r)).

Thus, Ai, consists of the arcs pointing into the artificial node 0, and A,, consists of the arcs pointing out of the artificial node. To be consistent we set fa = fo,r. With these extensions, we can think of the flow from node i to node j as fi,j for any arc (i, j) E A’. With this notation in mind, we see that bf,j = 1 if (i, j) E Ai, and bt = 0 for all other WCS.

Consider the following example. Suppose we wish to consider the removal of four blocks as shown in Fig. 2a. The root node is the node 0 and the root arc is indicated by the arc dangling to the right of the

root node. Let ut = u2 = us = -1 and ~4 = 4. In thisexampleAi, = {(l,O), (2,0), (3,0), (4,O))and Aout = ((0, l), (0,2), (0,3), (0,4)}. The remaining arcs are in A.

Fig. 2. An example.

Consider a solution where fa,t = 1, fo.2 = 1, f4.3 = 1, f4.e = 3, and for all other flows set fi,i = 0. The nonzero flows are displayed in Fig. 2b. From the definition of b, we have b4.0 = 1 (since (4,O) E Ai”), b4,1 = b4.2 = b4.3 = 0 (since they are associated with A), and bo,d = 0 (since (0,4) E Ain). The dual cost for this solution is 3. We can also see that the artificial node has to supply value for nodes ( 1,2} with the flows f0.l = 1, fa.2 = 1 while it receives value from nodes {3,4} via the flow f4,0 = 3.

In the next section, we will see that this interme- diate solution corresponds to removing just the nodes {3,4}, i.e. the blocks on the ‘branch’ with the flow directed into the artificial node. In all of our examples, the nodes represented by ‘squares’ in the figures are those being removed and the ones represented by ‘circles’ are those being left behind. Of course, this solution is not primal feasible. However, each step of the dual simplex algorithm tries to reduce the flow into the artificial node, thereby, forcing as much of the value as is possible into the support of positive nodes. Duality theory states that when the flow into node 0 is minimized, the primal program will be both optimal and feasible.

3. The dual simplex approach

In this section, we will discuss our dual simplex algorithm. Our goal is to describe the algorithm from the standpoint of the directed graph G’ = (X’, A’). This will allow efficient use of data structures while maintaining the simple logic of the dual simplex approach.

100 R. Underwood, B. Tolwinski/European Journal of Operational Research 107 (1998) 96-107

Our terminology is standard and is consistent with Lerchs and Grossmann in [ 71. Consider the graph G’ as defined in the previous section. Suppose that T = (X’, C’) where C’ C A’ is a rooted spanning tree for G’. Since it is ‘rooted’, the arc (0, r) always belongs to C’. Suppose we remove the arc (i, 0) from T leaving two subgraphs. Denote the nodes from the subgraph that does not contain the artificial node as /3(i). We will call this collection of nodes a strong branch of T. Similarly if we remove the arc (0, j), we will call the collection of nodes, p(j), corresponding to the subgraph not containing the artificial node a weak branch of T. Therefore, a weak branch is formed when the arc cut points away from node 0 and a strong one is formed when the arc cut points towards node 0. For the solution shown in the example depicted in Fig. 2b, the branch p(4) = {4,3} is strong and the branches p( 1) = { 1) and p(2) = (2) are weak. The argument i of /3(i) will be referred to as the root of the branch. No branch will be associated with the root XC.

It will be shown that at any stage of the dual simplex algorithm, the nodes in the union of all strong branches in a tree correspond to the nodes being ‘removed’. We will refer to the nodes in these strong branches as strong nodes. Similarly, the nodes in the union of all weak branches are those we are currently leaving behind. We refer to them as weak nodes. Since the dual simplex algorithm is moving towards feasibility while maintaining the conditions necessary for optimality, the strong nodes will not represent a feasible solution until the last step. For the solution shown in Fig. 2b, the strong nodes are the set {3,4} and the weak nodes are { 1,2}. The root node is considered to be neither strong nor weak.

We will need the lemma below regarding branches. For the tree T = (X’, C’), denote the set of all immediate successors to i E X’ as

Si = {k E X’ 1 (i,k) = (i,k) E C’}.

Similarly, the set of all immediate predecessors to j E X’ is denoted as

Pj = {k E X’ ] (k,j) = (k, j) E C’}.

The lemma can now be stated.

Lemma 3.1. Let T = (X’, C’) be a rooted spanning tree for the graph G’ = (X’, A’). Let W = & U PO.

If i and j E W, i.e. the nodes directly linked to the root node, and i # j, then p(i) n /3(j) = 0. Also, X= UiEwP(i>.

Proof. Let i and j E W and i # j. Consider the branches p( i) and p(j). By construction, neither contains the node 0. Since i and j E W and since T is a tree, the only chain connecting i to j is {{i, 0) , { 0, j}} . It follows from the definition of a branch that i q’ p(j) and j @ /3(i). We conclude that p(i) fl p(j) = 0. Suppose i E X. There is a unique chain in T connecting i to 0. Any chain connected to 0 must contain an edge (0, k} where k is in W. But then i must be in p(k). We conclude that i E UiEw p(i) . 0

The well known remark below provides the basic insight into how the graph structure can be related to our mathematical program for finding the ultimate pit. Let B be a basic submatrix for M’ consisting of n + 1 independent columns, and denote the indices associated with B by 23. Observe that the indices in 23 are arcs in A’. Similarly denote the corresponding nonbasic submatrix by N and its indices by hl.

Remark 3.1. Consider the dual program described by (6)) as defined by the directed graph G’ with root 0. Then B is a collection of basic indices if and only if its corresponding graph, T = (X’, 23)) is a rooted spanning tree of G’ rooted at node 0.

This result can be found in [ 11. Note that the arc (0, r) must always be in t3.

Recall (see [ 1 ] ) that the primal variables can be obtained from the dual solution by

xT = bT,B-‘.

Since it is known (see [ 1 ] ) that the matrix M’ is to- tally unimodular, we could argue from the unimod- ularity that x must assume integer values. However, we also want to show that when i belongs to a strong branch, we must have Ji = 1 and when j belongs to a weak branch, Xj = 0. The result is stated below as a theorem.

Theorem 3.1. Consider the minimum costflow program described by (6). Suppose we have a basis for M’ with indices 23 and corresponding rooted spanning tree T = (X’, f3). Let SO be the set of immediate


successors to the root node 0 relative to T and PO be the set of immediate predecessors to 0 relative to T. If 3 E SO, then for all nodes j in the weak branch /3( ‘j), the binary value Xj is 0. If? E PO, then for all nodes i in the strong branch B(z) the binary value xi is 1. Furthermore, x E I%“+’ can be constructedfrom the nodes in the weak and strong branches to satisfy BTx = bn, where bn consists of elements in b with indices in B. Lastly, all Xi are = 0 or = 1.

Proof. Suppose we have a basis for M’ with basic indices B and basic matrix B. From Remark 3.1, we know there is a spanning tree T = (X’, C’) where C’ = !3. Consider the system

B=x = bn, (7)

where x E R” and bn consists of elements in b with indices in a. From the definition of M’ in (6), we know that when node i depends on node j, we have

BTj x = xi - Xj = bi3j. (8)

Also, since B has rank n + 1, the root arc must be in any basis. In this case, (7) yields xa = bo = 0. Denote

Ci, = Ai, n C’, Co,, = A,,, n C’, C=AnC’.

Lemma 3.1 tells us that the nodes in the tree T be- long to unions of strong and weak branches. The arcs connecting the nodes within the branches correspond to columns from E. For these ucs we have bi,j = 0. Hence, (8) implies that xi = Xj. Consequently, all nodes in a branch must assume the same value, and the value of the nodes in a branch are determined by value of the branch’s root node.

First consider the case of a weak branch. Suppose there is a node 1 E SO from the tree T. The arc (0,;) E Gout, and from the definition of b, we see that bo,j = 0. But xc = 0, which together with (8) means that x; = 0. From the preceding comments, it follows that all nodes i in the weak branch /3(j) have binary value Xi = 0.

Now consider the strong branch case. Suppose there is a node 1 E PO which is linked to the root node 0 through arc (1,O) E Ci,. Here we have b;,, = 1. As before xc = 0 implies that x; = b;,,. Therefore, x; = 1, and all nodes in the branch p( ?) inherit its value. Thus, if i E B(1?), then xi = 1.

From Lemma 3.1, X = lJiEw p(i) where W is the set of all immediate successors and predecessors to the root node 0. Thus every node in X is assigned a value of ‘+l’ or ‘0’ depending on whether it is in a strong or weak branch. Furthermore, x satisfies (7). This completes the proof. 0

Our algorithm will move from one basic solution of the dual to another. The next result tells us that when considering new arcs to bring into the basis, we need only to look at arcs joining strong nodes to weak nodes. Expressing the dual cost described by (6) in terms of the corresponding nonbasic variables gives

z = zo + r& + r>fhf, (9)

where

rn=On=b;-b;B-‘B

and

rN = b% - b;B-‘N.

From (9) it follows that a nonbasic variable fij should be introduced into the basis when the corresponding reduced cost ri,j is negative. The next theorem provides a simple rule for making this determination.

Theorem 3.2. Suppose we have a collection of basic variables with indices 23 with corresponding spanning tree T = (X’, a). Suppose i is a strong node and j is a weak node. The reduced cost ri,j associated with this nonbasic arc (i, j) has a value of ri,j = - 1. The reduced costs ri,j for all other nonbasic arcs have values equal to 1 or 0.

Proof. Consider the program given by (6) and let T = (X’, f3) be a spanning tree associated with the collection of basic variables having indices f?. For all nonbasic arcs it follows from the definition of r;,j in (9) that

ri,j = bi,j - XTNi,j = bi,j - (Xi - Xj ) . (10)

Suppose the nonbasic arc (i, j) belongs to A-B. From b’s construction bi,j = 0, and therefore, ( 10) implies that

ri,j = -Xi + Xj. (11)

We need to consider four cases related to the strength of the nodes.

102 R. Underwood, B. Tolwinski/European Journal of Operational Research 107 (1998) %-IO7

Consider a nonbasic arc (i, j). Suppose node i is strong and node j is weak. It follows from Theorem 3.1 that ri,j = - 1 + 0 = - 1. If node i is weak and node j is strong, ri,j = -0 + 1 = 1. If both nodes are weak, ri,j = -0 + 0 = 0, and if both are strong, ‘i,j = -1 + 1 = 0.

The only arcs not yet considered are those connected directly to the root node. For the introduction of an arc into node 0, we have, bi,a = 1. Hence, ri,a = 1 - xi = 0 if node i is strong or ri,a = 1 - Xi = 0 if node i is weak. For the introduction of an arc out of the root node 0, ba,j = 0 and ra,j = -0 + Xj. Here ra,j = 1 or 0 if node j is strong or weak.

We conclude that r;,j = -1 only when node i is strong and node j is weak. In all other cases ri,j 2 0. This is what we wanted to show. Cl

From the computation of r outlined in the proof of Theorem 3.2 it follows that when there is a strong node depending on a weak node, the dual cost can be reduced by introducing an arc between these two nodes. In summary, we see that for the dual program:

?? a spanning tree corresponds to basic feasible solution;

?? the binary values for n in the primal program are 1 if the node is strong and 0 if it is weak; and

?? a spanning tree with lower cost can be found by introducing an arc between a strong node and a weak node.

The only question that remains is to determine the arc that must be swapped out of the basis. Suppose our current basis corresponds to the rooted spanning tree T = (X’, C’), and let the arc (?, T) be added to the current tree to form the graph T’ = T U { (;, j) }. From Remark 3.1 it follows that a single cycle K has been introduced into the graph T’. Let S be an increase in flow about this cycle and set fi,; = 6. The arcs with the same orientation as fi,~ will have flows increase by the amount S. The flows of those with the opposite orientation will decrease by the amount S. There must be some arc with orientation opposite to f7,; for otherwise the program is unbounded. Let R E A’ be the arcs in the cycle K of T’ with their orientation the reverse of fi,j. Since all flows must remain nonnegative, the increase in S is blocked by the smallest flow in the opposite direction, i.e.

S = f;,j = min{ fi,j 1 (i, j) E 72). (12)

In light of these observations, we see that there is no need to actually compute a, x or r since these values are automatically known from the structure of the tree. Therefore, the dual simplex algorithm for the ultimate pit problem can be restated as:

Step 1. Form an initial feasible spanning tree T (i.e. find an initial basis). Step 2. Search for a strong node which depends on a weak node (i.e. find an arc to introduce into the basis). If no such node exists, then an optimal solution has been found and the algorithm terminates; else, set the strong node to s and the weak node to w. Step 3. Add the arc (s, w) to the graph T and determine the cycle K formed in the graph T’ = T U {(s, w)}. In accordance with (12) compute 6, and determine the arc (7, j) which blocks the increase in flow (i.e. determine the arc to remove from the basis). Step 4. Compute the new flows by adding and sub- tracting S (depending on the arc orientations) from the flows in the cycle K. Construct a new spanning tree T by removing the arc (;,j) from the previous tree and adding the arc (s, w) . Reclassify the strength of the nodes in the new branches formed by breaking the cycle across the arc (7, i> ; one new branch when (793) 6 & ‘J&N, two new branches when (2, ?) E A (i.e. update the tableau). Return to Step 2.

Consider the example displayed in Fig. 3. Here X’ consists of nine nodes plus the artificial node. The dependency relationships are given to be A = {a,,, ~,2,

a6.3, al.2, a7,3, a7.4, a8.3, a8.4. a8,5, a9.6, a9.1, a9.8).

We will ignore the root arc. The graph on the left in Fig. 3 is an initial span-

ning tree with strong branches /3( 6)) p(7), and /3( 9). Again, strong nodes are represented by squares and weak nodes by circles. Thus, xg is a strong node and it depends on the weak node xs. By adding the arc (9,8) to the tree, the cycle ({9,8}, {8,0}, {0,9}) has been introduced. To assure conservation of flow around the cycle, an increases in flow of S across the arc (9,8) must be accompanied by a decrease in flow of 6 across the arcs (9,0) and (0,8) of opposite orientation. From ( 12) we see that 6 = min{ 1,2} = 1. Consequently, the flow fO,g is reduced to zero and the arc (0,8) is removed from the spanning tree. The new spanning tree is formed by adding the arc (9,8) to the initial spanning tree and deleting the arc (0,8). The

R. Underwood, B. TolwinskilEuropean Journal of Operational Research 107 (1998) 96-107 103

Fig. 3. An initial spanning tree and the change to a new spanning tree.

branch p( 9) is strong, and therefore, any nodes in the branch that are weak must be reclassified as strong. In this case, node 8 becomes strong. The new tree is shown in the left graph of solid lines in Fig. 4.

A few more steps through the algorithm will high- light some of the more subtle issues which need to be dealt with in the algorithm. In the next step, we introduce the arc ( 8,4). Here the increase in flow across (8,4) can be no more than 1. Notice that there is a tie, and therefore, there are two places, (9,0) and (0,4), where we could break the cycle. If we cut the arc (0,4), we will have zero flow from the strong branch p(9) into the root node 0. From a pure optimization viewpoint it makes no difference where the cut is made. From a pragmatic viewpoint, it is desirable to remove as few blocks as possible. Hence, we will make the cut across (9,0) making all of the nodes in the branch p( 4) weak. The new graph is displayed in the right most graph of solid lines in Fig. 4.

It is evident that the strong node 7 depends on the weak node 4. In this case we have a cycle which tra- verses through the nodes 0,7,4 back to 0. Because of the aforementioned tie, the flow across (0,4) is zero. Hence, S = 0 and the ‘new’ flow across the arc (7,4) is still zero. Here the flows do not change but the spanning tree does. We remove the arc (0,4) and add the arc (7,4) to get the graph in solid lines shown in the graph on the left in Fig. 5. The branch p(7) in the new spanning tree is strong and the nodes {4,8,9} are reclassified as strong.

In the next step we introduce the arc (8,5) between the strong node 8 and the weak node 5, and forming a cycle around the nodes {0,7,4,8,5} and back to 0. Again we have a tie. We choose to make the cut across (8,4) rather than (0,5). As before in ‘the situation

where the choice is not unique, we eliminate the arc which will leave us with the smaller pit. The result is shown in the rightmost graph in Fig. 5. Observe that in this last spanning tree the branch fi( 5) is weak but has zero flow across (0,5). The profit from mining the blocks { 5,8,9} is zero. Another dual feasible solution would be to choose the reverse arc (5,O) instead of (0,5), and thereby, make the branch p(5) strong. In this case we would remove the blocks in the branch p(5). The dual value would be the same but the pit would be larger. Continuing in this manner, we see that the ultimate pit removes the blocks { 1,2,3,4,6,7}. There are numerous graphs which will yield the same ultimate pit.

4. The Lerchs-Grossmann algorithm

The problem which both our algorithm and that of the Lerchs-Grossmann address is to find the maximum value closure of a graph. Both approaches solve the problem by forming a sequence of spanning trees which are partitioned into strong nodes and weak nodes. The strong nodes correspond to the nodes which are desirable to remove. The goal of both algorithms is find a collection of strong nodes which are feasible. Recall that a strong node is feasible when there are no weak blocks above it which must first be removed in order to allow access to the block. When this is not the case, there is a strong node which depends on a weak node. At each stage of either algorithm, a new arc is introduced connecting a strong node to a weak node with the hope of forming a new tree which will be feasible. When a new arc is introduced, a cycle is formed which must be subsequently

4’

104 R. Underwood, B. Tolwinski/European Journal of Operational Research 107 (1998) %-I07

Fig. 4. The second and third iterations.

Fig. 5. The fourth and fifth iterations.

broken in order to have a spanning tree for the next stage. The major difference between Lerchs- Grossmann’s algorithm and the one presented in the previous section is the manner in which the cycle is broken. In the discussion that follows, we will continue to use our definitions for strong and weak branches as defined in Section 2. This deviates some- what from Lerchs and Grossmann’s terminology but the description that follows is fundamentally the same. The interested reader should consult their paper [ 71.

Suppose a strong node s depends on a weak node w and the arc (s, w) is added to the current spanning tree thereby creating a cycle. For our algorithm, the cycle is broken by analyzing the change in flow, 8, around the cycle. The value of S is chosen so as to increase this flow as much as possible while maintaining dual feasibility. The Lerchs-Grossmann algorithm implicitly chooses S using a different strategy. Rather than compute S, they follow a simple rule for removing the arc. Consider the strong branch containing s. Suppose rs is the root for this strong branch. Since it

is a strong branch, the arc joining the branch to the artificial node 0 is ( rs, 0) , i.e. it points towards x0. Ler- chs and Grossmann always remove this arc. From our viewpoint this means that the flow, S, around the cycle is chosen so as to reduce the how across ( rs, 0) to zero. Hence, S is chosen to be the flow across ( rs. 0) , i.e. S = f,.,,c, which when subtracted from the flow across ( rs, 0) reduces it to zero. The remainder of the flows around this cycle are changed by +6 or 4 depending on the orientation of their arcs. As with our algorithm the flow along (s, w) becomes +S. Since no effort is made at this stage to guarantee dual feasibility, the resulting flows may become negative. Three things may happen. After we describe these situations, we will step through an example.

1.

2.

The flows around the cycle remain nonnegative. In this case, the arc ( rs, 0) is removed from the spanning tree and the new branch rooted at rw is weak. All the flows around the cycle remain positive with the exception of the flow along the arc

R. Underwood, B. TolwinskiIEuropean Journal of Operational Research 107 (1998) 96-107 10.5

(0, r,) . Again ( rs, 0) is removed from the spanning tree but in order to have the new dual solution remain feasible the arc across (r,, 0) is reversed. Correspondingly, the branch rooted at r, becomes strong.

3. More than one flow around the cycle becomes nonpositive. When this occurs, the routine Nor- malize Tree as described below is used to correct the infeasible flows.

Procedure Normalize Tree Suppose the flow across (p, q) is negative and has flow fP,4. Introduce the arc (q, 0) into the spanning tree. Change the flow around the cycle introduced by this arc by 6 = - fP,q. This results in a new strong branch rooted at q. The change in flows around the cycle are changed by + or -6 as before. This procedure is repeated until all flows are nonnegative, and therefore, dual feasible.

4.1. An example of the Lerchs-Grossmann algorithm

An example of the Lerchs-Grossmann algorithm is displayed in Figs. 4-8. The pertinent flows are shown along the arcs between the nodes. We start with the same initial spanning tree as in Fig. 3. As before node 9 is strong and depends on the weak node 8. We introduce the arc (9,8). Using our ‘dual’ algorithm, S was found to be 1 and the arc (0,8) was cut from the tree. In the case of Lerchs-Grossmann the arc (9,0) is automatically removed from the tree (see Fig. 6 ). To force the how along this arc down to zero, we choose 6 = 2. But this implies that the flow along (0,8) must be fe,s = - 1. We make the solution dual feasible by swapping arc (0,8) for (8,0). For this configuration fs,O = 1. This is an example case 2 mentioned above. Either method leads to a strong branch containing the nodes {9,8}.

For the next step, we can add the arc (8,4) to the tree. Here the flow, fs,e, out of the strong branch (see Fig. 6) is reduced to zero by choosing 6 = 1. Notice that the flow f0.4 = 0, and we do not re-orient the arc (0,4) (see Fig. 7). Hence, the branch rooted at 4 is weak. This assures us that we are always choosing the smallest pit among those with the same value. This step is an example of case 1 above.

The strong node 7 depends on the weak node 4. Therefore, we add the arc (7,4) to the spanning tree

(see Fig. 7). If we adjust the flows by S = f4,0 = 4 and re-orient the arc (0,4) according to case 1 above, we get the new tree shown in second graph of Fig. 7. The new branch consists of nodes {7,4,9,8} and is rooted at 4. Since the flow f4.0 = 4 > 0, the branch is strong.

The last iteration that we will examine demonstrates the normalize tree procedure. This step is depicted in Fig. 8. Observe that the node 8 is strong and the node 5 is weak. As a consequence, we add the arc (8,5) to the tree. Recall that the flow out of the strong branch is f4,e = 4 (see Fig. 7). The flows are adjusted by S = 4 according to their orientation. Notice that this adjustment leaves us with a flow of f8.4 = -3 across (8,4). Also, the flow across (0,5) is -3 < 0. This second flow can be re-oriented into the artificial node xc making it positive, and therefore, feasible. To correct the flow f&4 is more involved. We introduce the new arc (4,0) which creates a cycle between the nodes 0,4,8,5,0. We change the flow around this cycle by S = 3. This makes the flows f&4 and fc,s become zero and the flow along the new arc becomes f4,c = 6 = 3. Since f&4 = 0, we break the cycle by removing the arc (8,4). As a consequence, we are left with a strong branch rooted at 4 and a weak branch rooted at 5. The weak branch has a how of zero into it. As a result of ‘Normalize Tree’ adjustments, the new tree is feasible. Thus, Lerchs and Grossmann’s ‘Normalize Tree’ procedure is their way of obtaining dual feasibility.

5. Conclusions

Both the dual simplex and LG algorithms have been implemented and tested extensively on real mines having up to 2 500000 blocks. All of the experiments were run an Intel 486 (66 MHz) processor. For the largest block models the computation time was ap- proximately 5 hours. The codes differed only in so far as the algorithms differed.

The critical aspect of correctly modeling the ultimate pit problem is an appropriate view of the dependencies between blocks. Recall that each block in the mine depends on the blocks above it. The exact nature of the dependency is determined by the angle of the pit slopes. The slopes may vary throughout the mine as engineering considerations dictate. To obtain a pit with required pit slopes, for each block, b, we need

106 R. Underwood~ B. Tolwimki/European Journal of Operational Research 107 (1998) %-I07

Fig. 6. A first step for the Lerchs-Grossmann algorithm.

Fig. 7. A second and third step for the Lerchs-Grossmann algorithm.

Fig. 8. An example of the normalize tree procedure.

to know which blocks need to be removed prior to b. before b. Depending on the slope angles and block The accepted manner of describing these blocks is to dimensions these cones may involve anywhere from form an inverted cone with vertex at b (see Fig. 9) 50 to 250 blocks. We have observed that examining and require that all blocks in this cone be removed block dependencies in this manner is the single most


Fig. 9. Cone of dependencies.

time consuming task in any ultimate pit algorithm. In testing the two algorithms described in this paper

we found that for the dependency cones of practical size as previously mentioned, 95-98% of the overall run time was spent on checking block dependencies. One should keep this fact in mind when interpreting results of computational experiments.

We compared the two algorithms on two block models which we shall refer to as A and B. Model A was 82 x 118 x 24 and B was 77 x 106 x 50. The last di- mension represents depth. The total run time in min- utes:seconds for mine A was 19:28 for the dual simplex and 20:06 for Lerchs-Grossmann. In the case of mine B, the times were 33: 13 for the dual simplex and 35:04 for Lerchs-Grossmann. Both algorithms search for a strong node’s dependence on a weak node in the same manner. The algorithms differ in how the change in flows are updated once the new arc between the strong and weak node is introduced. It is this last mod- ification which is responsible for the improved performance.

The main contribution of this work is to provide an interpretation of the graph theoretic methodology in a mathematical programming setting so that the convergence and implementation issues can be analyzed from a mathematical programming viewpoint. In fu- ture work, we would like to explore various rules for

the order in which we inspect the nodes in the trees to see if there are any further algorithmic modifications which will improve performance. For instance other network flow algorithms may be of interest. Lastly, we note that from a pragmatic viewpoint how one imple- ments the checks on dependencies between nodes can have a dominant effect on overall performance.

References

Ill

121

[31

[41

[51

[61

t71

[81

[91

[lOI

t111

[I21

M. Bazaraa, J. Jarvis, M. Sherali, Linear Programming and Network Flows, Wiley, New York, 1990. G. Bond, A mathematical analysis of the Lerchs and Grossmann algorithm and the nested Lerchs and Grossmann algorithm, Ph.D. Dissertation, Colorado School of Mines, May 1995. K. Dagdelen, Optimum multi-period open pit mine production scheduling, Ph.D. Dissertation, Colorado School of Mines, September 1985. M. David, P. Dowd, S. Korobov, Forecasting departure from planning in open pit design and grade control, in: Proceedings of APCOM 1974, Golden, CO, April 1974. P. Dowd, A. Onur, Optimizing open pit design and sequencing, in: Proceedings of APCOM 1992, Tucson, AZ, April 1992. T. Johnson, A comparative study of methods for determining ultimate open-pit mining limits, 11th Conference on Application of Computer Methods in the Mineral Industries, University of Arizona, Tucson, AZ, April 1973. H. Lerchs, 1. Grossman, Optimum design of open-pit mines, Transactions, Canadian Institute of Mining 68 (1965) 17-24. J.-C. Picard, Maximal closure of a graph and application to combinatorial problems, Management Science 22 ( 11) (1976) 1268-1272. B. Tolwinski, R. Underwood, An algorithm to estimate the optimal evolution of an open pit mine, in: Proceedings of APCOM 1992, Tucson, AZ, April 1992. B. Tolwinski, R. Underwood, A scheduling algorithm for open pit mines, to appear in IMA Journal of Mathematics Applied in Business and Industry. J. Whittle, Beyond optimization in open-pit design, in: Proceedings of the Fit Canadian Conference on Computer Applications in the Mineral Industries, A.A. Balkema, Rotterdam, pp. 331-337. Y. Zhao, Y.C. Kim, A new optimum pit limit design algorithm, in: Proceedings of APCOM 1992, Tucson, AZ, April 1992.

Documents

A mathematical programming viewpoint for solving the ultimate pit problem