c),

Computers d Chemical Engineering, Vol. 3, pp. 363-371, 1979 0098-1354/79/040363-09E02.00/0

Printed in Great Britain. All rights reserved. Copyright © 1981 Pergamon Press Ltd.

Paper 6B.2

A NEW ALGORITHM FOR PROCESS FLOWSHEETING

R. HERNANDEZ and R. W. H. SARGENT*
Imperial College, Department ofChemical Engineering and Chemical Technology, Prince Consort Road,
London SW7, England

(Received 3 November 1979)

Abstract—A new algorithm is described for organizing the computations in a process

flowsheeting system designed to handle mixed systems of equations and procedures. It is
essentially a depth-first implicit enumeration algorithm based on partitioning and tearing
techniques, but also uses automatic algebraic manipulation to take further advantage of the
structure.

Scope—Process design or simulation gives rise to the need for solving large sets of nonlinear
algebraic equations. For steady-state calculations the equations are naturally algebraic, at least
for lumped-parameter models of individual units, while dynamic problems involve mixed
systems of algebraic and differential equations whose solution in turn involves repetitive
solution of algebraic systems.
Typically problems give rise to sets of several thousand equations, but each equation will
usually involve only a dozen or so variables, and this sparsity must be exploited for efficient
solution. The equations have a definite structure, reflecting the structure of the process units
and the topology of the process flow-diagram, but this structure varies from problem to
problem and does not conform to a fixed sparsity pattern, as occurs for example in the
numerical solution of partial differential equations. Thus the solution procedure must include
means for detecting the sparsity pattern and appropriate means of compact storage of the data
for arbitrary sparsity patterns.
Large sparse systems of this type can usually be decomposed, or 'partitioned' into a set of
smaller problems which can then be processed sequentially, results from one problem
providing data for the next. There are then two basic approaches to solving these sub-
problems, either simultaneous solution or the use of further decomposition by `tearing'—the
choice of a certain subset of variables, whose values are adjusted in an outer loop, such that the
subset of equations determining the remaining variables can be further partitioned, usually into
a sequence of single-variable problems.
In both approaches one is left with residual sets of nonlinear algebraic equations to solve,
which are most effectively dealt with by either Newton's method or a quasi-Newton method.
These methods require the solution of systems of simultaneous linear equations involving the
Jacobian matrix of the system or an approximation to it, and hence the generation of its inverse
or its factorization. In the simultaneous solution approach this matrix reflects the sparsity
pattern of the underlying nonlinear system, and if the storage problem is not to get out of hand
solution techniques must be used which minimize the increase of density, or fill-in of non-zero
elements, in the inverse or factorization.
In spite of the development of these general techniques for large systems of equations over
the last fifteen years, the parallel development of chemical process flowsheeting systems has
made little use of them. Most flowsheeting systems rely on the building up of a library of
special-purpose routines for the design or simulation of the various units used in chemical
processes, with an executive programme which uses the topology of the process flow-diagram
to link these routines into a computable sequence. Again tearing techniques are used to deal
with recycle streams or other information loops arising from controls or design specifications.
There are obviously great advantages to be gained from writing special-purpose routines for
standard units. Not only can the sparsity-pattern of their describing equations be exploited,
but also their algebraic structure, and account can even be taken of numerical conditioning,
derived from the known physical behaviour of the unit. However the rigid structure of the unit
routines in general makes the composite solution for the whole process less effective,
particularly for design or dynamic simulation. The relative computational advantages of the two
approaches is still a subject of debate, but the great drawback of procedure-based flowsheeting
systems is the effort involved in building up a sufficiently comprehensive library of routines,
and the inevitability of the occurrence of many special units, with the consequent need for much
one-off programming for any particular problem.
Of course an equation-oriented flowsheeting system also needs a library of models for
standard units, the difference being that these are merely sets of describing equations which are

* Author to whom correspondence should be addressed.

363
364 R. HERNANDEZ and R. W. H. SARGENT

assembled by the executive, again using the process flow-diagram. Thus the models are easier
to write and debug, and no expert knowledge of numerical methods is required, since these are
built into the main executive programme. However, although automatic algebraic
manipulation has made great strides in recent years, making possible some exploitation of
algebraic structure, it would at present be prohibitive in computing costs to provide for
automatic sensitivity analysis of the assembled system of equations. Hence a practical flow-
sheeting package ought to be capable of dealing with mixed systems of procedures
(subroutines) and equations, so that special-purpose routines can be used for subsets of
equations known to be ill-conditioned. Such a system of course also has the advantage that
existing libraries of routines, both for process units and for physical property calculations, can
be incorporated if desired.
Sargent [1] has given a review of the techniques now available for partitioning and tearing of
both systems of procedures and systems of equations, and outlines an algorithm for dealing
with mixed systems. Duff [2] gives a more detailed review of sparse matrix techniques, and Lin
& Mah [3,4] describe the implementation of their own 'hierarchical partitioning' algorithm
for the simultaneous solution of the sparse irreducible subsets obtained after partitioning. The
present paper describes the implementation of the algorithm for mixed systems outlined by
Sargent [1], and discusses the more extended use of automatic algebraic manipulation. To
explain the motivation for the algorithm some general properties of systems of equations are
summarized in Section 1, the algorithm is described in Section 2, and the problems associated
with its implementation are discussed in Section 3.
Conclusions and Signifiance—A number of problems exist in the implementation of the
previously outlined algorithm. Their solution by the use of standard programs for algebraic
manipulation appears promising. However, with present programs such use will be expensive
in computing time but significant savings can be made by special-purpose coding. We need• to
have a clearer idea of the benefits of this approach before undertaking it.

1. SYSTEMS OF EQUATIONS example the resulting subproblems are irreducible, in

1.1 Partitioning and tearing
In this section we consider only 'square' systems,
containing the same number of equations and vari-
ables, and assume that the system has a solution.
Let us first consider the following example:
fl (Xl, X2, X5, X6) =0
12 (X19 X3) =0
A (X i, X2, X3, X4, X6) = 0 (1.1)
f4 x3) =o
A (xi, x2, x4, xs, x6) = 0
f6 (x 1, x3, x 5) = 0.
These six equations in six unknowns could in principle
be solved simultaneously. However, instead we could
start by solving the second and fourth equations for x i
and x3, then the last equation for x5, and finally the
remaining three equations for x2, x4 and x6. Such a
decomposition saves both storage and computation
time.
Analyses of decompositions like this are made more
easily by use of the occurrence matrix M of the system,
which has a row for each equation, a column for each
variable, and elements defined by
1 if variable j occurs in equation i
Mu = (1.2)
0 otherwise
The occurrence matrix for system (2.1) is given in Fig.
1(a).
The above decomposition into a sequence of sub-
problems is equivalent to reordering the rows and
columns of the occurrence matrix to put it into block
triangular form, as shown in Fig. 1(b), and this process
is known as 'partitioning' the system. In the above
the sense that none of them can be further partitioned.
It is well known (see [1] for a proof) that the partition
of a square system into a sequence of irreducible
subsets is unique to within permutations of disjoint
subsets (i.e. subsets of equations with no variables in
common other than those occurring in earlier subsets
of the sequence).
The irreducible subsystems can be further de-
composed by 'tearing'. For example, in the first
subsystem of Fig. 1(b) we could guess x3, compute x4
from Eq. (4), and then a new value of x3 from Eq. (2),
which can be used to revise the estimate of x3 in order
to repeat the iteration. Similarly in the last subsystem
we could guess x6, then compute x2 from Eq. (1), x4
from Eq. (3), and finally a new value of x6 from Eq. (5).
Thus the system has been decomposed into a sequence
of one-variable problems. Each equation is solved for a
certain variable (its 'output variable'), and the guessed
(or 'torn') variables form outer iteration loops linking
all the variables and equations in their subset. In Fig.
1(b) the variables have been ordered so that the output
variable for each equation lies on the diagonal of the
occurrence matrix.
The approach to developing algorithms for par-
titioning and tearing has been to start by finding a
feasible assignment of output variables to equations.
Each equation then becomes a 'procedure' for calculat-
ing its output variable from the other variables
occurring in it, taken as inputs, and standard algor-
ithms for partitioning and tearing of directed graphs
may then be used, as described by Sargent [1].
However these algorithms are not trivial, and the
finding of an output set is itself not a trivial task.
Moreover, although the partitioning is unique, and
hence obtained from any feasible output set, the
conditioning of each subproblem and the minimum
number of torn variables required for complete de-
composition both depend on the choice of output set,
 New algorithm for process flowsheeting 365

Variables Variables
I 2 3 4 5 6 I 3 5 2 4 6

I I I I I 4 0 I

N
2 1 I 2 I 0
0 3 1 I I I i
C
0 6 I I 0
0
cr
w 4 1 I
S
L
cr I I I C) I
5 1 I I I I 3 I I I 0 I
6 I I I 5 I I I I 0
(a) (b)
Fig. 1. Occurrence matrix and partitioning.

and the computing requirements for analysing each be less than the minimum number for the complete
subproblem for all possible output sets become decomposition of any subset, and we shall use this
prohibitive. result later.
Further difficulties are illustrated in the example in
Fig. 2, which gives an occurrence matrix already in
partitioned form. A possible solution procedure for the 1.2 Rectangular systems
first block is to guess variables 1 and 2, compute So far we have considered only square systems, with
variables 3-5 in turn from Eqs. (1)—(3) respectively, the same number of variables and equations. However
then use the residuals of Eqs. (4) and (5) to correct the most design problems yield rectangular systems, with
guesses. However this scheme does not use a feasible many more variables than equations. The additional
output assignment, since variable 1 does not occur in degrees of freedom may be taken up by heuristic
either of Eqs. (4) or (5) ! Thus even if we analyse the choices of some variable values on the part of the
system for all possible output sets, we shall still miss a designer, and clearly a judicious choice of the variables
whole class of feasible solution schemes—which could so fixed could simplify the analysis of the remaining
well contain the optimum scheme! square system—for example by decreasing the size of
Each block in Fig. 2 requires at least two torn the irreducible subsets and the number of tears re-
variables for complete decomposition of the block, quired for complete decomposition. On the other hand
making four torn variables for the whole system. the choice is not completely arbitrary—for example we
However we could start by guessing variables 6 and 7, cannot independently fix all mole fractions in a
then compute variables 8, 9,1 and 2-5 in turn as output mixture since their sum must be unity.
variables of Eqs. (6)—(9) and (1)—(3) respectively, finally For a system of m equations in n variables (n m),
using the residuals of Eqs. (4) and (5) to correct the we can imagine the extra (n — m) degrees of freedom
guesses. Hence the minimum tear set for the un- taken up by adding (n — m) extra equations, each
partitioned system is smaller than the union of the containing all the variables. We then have a square
minimum tear sets for the partitioned blocks, and it is system, for which we know there is a unique partition,
not necessarily optimal to partition first and then and since the extra equations contain all the variables
analyse the individual blocks! they must be in the last block. Hence these equations
Of course the minimum number of torn variables for can be permuted to the last (n — m) rows and then
the unpartitioned system cannot exceed the sum of the deleted, leaving a unique partition of the original
minimum numbers for each block (since their union is rectangular system. The situation is illustrated in Fig. 3
a feasible tear set for the whole system). Sargent [1] has for 5 equations in 7 variables.
also shown that the number of torn variables for We see that the free 'decision variables' fixed by the
complete decomposition of the whole system cannot designer must be taken from the last block, and a

Variables

I 2 3 4 5 6 7 8 9
Variables

0
-

I
I 2 3 4 5 6 7
0
C\Ir+)

I I

I I 0 I I I

2 I I ;
,

I I I
tIn

1 i
I I 0 3 I L P
I
0 1
6 I I 0 3
0"
4 II I I
I ■ I I I
7 I I 0 5 I
-I I I :I 1 I I I
8 I I I I
-I I III I I I
9 I I I I I

Fig. 2. Tearing. Fg. 3. Rectangular system.

366 R. HERNANDEZ and R. W. H. SARGENT
judicious choice may permit further partitioning of
this block, as indeed happens in Fig. 3.
Alternatively, the rectangular system of equations
may form equality constraints in a mathematical
programming problem. Partitioning and tearing may
then be used to solve for some of the variables, thus
reducing the effective size of this programming prob-
lem. Specifically we choose 'decision
variables', yielding a sequence of (n — d) one-variable
equations to solve for the remaining variables, and a
set of (d — n + m) residual equations as equality
constraints in the reduced problem. From the above it
is clear that (n — m) of the decision variables must be
taken from the last block ; the other decision variables
and the residual equations arise from the complete
decomposition of the resulting set of square
subsystems.
1.3 Computing costs
It is clear from the results of Section 1.1 that the
commonly accepted strategy of partitioning, followed
by complete decomposition using the minimum
number of torn variables within each subset, is not
necessarily optimal, and in this section we attempt a
more detailed examination of computing costs. We
shall assume that the one-variable problems and sets
of nonlinear equations are solved by a quasi-Newton
method. Such a method starts with estimated values of
the variables, and at each iteration requires the
computation of the residuals of the equations, from
which new estimates are obtained by solving an
approximating linear system. The coefficient matrix of
this linear system may be regarded as an approxima-
tion to the Jacobian matrix, and has the same occur-
rence matrix as the nonlinear system itself ; it is best
stored in factored form to conserve sparsity and
facilitate the solution of the linear equations. The
residuals are also used to update the factors of this
approximate Jacobian at each iteration, and the work
involved both for this update and for the generation of
the new estimates of the variables is proportional to
the number of non-zero elements (e) in the factors. The
cost of computing the solution is then
C = N(ae + E (1.3)
i=
where N is the number of quasi-Newton iterations, a is
a constant depending on the quasi-Newton method
used, and ri is the cost of evaluating the residual of the
ith equation. The constant a and the ri can be obtained
by operation counts.
It is worth noting that (1.3) applies to a rectangular
system, provided that the additional degrees of free-
dom are taken up by specifying values of an ap-
propriate number of variables; the additional work
affects only the values of the ri.
We first consider the simultaneous solution of a
sparse set of equations. Whatever form of factorization
is used, the fill-in is usually a convex function of the
number of non-zero elements in the original matrix.
Thus if we assume that each equation contains ap-
proximately the same number of variables, the number
of non-zero elements is proportional to m and hence e
is a convex function of m. Similarly N tends to increase
with the size of problem, and it is not unreasonable to
assume it is a non-decreasing function of m.
We can now compare the solution of the un-
partitioned system with that obtained by partitioning
into two subproblems. Using the above properties, and
with an obvious notation, we may then write
m = mi + m2, e ei + e2
(1.4)
N N 1, N N2.
Assuming the equations are ordered according to the
partition, we then have
m,
C — (C, + C2) = N(ae + E — N i(ae, + E r,
i=1
— N 2(ae2 + E
i=+1 ri)
N(ae + E ri) — N(ae, + iE ri
i 1
m
— N(ae2 + E ri
1=m,
Na(e — el — e2) 0.
Since one of the inequalities in (1.4) will usually be
strict, it thus follows that under the given assumptions
it will usually be advantageous to partition the system.
Since the same argument applies in turn to each of the
subproblems, the cost will usually be minimized by
partitioning into irreducible subsets and solving these
sequentially.
When a system is completely decomposed by tear-
ing, the approximate Jacobian matrix for the outer-
loop iteration on the torn variables is usually full, and
hence e = where t is the number of torn variables.
The residuals for this system are the residuals of the
last t equations, after substituting the results from the
(m — t) one variable problems. Thus the cost of com-
puting the solution may be written
C= E Cate + E riNij , (1.5)
i=1 1=1
where N, is the number of iterations required to solve
equation i during the jth outer iteration, with Nu = 1
for the last t equations. We also have N1 = 1 if
equation i is linear (hence explicit) in its output
variable ; otherwise N1 depends on the conditioning of
the equation, and also on the distance of the initial
value from the solution, which in turn depends on the
rate of convergence of the outer loop. However it is
reasonable to suppose that N is a non-decreasing
function of t, and that we may write
N
E Nu = piN, pi Z 1, (1.6)
1=
where pi, if not constant, is only a slowly varying
function of t. Using (1.6), the cost in (1.5) may then be
written
C = N(at2 + E (1.7)
i=
The justification of tearing is based on the assumption
that the increased work in solving the one-variable
problems at each iteration is more than compensated
by the reduction in the number of iterations, and to a
lesser extent by the reduced work in the update for the
smaller outer-loop problem. This reasoning naturally
leads to the choice of the minimum number of tears to
 New algorithm for process flow sheeting
achieve the decomposition. However it is not obvious
from (1.5) or (1.7) that this will generally be optimal. It
will obviously be so if the first term in (1.7) is much
larger than the second, or if N is a strongly increasing
function of t, but neither of these situations is likely to
be common. If rip; is unduly large for any equation i,
it could well be that a net reduction in C will occur
by using i to compute a residual rather than using it
in a one-variable problem, even if this increases t.
Nevertheless, the basic assumption does not seem too
unreasonable if there are no very large values of r1 or pi.
Accepting the strategy of choosing the minimum
tear set, we can again examine the desirability of
partitioning into two subproblems. Recalling the
properties of minimum tear sets given at the end of
Section 1.1, and using the above assumed property of
N, we have
m = ml + m2, t < ti + t2,
t t2, (1.8)
N N 1, N N2.
We shall also assume that the p1 are constants.
Let us first consider the case where all one-variable
problems are of approximately the same difficulty, and
assume
pi = p, ict T; r1 = r, all i, (1.9)
where T denotes the appropriate minimum tear set. Of
course we have Nu = 1 and hence pi = 1 for i e T.
From (1.7) and (1.9) we have
C = N(at2 + rp(m — t) + rt), (1.10)
and hence, using (1.8):
C — (C, + C2) = N{at2 + rpm — rt(p — 1)}
—N,{ati + rpm, — rti(p — 1))
— N2{ati + rpm2 — rt2(p — 1)}
Na(t2 — t?— ti)
(1.11)
+ Nr(p — 1)(t 1 + t2 — t).
It follows from (1.8) that the second term here is non-
negative, but unfortunately we can draw no conclu-
sions about the sign of the first term. However, it is
usually the case that t = t + t2, and then (1.11)
confirms that C > C1 + C2 and partitioning to ir-
reducible subsets is advantageous.
The only failing case is illustrated in Fig. 2; it
requires in general that the two blocks are disjoint
except for the torn variables in block one, and some of
these must occur in block 2 in lower-triangular
pattern. Even when this occurs we shall usually have t
close to (t1 + t2), so that t2 > ti + ti and the conclu-
sion still follows.
Normally we have T = T, v T2, and even in the
above failing case we can choose the minimum tear sets
so that T c T, u T2. It turns out that this condition,
together with the condition t2 > t? -1- ti suffices to
prove that partitioning is advantageous without the
special assumptions of (1.9), for we have from (1.8):
If i e : Pi =1
If ie T2 : Pi (P1)2 = 1 (1.12)
Ifi T, u T2: Pi = (Pal = (P1)2 Z 1.
367
Then from (1.7) and (1.12), with appropriate ordering
of the equations :
C — (C 1 + C2) = Na(t2 — ti —
E rAP. (Pi)i) + N E
+N ri(Pi (P1)2)> 0,
i----- 1 1=m1+1
and the result follows.
Finally there is the question of whether tearing is
preferable to the simultaneous solution of the irreduc-
ible subsets, which involves comparing Eqs. (1.3) and
(1.7). First, if we consider pivot selection procedures of
the type used by Lin & Mah [3] it is easy to conclude
that e > 12. In the general case we are then left, as in the
choice of the tear set, with the balance between the
increased work of iteration on the one-variable prob-
lems and the resulting decrease in the number of outer
iterations. However, in the special case where most of
the one-variable equations are explicit in their output
variables (i.e. p, = 1), it is clear that we shall gain
advantage from tearing.
This reasoning would seem to indicate that if we can
reduce the number of torn variables by isolating and
solving subsets of linear variables, rather than de-
composing these to one-variable problems, we shall
also gain in computing costs.
However the considerations are different for a
completely linear system. Here pi = 1 for all i, and with
e > t2 tearing gives somewhat less work per iteration
than simultaneous solution. However, simultaneous
solution is a direct method, and if the initial matrix is
the correct Jacobian matrix the solution will be
obtained in one 'iteration'. On the other hand, if
Broyden's method [5] is used with an arbitrary initial
matrix the convergence is only superlinear. Solution
by tearing is in any case an iterative method, and it is
well known that such methods are less efficient than
direct methods when the correct Jacobian is available ;
when it is not, it is impossible to draw general
conclusions about the relative efficiency of the two
methods.
2. THE ALGORITHM
From the discussion in the last section it would seem
desirable to develop an algorithm which will partition
an arbitrary rectangular system of equations into a
sequence of irreducible subproblems, and then identify
a minimum tear set for each of these subproblems to
reduce them to a sequence of either one-variable
problems or linear subsets. We also need to in-
corporate the treatment of procedures in this
algorithm.
2.1 Minimum tear sets
We start by considering the problem of finding a
minimum tear set to reduce any system of equations to
a sequence of one-variable problems. First we note
that any permutation of the equations represents a
computable sequence. For each equation in the
sequence we simply guess all except one of the new
variables occurring in it and solve for the remaining
variable. If we encounter an equation which introduces
no new variables (henceforth called a 'covered' equa-
tion), its residual can be evaluated and serves to correct
368 R. HERNANDEZ and R. W. H. SARGENT
a previously guessed variable. At the end of the
sequence, the number of residuals computed will be
equal to the number of variables guessed (torn),
provided that the system of equations is consistent.
Of course the number of torn variables can be
counted, and the covered equations identified, simply
from the occurrence matrix, without actually carrying
out the computations. Thus in principle it suffices to
generate all possible permutations, evaluate each of
them, and pick out the one yielding the minimum
number of torn variables. In practice however it is by
no means necessary to carry out such an exhaustive
enumeration.
First we note that the number of torn variables
increases monotonically as we progress along the
sequence. Thus if at any point in the evaluation the
number of torn variables exceeds the total number
found for a previously evaluated complete sequence,
there is no point in continuing, and all sequences
starting with this partial sequence can be rejected.
Secondly, if we encounter a covered equation, or one
that introduces only one new variable, the number of
torn variables is not increased, and one cannot im-
prove on this choice. Thus all completing sequences
with a different equation in this position can be
rejected.
Hence we carry out a 'depth-first' search of all
possible permutations, generating these in lexico-
graphical order and abandoning partial sequences
according to the above two rules. At each stage we
keep a record of the best complete sequence so far
evaluated.
In additibn we also have the following rule for
abandoning partial sequences :
The Tack-track Rule' Suppose at some stage equ-
ation e is added to a sequence of s equations, yielding
t„1 torn variables, and later after back-tracking in the
lexicographical order, e is added after the first r
equations of the same sequence (r < s), yielding
t, ts+ torn variables. Then e is removed,
and all completing sequences with e in this position
are abandoned.
To prove that the rule works we need to consider
four cases :
(a) Suppose that equation e is covered by the first r
equations. In this case the second rule above applies,
and the back-track rule is not applied.
(b) Suppose that in the original partial sequence one
of the extra (s — r) equations contained no new vari-
ables not in e. Then this equation is either covered by
the first r equations —and hence, by the second rule
above, this should be in position (r+ 1) rather than
e —or its output variable is contained in e, in
which case there will be one fewer torn variables if it
precedes e.
(c) Suppose that each of the extra (s — r) equations
contains just one new variable not in e. Then with e in
position (r + 1) these equations should all follow e
immediately, by the second rule above, and of course
the number of torn variables remains at t, 1 . But this is
just a permutation of the original (s + 1) equations
yielding t,,1 1 , so that any completing sequence
based on it cannot improve on the original sequence.
(d) Finally, suppose that one of the extra (s — r)
equations contains more than one new variable not in
e. Then since t„ is ,, at least one of the other extra
equations must contain no new variables not in e, and
again we have case (b) above.
Thus the rule is proved.
The first rule above will be effective in eliminating
sequences if the first sequence in lexicographical order
has a small number of torn variables. A good strategy
is to number the equations by choosing the first to have
the smallest number of variables, and then at each
point to add the equation which introduces fewest new
variables. In fact this often yields immediately the
optimum sequence.
2.2 Partitioning
It is easy to modify this algorithm to partition the
system at the same time. At any point in evaluating a
sequence we normally have more variables than
equations. However if we encounter a covered equa-
tion, this increases the equation count without increas-
ing the variable count, and if at any point the two
counts become equal we have clearly found an in-
dependent subset. At this point the system can be
partitioned, and the two subsystems subsequently
analysed independently.
Such a partition greatly decreases the number (and
length) of permutations to be examined, and it is
therefore worthwhile modifying the algorithm to
search for partitions, rather than wait for them to arise.
This can be done by 'deleting' the variables from all
succeeding equations as they are introduced, and
keeping a count of remaining variables in each of the
remaining equations as this is done. Then any covered
equations found are immediately added to the partial
sequence in preference to the normal lexicographical
rule (abandoning all other completing sequences). If
these covered equations complete a block, then the
system is partitioned as described above. If more
covered equations are found than are required to
complete the block, then the additional covered
equations are either redundant or inconsistent ; the
algorithm treats them as redundant and eliminates
them, giving a warning message since an extra
degree of freedom has been created for each equation
eliminated.
It should be noted that if partitioning is sought, one-
variable equations should not be given any special
preference as suggested in Section 2.1. This is because a
one-variable equation may not be part of the current
incomplete block, but will necessarily be included if
other completing sequences are abandoned. The back-
track rule still applies however, since it is only
operative on permutations within an irreducible
subset.
2.3 Mixed systems
The algorithm is easily extended to deal with a
mixture of procedures and equations. A procedure
computes a given set of output variables from a given
set of input variables. Thus, if it is inserted into a
sequence of equations at any point, any of its input
variables not previously evaluated must be guessed;
on execution the procedure then yields the values of all
the output variables, and thus counts as a block of one-
variable equations equal in number to the output
variables. It may of course happen that any one of the
output variables has been previously evaluated, in
which case the difference between this previous value
and the value given by the procedure provides a
 New algorithm for process flowsheeting
residual, and hence counts as a covered equation
instead. No other changes in the algorithm are
required.
2.4 Linear subsets
Finally we consider the extension necessary to
identify linear subsets of equations. Here we count
separately the linear variables and the equations in the
current linear subset, as well as the total variable and
equation counts as before. Again, equality of the linear
variable and equation counts identifies a linear subset,
while equality of the total counts indicates a partition
of the whole system.
The procedure is illustrated by the example in Fig. 4.
In this figure L denotes a linearly occurring variable, N
a nonlinear variable and X a previously determined
variable.
Variables Total Linear
I 2 3 4 5 6 78 E V E V
I L L N L L I 5 I 4
2 L X L N 2 7 2 5
0 3 L N X 3 7 2 3 and (4) as covered equations. On the other hand,
0 4 L X X L L X 4 8 3 4
cr
w 5 X X X N 5 8 3 3
6 X X X X 6 8 0 0 solve Eq. (1) for variable 6, Eq. (2) for variable 1, and
Fig. 4. Finding linear subsets.
The counts for Eqs. 1 and 2 are self-evident ; the
nonlinear variables 4 and 8 will have to be guessed in
any case, but for the present both equations are
retained as possible members of a linear subset. In Eq.
(3) there is only one linear variable, so this is chosen as
output variable in preference to the new nonlinear
variable 3, which is guessed. Since Eqs. (1) and (2) are
still retained as possible candidates for a linear subset,
this effectively moves Eq. (3) to the head of the
sequence, with variables 2 and 3 known there-
after—hence the linear subset contains two equations
and three variables. Equation (4) adds a new equation
and a new variable to the linear subset. Equation (5)
contains one new nonlinear variable, which therefore
becomes its output variable, and it too is effectively
moved to the top of the list after Eq. (3). Since its
output variable was previously in the linear subset, the
latter's variable count is reduced by one, leaving a
complete linear subset —Eqs. (1), (2) and (4), determin-
ing variables 1, 6 and 7. Finally Eq. (6) is a covered
equation, serving as an equality constraint on the
values of the decision variables 3, 4, 8. If in fact Eq. (5)
had been a procedure to determine variables 3 and 5
given variables 2 and 4, then the only change would
have been that the difference between the guessed
variable 3 (Eq. 3) and its value computed by the
procedure would provide an additional residual and
equality constraint. Of course in general a procedure
must be regarded as nonlinear in its input variables,
and explicit in its output variables.
Note that the linear subset in this example is in fact
irreducible, but in general the linear subsets may be
partitioned into smaller linear subsets, and of course
the basic algorithm may be applied to them to achieve
this.
369
There are several situations when we are left with an
incomplete (rectangular) linear subset, in which case it
is necessary to guess enough variables in it to render it
square. Again application of the algorithm will yield
the appropriate partition, and hence a permissible set
of candidates for guessing, as illustrated in Fig. 3. This
situation can arise on completion of a sequence, on
detecting a partition, or when the next equation or
procedure determines so many variables that fewer
variables than equations are left in the linear subset.
This last situation does not force a return to the
rectangular system, since we could, as above, move up
this last equation, select a square system from the
linear subset (preferably one which gives maximum
partitioning) and leave the others as covered equa-
tions. However, this treatment is never better than
decomposing the rectangular system, leaving the last
equation to follow it.
To illustrate this situation, suppose Eq. (5) also
involved variables 6 and 7 nonlinearly. Then, moving
up Eq. (5), we should guess two of the three nonlinear
variables in it and solve for the remaining one, leaving
Eqs. (1), (2) and (4) involving only variable 1; Eq. (2)
could be solved explicitly for variable 1, leaving Eqs. (1)
leaving Eq. (5) in place, Eqs. (1), (2) and (4) involve
variables 1, 5, 6 and 7. Guessing variable 7, we can
Eq. (4) for variable 5, in each case explicitly, leaving Eq.
(5) as a covered equation. Note that if only variables 5
and 7 had occurred in Eq. (5) the score would have
been even, but no pattern in Eq. (5) can actually reverse
the scores.
It should be noted that the isolation of linear subsets
as above reduces the number of partial sequences to be
examined. In the example of Fig. 4 the same result
would have been obtained with any permutation of
Eqs. (1)–(5) in which Eq. (5) occurs later than Eq. (3).
More generally, in the block of equations from the first
to the last of the linear subset, any permutation which
preserves the order of the non-members of the subset in
the sequence will yield the same result, and hence need
not be examined.
For simplicity of explanation, it was assumed in the
above examples that the variables were already typed
as linear or nonlinear, but in practice such preanalysis
cannot be done. Consider for example the equations :
1. x2x2x3 + x i x2 + x2x3 + x3x4 = 0
2. x2x3 + x3x4 = 0 (2.1)
3. xix3 + X2X4 = 0.
If none of the variables are known and the equations
are processed in this order, the optimum solution is to
guess variables x 1 and x3, since Eqs. 1 and 2 then yield
a linear subset in variables x2 and x4, with Eq. (3)
covered. On the other hand, if the equations are
processed in the order 1, 3, 2, the optimum solution is
to guess variables x2 and x3, yielding a linear subset in
x, and x4 followed by a covered equation. Any other
choice gives more torn variables in each case.
Of course the situation would be essentially un-
changed if x3 were known beforehand. Similarly, if x2
were known and the equations were processed in the
order 1, 2, 3, one would guess x3, rendering Eq. (1)
linear in x, and x4. Then Eq. (2) involves both of these
variables nonlinearly, so one would return to equation
370 R. HERNANDEZ and R. W. H. SARGENT
1, guessing either x, or x4 and solving for the other;
Eqs. (2) and (3) thus become covered equations. With
x4 fixed beforehand, two more variables must be fixed
in Eq. (1) to render it linear, and in fact any pair leaves
the equation linear in the remaining variable, with 2
and 3 as covered equations.
This simple example shows that each sequence must
be analysed independently, and at each stage all
possible sets of torn variables which produce a linear
subset must be retained.
2.5 Initial sequence
When the search for linear subsets is included, the
initial sequence described at the end of Section 2.1 is
not very effective. What is needed is a heuristic method
which produces clusters of equations containing as
many linear variables as possible. It has been found
that the following approach is reasonably successful :
Step 1. For each Eq. (i) determine the minimum
number of variables which must be fixed to render the
equation linear in the remainder. Compute a weight
(w1) as the ratio of the nonlinear (fixed) variables to the
linear variables, classifying the equations as follows :
I 1 5 wi 5 3, II wi > 3, III Iv; < 1.
Step 2. Put the classes in order I—III with the
equations within each class in order of decreasing
weight.
Step 3. If any Class III equation contains a non-
linear variable which is not nonlinear in any other
Class III equation, then move this equation to the end
of the sequence.
Step 4. Treating all variables in the Class I equ-
ations as known, recompute the weights of the Class H
equations.
(a) Reclassify these as necessary, putting the new
Class I equations below the existing ones and the new
Class III equations above the existing ones.
(b) Transfer any equations in Class II containing no
linear variables to the end of the sequence.
Step 5. Repeat from Step 3 if any equations were
reclassified in Step 4.
Since procedures cannot provide equations to com-
plete linear subsets but do provide their output
variables explicitly, it seems reasonable to insert them
in the sequence as soon as all their input variables are
known. This can conveniently be done in Step 4 where
the fixed variables are identified for the purpose of
recomputing weights, and of course the output vari-
ables of the procedure are then assumed known below
its insertion point.
3. IMPLEMENTATION AND EXTENSIONS
The tearing and partitioning algorithms of Sections
2.1-2.3 use only information contained in the occur-
rence matrix of the system, but the isolation of linear
subsets involves analysis of the algebraic structure of
the equations, and hence automatic algebraic manipu-
lation by the computer.
There is now a considerable number of packages
available for this purpose, and useful surveys have
been published by Sammet [6], Engeli [7] &
Moses [8]. The packages serve a wide variety of
purposes, and provide a corresponding variety of
facilities, so that it is necessary to choose a package
which is well adapted to the purpose in hand.
However, most packages are machine dependent to a
greater or lesser degree, and this greatly restricts the
choice. We experimented with SCHOONSCHIP [9]
and SYMBOLANG [10], both implemented on
CDC6000 series machines, but rapidly concluded that
SYMBOLANG was better suited to our purpose. In
contrast to SCHOONSCHIP, which is written in
assembly code, SYMBOLANG is a set of
FORTRAN-callable routines, mostly written in
FORTRAN and based on the SLIP list-processing
package. This is doubly advantageous, since the
resulting code is FORTRAN compatible, and the
SLIP facilities are otherwise useful for dealing with
sparse systems. SYMBOLANG also proved to be
more flexible, and considerably more efficient in both
storage and computing time, for the particular kinds of
analysis involved.
The essential algebraic step in finding linear subsets
is to identify for each equation the tear sets which
render it linear, and the resulting linear variables, given
the current set of previously determined variables. It
would be perfectly feasible to write a subroutine in
SYMBOLANG to carry out this task, and then call it
as each equation is added to a given partial sequence in
the implicit enumeration algorithm. However such a
routine involves substantial algebraic manipulation,
and hence is quite expensive in computing time, so that
its repeated use in this way would be quite prohibitive.
Fortunately much of the analysis of each equation
can be made once and for all, and the results stored as
FORTRAN arrays, so that no SYMBOLANG code
need actually be imbedded in the enumeration routine.
To explain how this is done, it is necessary to give a
brief description of how algebraic expressions are
stored in SYMBOLANG; a complete description of
the language will be found in [10].
An algebraic 'expression' is a sum of 'terms', stored
as a SLIP list. Each term has a signed numerical
coefficient multiplied by a product of 'factors', each
raised to an 'exponent', where a factor is a variable or
function, and an exponent is a signed number or an
'expression'. A function has a list of arguments which
are themselves 'expressions'. It will be seen that the
definitions are recursive, but will be finite for any
practical expression, and the various components are
stored as a tree of sub-lists to the main list.
A variable or a function can be defined to be any
expression, in the latter case the expression being in
terms of dummy arguments of the function. However
undefined functions can also be included.
Subroutines are available for converting a
FORTRAN expression into a SYMBOLANG expres-
sion list and vice versa, and this in itself provides a
significant part of the analysis. From the
SYMBOLANG lists for a given equation it is a
straightforward matter to identify 'simple' terms,
which are a function of only one variable, and to check
whether such terms are linear or nonlinear in the
variable concerned. For the remaining 'complex' terms
it is also easy to check whether they are linear or
nonlinear in each of the variables involved, and if the
term contains a function its input (nonlinear) variables
and output (linear) variables can be identified. The
variables, classified into these categories, are stored on
SLIP lists during the analysis, but once this is complete
the number of elements in each list is known and the
data can be re-packed into FORTRAN arrays.
Further savings are achieved by numbering the variab-
 New algorithm for process flow sheeting
les as they are read, thus providing integer identifiers
for the variables and avoiding reference to them by
name in the above analysis.
The final FORTRAN arrays are thus integer arrays,
and the repetitive analysis of each equation in the
enumeration algorithm when it is added to different
partial sequences can be carried out by simple
FORTRAN instructions.
This is sufficient to execute the algorithm as de-
scribed in Section 3, but with SYMBOLANG facilities
available a number of other useful operations can be
carried out, which further exploit the algebraic
structure.
Probably the most powerful of these is the simplifi-
cation of the system of equations by substituting a
simple variable for any repeated expressions ; a new
equation is then created, equating the expression to
this new variable. Not only does this ensure that such
repeated expressions are evaluated only once, which is
a direct saving of computation, but the total number of
variables in the equations concerned is reduced, and
the number of linearly occurring variables increased,
so that the decomposition is more effective. A similar
effect is obtained by treating each function as a simple
variable, with its definition treated as an additional
equation; it is important to note that the function is a
different variable, with a corresponding distinct defin-
ing equation, for each distinct set of actual arguments
which occur in the equations.
Obviously such simplifications are carried out be-
fore decomposition, but having obtained the optimal
computational sequence it is clearly advantageous
to convert as many as possible of the one-variable
subproblems to a formula which explicitly evaluates
the output variable. If the equation is linear in its
output variable the operation is trivial, but often more
complex expressions can be reduced by the use of
inverse functions, as illustrated by the following
example:
x1F(x2) - x2 exp (xixi + x2) = 0. (3.1)
If x3 is the output variable, this is clearly a nonlinear
equation, but straightforward manipulation yields the
explicit FORTRAN expression :
x3 = SQRT((ALOG(xi F(xs)/x2**2) — x2)/xi). (3.2)
The general principle for explicit solutign is that at
each level of expression the output variable occurs in a
single term of the argument of an invertible function,
and a single term of the equation itself.
Finally, SYMBOLANG provides routines for the
symbolic differentiation of expressions, so that explicit
formulae for partial derivatives, gradients and
Jacobian matrices can be generated from the equ-
ations. When tearing is used, expressions for the
Jacobian of the residual equations with respect to the
torn variables can then be generated by the chain rule.
This Jacobian is then available for solution of the
outer-loop iterations by Newton's method, or if these
residual equations are treated as constraints in a
371
mathematical programming problem it provides the
constraint gradients, as required by efficient mathema-
tical programming algorithms.
At the level of the nonlinear one-variable problems,
the derivatives permit the use of cubic interpolation for
the solution. At the pre-processing stage they could
also be evaluated using the initial estimates of the
variables, and put in order of decreasing magnitude for
each equation to provide a priority list for the choice of
output variable based on numerical conditioning.
The automatic provision of consistent derivative
formulae is a great boon, not only because of the direct
saving of coding time, but because it is easy to make
mistakes in the algebra and the coding, and incon-
sistency of the derivative values is the commonest
cause of failure of numerical routines which require
them.
Nevertheless it has to be said that automatic
algebraic manipulation is at present very expensive in
computing time, especially using standard packages
which provide a wide range of facilities. The operations
described above use only a fraction of the
SYMBOLANG facilities, and it is certain that con-
siderable savings could be made by writing code
specifically for these operations. This is in itself a large
task, and we need to have a clearer idea of the benefits
of this approach before undertaking it. At present we
have very little numerical experience, and are still very
much at the exploratory stage.
REFERENCES
1. R. W. H. Sargent, The decomposition of procedures and
algebraic equations. (Ed.) G. A Watson Numerical
Analysis—Proc., Biennial Conf., Dundee 1977, Lecture
Notes in Mathematics 630, 158-178, Springer-Verlag,
Berlin (1978).
2. I. S. Duff, A survey of sparse matrix research. AERE
Harwell Rep. CSS28 (1976).
3. T. D. Lin & R. S. H. Mah, Hierarchical partition—a new
optimal pivoting algorithm. Math. Programming 12(2),
260 (1977).
4. T. D. Lin & R. S. H. Mah, A sparse computation system
for process design and simulation. Part I AIChE J. 24(5),
830 (1978); Part II AIChE J. 24(5), 839 (1978).
5. C. G. Broyden, A class of methods for solving nonlinear
simultaneous equations. Math. Comp. 19, 577 (1965).
6. J. E. Sammet, Survey of formula manipulation.
Communications of the Association of Computing
Machinery 9(8), 555 (1966).
7. M. E. Engeli, Achievements and problems in formula
manipulation. Proc. IF IP Congress 79, North Holland
(1968).
8. J. Moses, The evolution of algebraic manipulation algor-
ithms. Information Processing 74,483 (1974).
9. H. Strubbe, Manual for Schoonschip a CDC6000/7000
Program for Symbolic evaluation of algebraic expres-
sions. Computer Physics Communications 8, 1 (1974).
10. H. J. Bernstein, The algebraic manipulation package
SYMBOLANG, in N. V. Findler, J. L. Pfaltz and H. J.
Bernstein. Four High-Level Extensions of FORTRAN IV :
SHP, AM PPL-II, TREETRAN, SYMBOIANG.
Spartan Books New York (1972).