Linear Programming with Two Variables per Inequality in

Poly-Log Time
George S. Luekery Nimrod Megiddoz Vijaya Ramachandranx

Abstract. The parallel time complexity of the linear programming prob-

lem with at most two variables per inequality is discussed. Let n and m de-
note the number of variables and the number of inequalities, respectively, in a
linear programming problem. We assume all inequalities are weak. We describe
an O((log m + log2 n) log2 n)-time parallel algorithm for deciding feasibility, under
the concurrent-read-exclusive-write PRAM model. It requires mnO(log n) proces-
sors in the worst case, though we do not know whether this bound is tight. When
the problem is feasible a solution can be computed within the same complexity.
Moreover, linear programming problems with at most two nonzero coecients in
the objective function can be solved in poly-log time on a similar number of pro-
cessors. Consequently, all these problems can be solved sequentially with only
O((log m + log2 n)2 log2 n) space. (These bounds assume that numbers take O(1)
space, and arithmetic on them takes O(1) time the problem can still be solved
in poly-log space as a function of the input size even if we instead use a Turing
machine model with rational input.) It is also shown that if the underlying graph
has bounded tree-width and an underlying tree is given then the feasibility problem
is in the class NC.

1. Introduction
Dobkin, Lipton and Reiss 7] rst showed that the general linear programming problem
was (log-space) hard for P. Combined with Khachiyan's deep result 14] that the problem
is in P, this establishes that the problem is P-complete (that is, log-space complete for
An earlier version of this paper appeared in the Proceedings of the 18th Annual Symposium on
Theory of Computing, May 1986, pp. 196{205.
y Department of Information and Computer Science, University of California at Irvine, Irvine, CA
92717. Supported by National Science Foundation Grant DCR-8509667.
z IBM Research, Almaden Research Center, 650 Harry Road, San Jose, CA 95120 and School of
Mathematical Sciences, Tel Aviv University, Tel Aviv, Israel
x Department of Computer Science, University of Texas at Austin, Austin, TX 78712. Supported by
NSF under Grant ECS-8404866, by Joint Services Electronics Program under Grant N00014-84-CO149
and by an IBM Faculty Development award.

1
P). A popular specialization of the general linear programming problem is the problem
of solving linear inequalities with at most two variables per inequality (see 15] and the
references thereof). It is shown in 15] that a system of m linear inequalities in n variables
(but at most two nonzero coe cients per inequality) can be solved in O(mn3 log m)
arithmetic operations and comparisons over any ordered eld. It is not known whether
the general problem (even only over the rationals) can be solved in less than p(m n)
operations, for any polynomial p.
Throughout the paper we assume that the space to store numbers and the time for
arithmetic operations is O(1). Since each expression we compute can be written as an
expression tree of height O(log n) in the input values, the length of numbers only increases
by a polynomial factor during the execution of the algorithm, so this assumption does
not alter the statements of our results by more than a polynomial factor for the number
of processors, or more than a poly-log factor for the time.
In this paper we are interested in the parallel computational complexity of the two
variables per inequality problem. We rst mention some related results which, we hope,
shed some light on the parallel complexity of the problem.
Proposition 1.1. The problem of nding the minimum value of a general linear function
subject to linear inequalities with at most two variables per inequality is P-complete.
Proof: The proof follows from the result that the problem of nding the value of the
maximum ow through a capacitated network is P-complete 11]. More specically,
every maximum ow problem can be reduced 8] to a transportation problem, that is,
a problem of the form X
Minimize cij xij
ij
X
subject to xij ai
j
X
xij
bj
i
xij
0:
The dual of the latter has only two variables per inequality.
In fact, there exist much simpler but yet P-complete linear programming problems
with a general objective function and only two variables per inequality. For example,
consider the following recursive formula
xk+1 = max(k xk + k k xk + k)
where k , k, k and k (k = 1 . . . n) are given numbers. Given any value of x1, we want
to determine the resulting value of xn . Let us call this the PROPAGATION problem.
2
The propagation problem can be solved as the following linear programming problem:
X
Minimize M i xi
i
subject to xk+1
k xk + k
xk+1
k xk + k :
where M is su ciently large.
Proposition 1.2. PROPAGATION is P-complete.
Proof: The proposition follows from the result by Helmbold and Mayr 12] that the
2-processor list scheduling problem is P-complete. The latter amounts to a special case
of PROPAGATION: xk = jxk;1 ; Tk j = maxfxk;1 ; Tk ;xk;1 + Tk g, (k = 1 . . . n),
where T1 . . . Tn are given integers and x0 = 0.
Interestingly, the subproblem of PROPAGATION where all the k 's and k 's are
nonnegative is in NC this follows immediately from the parallel composition of monotonic
piecewise linear functions to be discussed in Section 3.
We discuss three dierent problems:
(i) Deciding feasibility. Here we only need to determine whether there exists a
solution to a given set of linear inequalities with at most two variables per inequality.
(ii) Solving inequalities. Here we require that if the system is feasible then some
point in the feasible space be determined.
(iii) Optimization. Here we seek to nd a point in the feasible space which maximizes
a given linear combination of two of the variables. As in the previous case, one has
to distinguish here between the problem of computing the optimum value of the
function and the problem of computing optimum values of the variables.
Deciding feasibility is the core of our algorithm. This is accomplished by computing
the projections of the set of feasible solutions onto the individual coordinate axes. Using
a parallelization of the sequential algorithm of 17], we will compute for each variable
x an interval xlow xhigh], ;1 xlow xhigh 1, (possibly empty) so that for every
x0 2 xlow xhigh] there is a solution to the system of inequalities with x = x0. This
part of the algorithm su ces of course for determining whether a given system of linear
inequalities (with at most two variables per inequality) has a solution. We shall later
discuss the problem of nding a feasible solution given the (nonempty) projections onto
the axes. Finally, we show how to optimize a linear function with at most two nonzero
coe cients subject to such systems of inequalities.

3
2. Preliminaries
Two characterizations of feasibility of linear inequalities with at most two variables per
inequality were given by Nelson 17] and Shostak 19]. Our algorithm is a parallelization of
the algorithm in Nelson 17], but our exposition will also make use of the characterization
of Shostak 19] and further results by Aspvall and Shiloach 2] which we now describe.1
A key idea in these papers is the observation that one can combine inequalities to deduce
new inequalities. For example, suppose we are given x + 2y 3 and ;y + 3z 4.
Eliminating y between these two inequalities, we obtain x + 6z 11.
It is convenient to discuss the problem using graph-theoretic terminology. We form
what is called the constraints graph, denoted G, by creating a vertex for each variable,
and an edge for each inequality whose endpoints are the two variables appearing in
the inequality. (Note that this is actually a multigraph, since a pair of variables can
be involved in many dierent inequalities.) We henceforth identify variables with the
corresponding vertices. To take care of inequalities involving only a single variable, such
as x 4, 19] also added a dummy vertex v0 corresponding to a new variable which
can only occur with coe cient 0 an edge representing an inequality involving only one
variable, say x, runs between x and v0. Now let L denote a path in G from x to y, that is,
a set of inequalities ixi + i+1xi+1 i , (i = 0 1 . . . k ; 1), where x = x0 and y = xk .
(Note that since G is a multigraph, a path should be thought of as a sequence of edges
rather than as a sequence of vertices, to avoid ambiguity.) If ii < 0 for i = 1 . . . k ; 1,
we say P is admissible, and then by successive elimination of x1 x2 . . . xk;1 one can
deduce a new inequality x + y  that is implied by this path. We will call this the
resultant of the path. If on the other hand there exists an i (1 i k ; 1) such that
ii > 0, we say the path is inadmissible, and then one cannot deduce a resultant.
The case in which the endpoints of the path are the same variable deserves special
attention in this case we call the path a loop. Then the resultant involves only a single
variable, that is, it is a bound of the form x  . It is possible that the resultant
could be an inherent contradiction|this occurs if  = 0 and  < 0. For instance, the
path ;x + 2y ;7 and ;y + x=2 2 has the resultant 0x ;3, which is clearly a
contradiction. In this case we can deduce that there is no feasible solution. Unfortunately
the converse is not true it is possible to produce an example of an infeasible set of
inequalities for which no loop yields a contradiction. One further idea is needed to
produce a characterization.
The closure G0 of G is the multigraph we obtain by adding to G all of the bounds
which are resultants of simple cycles.
1The correctness of our feasibility test follows directly from the theorems of 17], but the presentation
we have chosen enables us to depend only on results appearing in journals.

4
Theorem 2.1 (Shostak 19]) : The original system G is infeasible if and only if some
simple loop in the closure G0 has a resultant which is a contradiction.

3. Operations on polygons
For parallel computation we will want to be able to manipulate many bounds simul-
taneously. To discuss this approach it is convenient to represent a set of inequalities
involving x and y by a polygon Pxy consisting of all points in the plane which satisfy all
of the inequalities. (We call these objects polygons even though they may sometimes be
unbounded.) It is useful to have a term to indicate that membership in a polygon implies
some inequality thus we will say that a polygon P incorporates an inequality if all points
in the polygon satisfy the inequality. The algorithm of Nelson 17] made use of two oper-
ations on polygons, namely intersection and composition. In this section we dene these
polygons and operations, and indicate how we do them e ciently in parallel. (We have
not carefully optimized these algorithms since this would not signicantly improve the
statement of the overall complexity of our feasibility testing algorithm.) Let R denote
the set of reals, and let Rxy , for any two variables x and y, denote the two-dimensional
space R  R given by the cross product of the x and y axes.
Suppose S consists of m inequalities in n variables. For 1 k n, let Qkxy denote
the polygon corresponding to the set of all inequalities which involve no variables other
than x and y, and which are resultants of paths (not necessarily simple) of length at most
k. Note that Q1xy is the polygon determined by the original inequalities involving only x
and/or y. In particular, the polygon Q1xy incorporates all of the inequalities corresponding
to edges among v0, x, and y thus we do not need the vertex v0 in our graphs. Clearly the
polygon Qkxx incorporates the resultants of all cycles of length at most k which involve
x.
The algorithm uses two basic operations on convex polygons, namely, intersection and
functional composition. The intersection of two polygons is the ordinary set intersection
of their point sets, i.e.,
Pxy \ Pxy0 = f(x y) j (x y) 2 Pxy and (x y) 2 Pxy0 g:
The composition Pzx of two polygons Pzy and Pyx is
Pzx = Pzy  Pyx = f(z x) j 9y 2 R such that (z y) 2 Pzy and (y x) 2 Pyx g:
In other words, as noted in 17], Pzy  Pyx is the projection onto Rzx of the intersection
of the cylinders with bases Pzy and Pyx .
We now describe the implementation of these two operations. We represent convex
polygons by a domain D and two bounds L and H  D is a (possibly innite) interval,
5
and L(x) (respectively H (x)) is a convex (respectively concave) piecewise linear function.
The set of points in the represented polygon Pyx is
Pyx = f(y x) j x 2 D and L(x) y H (x)g
for the representation to be considered valid we require that
x 2 D =) L(x) H (x):
For simplicity we rst discuss the basic operations as applied to piecewise linear
convex functions rather than polygons. Thus, we rst consider functions of the form
y = f (x) = max1iN fix + ig, which we represent by a list of pairs (i i) ordered
such that i < j for i < j  we will require that there be no extraneous pairs, i.e., that
no pair of values (  ) appears more than once in the list, and that f coincides with
each linear function y = i x + i over some interval of positive length.
Consider rst the intersection problem. Given two functions y = f1(x) and y = f2(x)
in the form described above, with N1 and N2 linear pieces, respectively, we have to
compute the representation of y = g(x) = maxff1(x) f2(x)g. This problem can be
solved in O(log N ) time with O(N ) processors, where N = N1 + N2. Here we briey
sketch the method. First note that we can convert between the representation discussed
above and a list of the breakpoints (i.e., coordinates of points of discontinuity in the
slope) of each function in constant time. Next, we merge the sets of breakpoints for f1
and f2 according to their x-coordinate, but keep track of whether each came from f1
or f2 call these respectively type 1 and type 2 breakpoints. The merging can be done
e ciently by the algorithm of 4]. Next, using standard pointer doubling techniques,
each type 1 (resp. type 2) point can determine the previous and following type 2 (resp.
type 1) point. Once this information is available, each point can determine in O(1) time
whether it lies below or on g(x). Finally, knowing the type of its neighbors, and whether
they lie below or lie on g(x), each point can determine in O(1) time whether f1 and f2
intersect between it and its neighbor. Thus we can generate a list of all breakpoints of
g(x). This can then be converted back to the representation, as a list of linear functions,
described above.
The second operation we need for our algorithm is functional composition. We rst
demonstrate this operation in a special case. Suppose y = f (x) and z = g(y) are strictly
monotone piecewise linear functions, each represented as described above. We would like
to compute the representation of the composition z = h(x) = g(f (x)). Suppose f and
g consist of k and l linear pieces, respectively, and let N = k + l. The problem can
be solved by O(N ) processors in O(log N ) time as follows. Let y1 . . . yl;1 denote the
breakpoints of g. These can be found in constant time from the representation of g. Let
ti = f ;1 (yi), i = 1 . . . l ; 1. The ti's can be computed in parallel in O(log k) time by a
binary search. Let x1 . . . xk;1 denote the breakpoints of f . Now, the xi's and ti's can
6
be merged and then the linear pieces of h can be constructed as compositions of linear
functions.
Obviously, if both f and g are increasing, or if both are decreasing, then h is increasing
otherwise, h is decreasing. As for convexity or concavity properties, it is easy to verify
the following:
(i) If g is monotone increasing then h is convex if both f and g are convex, and h is
concave if both f and g are concave.
(ii) If g is monotone decreasing then h is convex if f is concave and g is convex, and h
is concave if f is convex and g is concave.
We now sketch the construction of Pzx with linearly many processors in the total
number of edges in Pyx and Pzy . Let yh denote the smallest value of y (with y 2 Dzy ) at
which Hzy (y) attains a maximum. Note that Hzy (y) is increasing for y yh (for y 2 Dzy )
and nonincreasing for y
yh (again, for y 2 Dzy ). The function Hzx (x) maps x to the
largest value of z such that there is y in Lyx(x) Hyx (x)] for which y 2 Dzy and Lzy (y)
z Hzy (y). Thus, if x 2 Dyx is such that Hyx (x) yh (and Hyx (x) 2 Dzy ) then a least
upper bound on z is obtained by setting y to Hyx (x), that is, Hzx (x) = Hzy (Hyx (x)). On
the other hand, if x is such that Lyx (x)
yh, then a least upper bound on z is obtained
by setting y to Lyx(x). Finally, if x is such that Lyx(x) yh Hyx (x), then the least
upper bound on z is found by setting y to yh. Summarizing, we have
8 H (L (x)) if y L (x)
>< zy yx h yx
Hzx (x) = > Hzy (yh) if Lyx (x) yh Hyx (x)
: Hzy (Hyx (x)) if Hyx (x) yh.
Similarly, let yl denote the smallest value of y at which Lzy (y) attains a minimum. Then
Lzy (y) is decreasing for y yl (with y 2 Dzy ) and nondecreasing for y
yl (with
y 2 Dzy ). This implies that if x 2 Dyx is such that Hyx (x) yl, then a largest lower
bound on z is obtained by picking y to be Hyx (x), and if x is such that Lyx (x)
yl,
then a largest lower bound on z is obtained by picking y to be Lyx (x). Finally, if
Lyx (x) yl Hyx (x), then we pick y = yl. Thus
8> L (L (x)) if y L (x)
< zy yx l yx
Lzx (x) = > Lzy (yl) if Lyx(x) yl Hyx (x)
: Lzy (Hyx (x)) if Hyx (x) yl.

Obviously, there exist xhl and xhh such that Hyx (x)
yh i x 2 xhl xhh ]. Anal-
ogously, there exist xll and xlh such that Lyx (x) yl i x 2 xll xlh]. Note that the
values of yl, yh , xhl, xhh , xll and xlh can be found in O(log N ) time. It follows that the
representations of the functions Hzx (x) and Lzx (x) can be computed, each over at most
three disjoint intervals of x, as compositions of monotone functions. Let us consider the
7
 procedure UpdatePaths(Q)
comment Q is an array of polygons indexed by x and y
begin
for i
1 to dlg ne do
for all variablesz\and x pardo

Qzx
Qzx \ Qzy  Qyx 
y
POINTA: comment at this point the resultants of all paths
are incorporated into the polygons
for all variables x pardo
Qxx
Qxx \ Ixx
end

various types of breakpoints of the functions Hzx (x) and Lzx (x). Obviously, any such
breakpoint is of one of the following types: (i) a breakpoint of one of the functions Hyx (x)
and Lyx (x), (ii) an inverse image under one of these functions of a breakpoint of one of
the functions Hzy (y) and Lzy (y), (iii) one of the points xhl, xhh , xll and xlh. Each of the
breakpoints of the functions Hzy (respectively Lzy ) contributes at most two breakpoints
to Hzx (respectively Lzx ). Also, each of the breakpoints of the functions Hyx and Lyx
contributes at most one breakpoint to each of the functions Hzx and Lzx . Thus, the total
number of breakpoints of Hzx and Lzx is at most 2N + 4, where N is the total number
of breakpoints of Hyx , Lyx , Hzy and Lzy .
The new domain is given by
Dzx = fx j x 2 Dyx and Lyx (x) Hyx(x)] \ Dzy 6= g
We omit the details showing how this can be computed within the stated resource bounds.

4. Deciding feasibility
Using the basic operations of intersection and decomposition, we can now sketch the
algorithm for deciding feasibility of a given system of linear inequalities with at most
two variables per inequality. The algorithm consists of two iterations of the procedure
UpdatePaths, shown here. We dene Ixx to be the identity polygon, i.e., I = f(x x) j
x 2 Rg. This algorithm for deciding feasibility begins by using an algorithm analogous
to the standard parallel transitive closure or shortest path algorithms (see 13] for more
information about such algorithms). It is interesting to note that the two operations
\ and  do not form a closed semiring in the sense dened in 1]. In particular, the
distributivity condition Pzy  (Pyx \ Pyx0 ) = (Pzy  Pyx ) \ (Pzy  Pyx0 ) fails to hold in
8
 procedure CheckFeasibility(S ,V )
comment S is the set of inequalities, and V is the set of variables
begin
for all variables x and y pardo
Qxy
the polygon determined by all inequalities
involving no variables outside fx yg
for all variables x pardo
Qxx
Qxx \ Ixx
for i
1 to 2dlg ne do
for all variablesx\and z pardo

Qzx
Qzx \ Qzy  Qyx 
y
end

general. (As an example, let Pzy be the entire zy plane, let Pyx be determined by the
one inequality y ;1, and let Pyx0 be determined by the one inequality y
1. Then the
left side is the empty set and the right side is the entire zx plane.) It is not hard to see
though that we do have
Pzy  (Pyx \ Pyx0 ) (Pzy  Pyx ) \ (Pzy  Pyx0 ):
From this one can easily show that, if for each x and y we initialize Qxy to be the
set of all inequalities involving x and y, then at POINTA we will have Qxy Qnxy ,
where Qnxy is dened as in Section 3. (Note that while we do not claim equality, the
Qxy do contain the projection of the feasible space onto Rxy since each composition and
intersection corresponds to valid deductions that can be made about the feasible space.)
In particular, at the end of UpdatePaths each Qxx will be a set of pairs (x x) where
each x obeys the constraints added to G in Section 2 to form the closure G0. Thus by
Theorem 2.1, a second application of UpdatePaths will cause at least one of the Qxy to
become empty if the original set of inequalities had no feasible solution. Further, if the
feasible space is nonempty, it follows from 2, Lemma 9] that after this second application
of the procedure the projection of the feasible set onto any axis Rx is the same as the
projection of Qxx onto Rx.
A simplication of this description is possible: by initially restricting each Qxx to be
contained within Ixx, we eliminate the need for the last loop in UpdatePaths. In fact, then
the entire feasibility checking procedure becomes the CheckFeasibility procedure shown
here. This is nearly the same as the algorithm of 17], and another proof of correctness
can be found there.
Let the total number of edges in all polygons constructed during the algorithm be E .
As in the sequential algorithm of 17], the polygons Qxy are computed in O(log n) stages,
9
and we have E = mnO(log n). Intersection of n polygons can be computed by n parallel
teams of processors in O(log n) phases, where in each phase each team is computing the
intersection of two polygons. It is convenient to think here of a model of computation
where the machine does not have to allocate all the processors in advance it rather
invokes processors as they are needed, just like a Turing machine using unlimited tape
space. This allows us to talk about the \worst-case processor complexity." Assuming we
have O(E ) processors, all pairwise intersections and compositions take O(log E ) time.
It follows that the entire procedure takes O(log E log2 n) time. Thus, the worst-case
running time is O((log m + log2 n) log2 n).
It is interesting to consider the space complexity implied by our result. We have just
established that we can determine feasibility in T = O((log m+log2 n) log2 n) parallel time
using P = mnO(log n) write parallel RAM. Using standard simulation relations between
parallel models of computation and between parallel time and sequential space 3, 9,
13, 20], this implies that feasibility can be determined by a poly-log space-bounded
deterministic Turing machine. This suggests that the problem might not be P-complete.

5. Computing a feasible solution

We now consider the problem of computing a feasible solution, given the projections
of the (nonempty) feasible domain P onto the individual axes. Thus, let xlow xhigh]
(;1 xlow xhigh 1) denote the set of values of variable x that can be completed
into a solution of the entire system S . If all the projections are nite intervals then a
feasible solution is readily available:
Proposition 5.1. If for every x both xlow and xhigh are nite, then a feasible solution is
obtained by setting each variable x to the arithmetic mean 12 (xlow + xhigh).
Proof: Suppose, to the contrary, that the vector of the arithmetic means 12 (xlow + xhigh)
is not feasible. Then there is an inequality x + y  which is violated. In other
words,
2 (xlow + xhigh) + 2  (ylow + yhigh) >  :
1 1

Consider the rectangle xlow xhigh]  ylow yhigh]. By denition, each edge of this rect-
angle contains at least one point of the projection Pxy . However, we claim that this
contradicts the inequality
1
2
(xlow + xhigh) + 12  (ylow + yhigh) > 
since the center of the rectangle is in the convex hull of any set that intersects all four
edges of the rectangle. The proof of this claim is easy. Let L, R, T and B denote
points (not necessarily distinct) that lie on the left, right, top and bottom edges of the
10
 rectangle, respectively. Consider the straight line determined by the points L and R.
If the center lies on this line then we are done. Otherwise, if the center lies above the
line then it is in the triangle determined by T together with L with R, and if it lies
below this line then it is in the triangle determined by B together with L and R.
Interestingly, Proposition 5.1 does not hold if there are more than two variables per
inequality. To see this, consider the system x
0, y
0, z
0, and x + y + z 1.
The projection of the feasible space onto the x-, y-, or z-axis is just 0 1], but the point
(1=2 1=2 1=2) is not feasible.
The unbounded case is handled as follows. We introduce to the system an additional
variable and the 2n inequalities xj , xj
; (j = 1 . . . n). We nd the projection
of the augmented problem onto the -axis. In other words, we compute an interval
I =  low high] (0 low high = 1), such that for every 2 I there exist values for
x1 . . . xn which solve the augmented problem. By setting to any nite number in I we
obtain a feasible system of linear inequalities (with at most two variables per inequality)
whose set of solutions is bounded. Any solution of the latter yields a solution to the
original problem simply by dropping . Thus we have the following:
Proposition 5.2. If a system of linear inequalities has a nonempty set of solutions, then
a solution can be found in poly-log time with mnO(log n) processors in the worst case.

6. Optimization problems
We have already shown that, with a general objective function, the optimization problem
with at most two variables per inequality is P-complete. In this section we discuss the
case where the objective function also has at most two variables with nonzero coe cients.
Intuitively, the optimization problem can be solved by searching for the optimum
value, using the feasibility checking algorithm as an \oracle". In the context of se-
quential computation this yields a polynomial-time (but not strongly polynomial-time)
algorithm. In the context of parallel computation this approach does not provide a poly-
log algorithm since the number of queries during the search is linear in the length of the
binary representation of the input.
We can use here a technique presented in 16] to obtain a poly-log algorithm for
nding optimum solutions over any ordered eld. Here is a sketch of the method see
16] for more detail. Suppose the problem is to minimize the function
f (x1 . . . xn) = c1x1 + c2x2
subject to a system S of linear inequalities in x1 . . . xn with at most two variables per
inequality. Consider the system S 0 of inequalities, which is obtained by adding to S
11
an inequality c1x1 + c2x2
, where
is a parameter. We need to nd the smallest
value of
for which S 0 is feasible. Denote this optimum value by
. We can run our
parallel algorithm for deciding feasibility on S 0, handling
as an indeterminate. Thus the
\program variables" will be functions of
rather than eld elements. Throughout the
execution of the algorithm we maintain an interval of values of
, guaranteed to contain

, over which the current program variables are all linear functions of
. Comparisons
between two functions of
have to be resolved according to the function values at
,
which is itself not known. However, during each step of the algorithm, each processor
that is unable to perform a comparison for which it is responsible simply reports the value
of
which is critical for that comparison, that is, a value
0 such that the comparison
between the two functions can be resolved by comparing
0 and
. The comparison
between
0 and
 can be carried out by setting
to
0 and checking feasibility of the
system. Let p denote a bound on the number of processors required to check feasibility.
For the parametric algorithm we can either use p2 processors, in which case all the critical
values of
can be tested in parallel, or only p processors and run a binary search over
the set of critical values. In the latter case we obtain a poly-log algorithm with mnO(log n)
processors for computing
 over any ordered eld.
Once
 is known, we can solve the system S 0 with
=
.

7. Bounded tree-width
Robertson and Seymour 18] introduced the notion of the tree-width of a graph. This
notion lends itself via the constraints graph to systems of linear inequalities with at most
two variables per inequality.
Denition 7.1. A connected graph G is said to have tree-width less than or equal to k if
there is a family V = fV1 . . . Vtg of sets Vi of vertices of G with the following properties:
(i) Each Vi contains at most k + 1 vertices of G.
(ii) For every edge e of G, there exists an i such that e has both its endpoints lying in
Vi.
(iii) The intersection graph T = (V E), where (Vi Vj ) 2 E if and only if Vi \ Vj 6= , is
a tree.
We assume the graph is given together with such a tree and develop an algorithm
that relies on the tree. Note that a tree with at most n nodes su ces. It will follow that
if the tree-width is bounded then the number of edges remains polynomial in m and n
during the execution of the special algorithm.
For our purpose here we may assume, without loss of generality, that our graphs are
connected. Also, for simplicity of presentation, assume all the sets Vi are (k + 1)-cliques
12
in G this assumption is also made without loss of generality since redundant inequalities
can always be added to the system.

Proposition 7.2. Suppose U , V , and W are nodes of T such that V lies on the path
connecting U and W . Let u 2 U and w 2 W be vertices of G. Then on any path in G
connecting u and w there is at least one vertex v 2 V .

Proof: Consider any such path u = v1 . . . vr = w. Let V0 = U and Vr = W . For

every i, i = 0 . . . r ; 1, there is a set Vi 2 T such that both vi and vi+1 are in Vi. By
denition each (Vi Vi+1) is an arc in T (if Vi 6= Vi+1). Thus, U = V0 V1 . . . Vr;1 Vr =
W yields a path in T. It follows that one of the Vi 's equals V . This implies that one
of the vi's is in V .
Given the underlying tree T, we can decompose the graph G in an e cient way. The
decomposition is based on the centroid which is often useful in the design of parallel
algorithms (as an early reference we might mention 5]). The centroid of a tree T with
N nodes is a node c so that there exist two subtrees T1, T2 rooted at c (and also c
is the only common node), each with no more than 32 N + 1 nodes, whose union is T .
The centroid decomposition of a tree is the iterated partitioning of a tree in this way
into two subtrees rooted at the centroid. This decomposition is obtained in O(log N )
iterations, and moreover, it can be computed in poly-log time with a polynomial number
of processors.
In view of Proposition 7.2 the centroid decomposition of T induces a decomposition
of G as follows. At the rst level of the decomposition we have a set C of k +1 vertices of
G and two induced subgraphs G1, G2, whose vertex sets intersect at C and cover all the
vertices of G. Moreover, every edge of G is contained in one of these two graphs. The
decomposition is iterated until all the subgraphs consist of not more than k + 1 vertices.
It follows that this decomposition has only O(log n) levels.
Given the decomposition of G, we produce polygons Qxy (G) as follows. The polygon
Qxy computed will incorporate all of the resultants of simple paths from x to y. (Recall
that a simple path can begin and end at the same point, so x and y may be equal.) Let
G1, G2 , and C be as explained above. We state the algorithm recursively. Thus, assume
we have computed polygons Qxy (Gi ) for all pairs of vertices x y 2 Gi (i = 1 2). In
particular, if x y 2 C then we have for them two polygons Qxy (G1) and Qxy (G2).
The recursive step is performed as follows. Let x and y be any two vertices of G for
which we compute Qxy (G). For simplicity of notation assume without loss of generality
that x 2 G1. Any simple path from x to y can be represented as a union of paths
(z0 z1) (z1 z2) . . . (zl;1 zl) where z0 = x, zl = y, zi 2 C for i = 1 . . . l ; 1, and
(z z0) denotes some simple path from z to z0. Moreover, paths of the form (z2i z2i+1)
stay entirely within G1 while paths of the form (z2i;1 z2i) stay entirely within G2. Thus,
13
to incorporate the resultants of all simple paths connecting x and y in G, it su ces to
intersect all the polygons obtained by compositions of the form
Qxz1 (G1 )  Qz1z2 (G2)  Qz2z3 (G1)      Qz ;1 y (Gi )
l

(where y 2 Gi), so that the zj 's (1 j l ; 1) are pairwise distinct points in C .

The number of dierent choices of the zj 's implies that for each pair x y, the number
of polygons intersected this way is bounded by a constant K depending only on k. For
each pair x and y, each composition is of at most k + 2 polygons. This may multiply
the number of breakpoints by at most O(k), since composition of k polygons can be
computed in O(log k) compositions of two polygons (where the number of breakpoints is
at most approximately doubled). Since the entire process runs in O(log n) stages, and
there are m inequalities at the beginning, it follows that the number of edges in each
of the generated polygons is m (kK )O(log n). This is the same as mng(k) for some g(k)
depending only on k hence it is polynomial in m and n for any xed k. The running
time on a suitable number of processors is O(log2 n log m) with a coe cient that depends
on k. By Theorem 2.1 this algorithm can determine feasibility.

8. Directions for further work

It is interesting to ask whether the algorithms we have described in Sections 4, 5, and
6 can ever in fact require more than polynomially many processors. This is essentially
the same as the question asked in 17] of whether the algorithm of 17] can require more
than polynomial time.
More generally, resolving whether the linear programming problem with two variables
per inequality lies in NC seems like a very interesting question. To provide context,
note that Cook fairly recently observed 6, p. 18] \I nd it interesting that very few
natural problems in poly-log space] have come to my attention which are not in NC.
One notable exception is the problem of determining whether two groups, presented by
their multiplication tables, are isomorphic. . . .. I know of no NC solution to this problem,
or even any polynomial time solution." Thus the present status of linear programming
with two variables per inequality seems to be rather unusual, particularly since it is
known to be solvable in polynomial time (even if we allow that inputs are arbitrary reals
and the time bound must be independent of these values 15]).
Acknowledgment. This work was done while the authors were at Mathematical
Sciences Research Institute, Berkeley, California.

References
14
 1] A. V. Aho, J. E. Hopcroft, and J. D. Ullman. The Design and Analysis of Computer
Algorithms, Addison-Wesley, Reading, Mass., 1974.
2] B. Aspvall and Y. Shiloach, \A polynomial time algorithm for solving systems of
linear inequalities with two variables per inequality," SIAM J. Comput. 9 (1980)
827{845.
3] A. Borodin, \On relating time and space to size and depth" SIAM J. Comput. 6
(1977) 733{744.
4] A. Borodin and J. E. Hopcroft, \Routing, merging, and sorting on parallel models
of computation," J. Comput. System Sci. 30 (1985) 130{145.
5] R. P. Brent, \The parallel evaluation of general arithmetic expressions," J. Assoc.
Comput. Mach. 21 (1974) 201{206.
6] S. A. Cook, \A taxonomy of problems with fast parallel algorithms," Information
and Control 64 (1985), pp. 2{22.
7] D. Dobkin, R. J. Lipton and S. Reiss, \Linear programming is log space hard for
P," Information Processing Letters 8 (1979) 96{97.
8] L. R. Ford, Jr., and R. D. Fulkerson, Flows in Networks, Princeton University Press,
Princeton, NJ, 1962.
9] S. Fortune and J. Wyllie, \Parallelism in random access machines," Proc. 10th An-
nual ACM Symposium on Theory of Computing, 1978, pp. 114{118.
10] L. M. Goldschlager, \Synchronous parallel computation," Technical Report No. 114,
Department of Computer Science, University of Toronto, December 1977.
11] L. M. Goldschlager, R. A. Shaw and J. Staples, \The maximum ow problem is log
space complete for P," Theoretical Computer Science 21 (1982) 105{111.
12] D. Helmbold and E. Mayr, \Fast scheduling problems on parallel computers," Report
No. STAN-CS-84-1025, Computer Science Department, Stanford University, 1984.
13] R. M. Karp and V. Ramachandran, \Parallel algorithms for shared memory ma-
chines," in: Handbook of Theoretical Computer Science, J. van Leeuwen, ed., North-
Holland, 1988, to appear.
14] L. G. Khachiyan, \A polynomial algorithm in linear programming," Soviet Math.
Dokl. 20 (1979) 191{194.
15] N. Megiddo, \Towards a genuinely polynomial algorithm for linear programming,"
SIAM Journal on Computing 12 (1983) 347{353.
16] N. Megiddo, \Applying parallel computation algorithms in the design of serial algo-
rithms," J. Assoc. Comput. Mach. 30 (1983) 852{865.
17] C. G. Nelson, An nO(log n) algorithm for the two two-variable-per-constraint linear
programming satisability problem," Report No. STAN-CS-78-689, Department of
Computer Science, Stanford University, November 1978.
18] N. Robertson and P. D. Seymour, \Graph width and well-quasi-ordering: a survey,"
Progress in Graph Theory, Academic Press Canada, 1984, pp. 399{406.
19] R. Shostak, \Deciding linear inequalities by computing loop residues," J. Assoc.
Comput. Mach. 28 (1981) 769{779.

15
20] L. Stockmeyer and U. Vishkin, \Simulation of parallel random access machines by
circuits," SIAM J. Comput. 13 (1984) 409{422.

16