A Polynomial Algorithm for Abstract Maximum Flow

Transcription

1 A Polynomial Algorithm for Abstract Maximum Flow S. Thomas McCormick Faculty of Commerce and Business Administration University of British Columbia Vancouver, BC V6T 1Z2 Canada May 1998 UBC Faculty of Commerce Working Paper 95-MSC-001 Abstract Ford and Fulkerson s original 1956 max flow/min cut paper formulated max flow in terms of flows on paths, rather than the more familiar flows on arcs. In 1974 Hoffman pointed that Ford and Fulkerson s original proof was quite abstract, and applied to a wide range of max flow-like problems. In this abstract model we have capacitated elements, and linearly ordered subsets of elements called paths. When two paths share an element ( cross ), then there must be a path that is a subset of the first path up to the cross, and a subset of the second path after the cross. (Hoffman s generalization of) Ford and Fulkerson s proof showed that the max flow/min cut theorem still holds under this weak assumption. However, this proof is non-constructive. To get an algorithm, we assume that we have an oracle whose input is an arbitrary subset of elements, and whose put is either a path contained in that subset, or the statement that no such path exists. We then use complementary slackness to show how to augment any feasible set of path flows to a set with a strictly larger total flow value using a polynomial number of calls to the oracle. Then standard scaling techniques yield an overall polynomial algorithm for finding both a max flow and a min cut. 1 Introduction Perhaps the single most celebrated result in combinatorial optimization is the Max Flow-Min Cut Theorem (MFMC Theorem). This theorem, established by Ford and Fulkerson [4, Theorem 1] and independently by Elias, Feinstein, and Shannon [3], inspired a lot of later work in analysis of algorithms, data structures, polyhedral combinatorics, and min-max theorems; see Ahuja, Magnanti and Orlin [1], and Schrijver [10]. Thus the seminal paper [4] is one of the most widely cited in all of combinatorial optimization. Despite being widely cited, [4] is seldom actually read: At the Netflow93 Conference of 116 network flow specialists, Alan Hoffman, during his talk [8], asked how many of those present had read [4]. Only two people raised their hands (I was one of those in the audience who had not read [4], an omission I ve since rectified). It seems that most researchers in this field have largely formed their opinion of Ford and Fulkerson s work by reading their excellent book [5]. This research was partially supported by an NSERC Operating Grant, an NSERC Grant for Research Abroad, and a UBC Killam Faculty Study Leave Fellowship. Parts of this research were done while the author was visiting Laboratoire ARTEMIS IMAG at Université Joseph Fourier de Grenoble, France. An extended abstract of this paper appeared in [9] 1

2 Part of the point of Hoffman s talk was that there is a great difference between Ford and Fulkerson s original paper [4] and their later book [5] in how the MFMC Theorem is proved. The proof in [4] is quite abstract, non-constructive, uses flows on paths, and is general enough to apply to both directed and undirected graphs (with needing to reduce one to the other). By contrast, the proof in [5] is concrete, constructive (for integral capacities), uses flows on arcs, and refers only to directed graphs. In [7] Hoffman observed that in fact Ford and Fulkerson s original MFMC proof made very few assumptions ab the network. Hoffman s abstraction of [4] is as follows: We are given a finite set E of (capacitated) elements; each e E has integral capacity u e > 0. We are also given a family P of subsets of E, where each P P is called a path and has a linear order < P (if P and Q are two paths both containing elements e and f, it is entirely possible that e < P f but e > Q f). If e P Q (paths P and Q cross at e), define We then require that: (P, e, Q) = {f E f P and f P e} {f E f Q and f Q e}. There is a path contained in the element subset (P, e, Q) (and so also in (Q, e, P)). (1) Intuitively, (1) says that when P and Q cross at e, we could re flow from the beginning of P up to e, and on Q after e. However, (1) gives no guarantee that, e.g., the the path P contained in (P, e, Q) contains e, or, if P does contain e, that the set of elements on P less than e is a subset of the set of elements on P less than e, or that < P is at all consistent with either < P or < Q. This framework is implicit in [4]. It is easy to see that any of the usual variants of max flow, e.g., with directed or undirected graphs, with capacities on nodes and/or arcs in any combination, and with multiple and/or single sources and/or sinks, fit into this model (in their path flow versions). The abstract max flow problem associated with E and P puts a flow variable x P on each P P and a weight y e on each element e E. The dual linear programs are: (P) max x P P s.t. x P u e for all e E (2) P e x 0 (D) min u e y e e s.t. y e 1 for all P P (3) e P y 0 Here (P) wants to maximize the sum of flows on all paths, the value of x, denoted val(x), subject to the total flow through any element not being more than its capacity, whereas (D) wants a minimum capacity weighting of elements that covers all paths. The main theorem Hoffman proved in [7] is quite general. Here we give a simple version that applies to the model above. Theorem 1.1 (Hoffman, [7, Theorem 2.4]) When u is a non-negative integral vector, linear programs (P) and (D) have integral optimal solutions. 2

3 Since we assume that u is integral, a consequence of Theorem 1.1 is that there is in fact a 0-1 optimal solution to (D), which then picks a subset of elements L E that meets all paths. Such a subset is called a cut. The capacity of a cut L is cap(l) = e L u e, so problem (D) is indeed a minimum cut problem. Thus Theorem 1.1 simultaneously proves MFMC for all the variations of max flow mentioned above. We say that an element e is saturated (by a flow x) if (2) is satisfied with equality for e w.r.t. x, and that a path P is positive (w.r.t. x) if x P > 0. Complementary slackness between (P) and (D) says that if we can find an x and a 0-1 y, corresponding to element subset L, which are respectively feasible and which satisfy CS (i) every positive P has exactly one element in common with L; and (ii) every e L is saturated; then x and L are a max flow and a min cut, respectively. Unfortunately, Hoffman s proof of Theorem 1.1 follows Ford and Fulkerson s [4] proof of MFMC in being non-constructive. This raises the natural question of whether there is a polynomial algorithm for solving the abstract max flow problem. Hoffman challenged his audience during his talk at Netflow93 [8] as follows: Is there a reasonable way using only [the above assumptions] and some modest oracle to find a generalized max flow and a min cut? Since it is known [7] that, for integral capacities, there is an optimum flow which is integral, it would even be progress to find an algorithm which increases a given flow by one unit, if the given flow is not optimum. The main result in this paper is to answer yes to Hoffman s question. Indeed, the key to our algorithm is a subrine that achieves what the second sentence above asks for, which is the subject of Section 2. First we must deal with the question of an oracle, which is connected to how we represent such problems, and what we mean by polynomial algorithm in this case. We take the point of view that E is fairly small, so that we can, e.g., explicitly search through all elements to discover which are saturated. On the other hand, we will think of P as being big, possibly exponential in E. A small E and big P is consistent with most applications of this model. Thus a polynomial bound is allowed to involve E, but not P. Since we cannot explicitly search over all paths, we need some sort of oracle to represent P. A reasonable choice (suggested by Hoffman, personal communication) is an oracle that: (O) when given a subset F E, will return either a path whose elements are all contained in F, or the statement that there is no path whose elements are all contained in F. Note that we shall assume nothing ab which path (O) chooses to return when there is more than one path whose elements are contained in F, i.e., a returned path could be shortest, longest, or anything in between. However, we do assume that (O) gives us < P along with P, when a path does exist in F. Also, this oracle allows us to operationalize assumption (1), since we can send subset (P, e, Q) to (O), and be sure of getting a path in return. We will use this uncrossing ability later with explicit reference to (O). Section 2 gives a strongly polynomial algorithm for either augmenting a feasible flow or proving that it is optimal. Section 3 uses this rine a part of a standard scaling scheme to get a (weakly) polynomial algorithm for abstract max flow and min cut. Section 4 concludes with some open questions. 3

4 2 How to Augment a Flow We start by recalling a characterization of a min cut from Ford and Fulkerson s original paper [4]. Following [4], when e < P f we say that e is to the left of f on P. Define S as the subset of elements saturated by every maximum flow. Element e S is a left element of S if there is a path P with e P such that e is the left-most element of S on P. Then [4] shows that the set L of left-most elements of S is a min cut (by showing that it satisfies CS w.r.t. every max flow). Given some feasible integral flow x, our Augment subrine will take the point of view of trying to prove that x is optimal by finding an element subset L satisfying CS with x. Define S as the set of elements saturated by the current x, and initialize L as the set of left-most saturated elements from every currently positive path. As the algorithm proceeds, we may discover that an element e L is not saturated by a flow with value val(x). In this case we know that e cannot belong to L (assuming that x is a max flow), so we move e of L into T, the trash elements (initially empty). We also define A = S (L T), the active elements, which are selectively added to L when elements move from L to T to try to maintain the property that L is a cut. We might also discover that an e A is not saturated in every flow of value val(x), and so move e from A to T. Thus, once an element joins T (leaves A), it cannot leave T (re-join A) until val(x) is increased. Lemma 2.1 will justify treating elements of T as if they were not really saturated. Note that L, T, and A partition S. We will maintain the property that: Every e L is the left-most element of L A on some positive path, call it P(e). (4) This is certainly true initially. The overall subrine Augment calls four subrines. ReduceL moves elements from L A to T as necessary to ensure that every positive path contains at most one L-element. Variable time is incremented in ReduceL. The time of element e T is t(e) = the value of time during the call to ReduceL that added e to T. FindViol looks for a violating path, i.e., a path violating (3) w.r.t. the current L, and either concludes that the current x is optimal (if no violating path exists), or returns a violating path V. Augment calls ReduceL and FindViol in a loop. When FindViol finds a violating path with an A-element, Augment moves the left-most such element to L, and then calls ReduceL to update T based on this new information ab L. This continues until either we are optimal, or FindViol returns a violating path V whose only saturated elements are in T. Every iteration of this loop causes A to strictly decrease, so there can be at most E iterations before we either discover that we are optimal, or find a such a violating path. Thus Augment takes only polynomial time, exclusive of the subrine calls. Once a path V whose only saturated elements are in T is found, Augment calls FindPath, which constructs a sequence of paths that will be able to unsaturate the T-elements on V. Then Augment calls DoAug, which adjusts the structure returned by FindPath so that a feasible, integral augmentation can be done, and then does it. Detailed descriptions of these four subrines follow. Since L S, CS (ii) is satisfied, but CS (i) might be violated (because, e.g., positive P contains two or more elements of L). We apply subrine ReduceL to change L so that CS (i) is closer to being satisfied. Somewhat counterintuitively, when ReduceL finds a positive path P containing more than one element of L, it moves all elements of L A to the left of the right-most element of L on P to T. The reason is that (as Lemma 2.1 below shows) there is a simple flow change that preserves val(x) and unsaturates all elements moved to T, proving that they are not saturated by every flow of this value, and so are not eligible for L. ReduceL must look at every positive path. Section 3 will show a polynomial bound on the number of iterations of the max flow algorithm. Below we will see that DoAug adds only a polynomial number of positive paths at each step, so the number of positive paths is bounded by a polynomial. Thus ReduceL takes only polynomial time. 4

5 Algorithm Augment: Initialize L = {left-most S-elements on every positive path}, time = 0. ReduceL, FindViol. [All saturated elements on violating path V are in T A.] While V contains A-elements do: Let e be the left-most A-element on V. Move e from A to L. ReduceL, FindViol. [Now all saturated elements on V are in T.] FindPath, DoAug. Algorithm ReduceL: For each positive P with more than one element of L do time = time + 1. Set e to be the right-most element of L on P. For each element f of L A to the left of e on P, move f from L A to T and set t(f) = time. [Now in(f) = e and P (f) = P.] We need to introduce some notation to describe the state of the problem at the time t = t(f) that element f is moved to T by ReduceL. This will be needed later to describe FindPath. The event that caused f to move to T is that f is to the left of an element e in L on some positive path P. We denote e as in(f) and P as P (f). Furthermore, (4) guarantees that in(f) is the left-most element of L A on some positive path, call it P in (f). Note that by definition of in(f) on path P in (f): At time t = t(f), every S-element g to the left of in(f) on P in (f) is in T and has t(g) < t(f). (5) We now show that ReduceL is correct in moving elements to T. Strictly speaking, this lemma is not necessary for proving overall correctness, but it is useful as a warm-up for the more complicated flow changes we use later. Lemma 2.1 If x is a max flow and ReduceL adds f to T, then there is a max flow where f is not saturated. Thus f does not belong to the canonical set of left elements L, and so ReduceL has correctly moved f to T. Proof: Consider the first f moved to T. Since f is the first element to move to T, in fact in(f) is the left-most of all saturated elements on P in (f). Use (1) on (P in (f), in(f), P (f)) to get P. Suppose that we decrease x on P (f) by ɛ = 1/2 and increase x on P by ɛ to get x. The only elements whose total flow can increase during such a change are those on P which do not belong to P (f). But all such elements are also on P in (f) and are to the left of in(f) on P in (f), and so are unsaturated. Thus x is feasible, and val(x ) = val(x), so x is also a max flow. But f is not saturated w.r.t. x. Now let g be the second saturated element moved to T. The only possible T-element to the left of in(g) on P in (g) is f. But the previous paragraph unsaturated f by at least 1/2. Thus, as before, we can use (1) on (P in (g), in(g), P (g)) to get Q, and change x on Q and P (g) by ɛ = 1/4, yielding max flow x that does not saturate g. Continuing by induction gives the result. 5

6 This proof justifies treating elements in T as not being saturated, but is unsatisfactory from the point of view of Theorem 1.1 because it (lazily) uses fractional flows. However, we will see later that a more careful accounting will be able to unsaturate enough elements in T with integral flows to be able to increase val(x) (when x is not yet optimal). Since ReduceL creates no new elements of L it needs to scan each positive path only once, and when it ends: Each positive path contains at most one element in L, and (4) is still satisfied. (6) However, it is possible that there is a positive P with no elements in L, i.e., CS (i) might still not be satisfied. It is the job of FindViol to look for such paths. FindViol checks to see if L is feasible for (D), i.e., whether (3) is satisfied by the incidence vector of L, i.e., whether every P contains an element of L. It does this by sending the set L to (O); if (O) returns a path, it must be violating. If the oracle tells us that there is no path in L, then the current x and L must be optimal: After all, x is feasible to (P), by the non-existence of a violating path L is feasible to (D), by (6) and dual feasibility CS (i) is satisfied, and by definition of L CS (ii) is satisfied. Thus the absence of a violating path proves that x is a max flow and that L is a min cut, and Augment can stop. Since the number of positive paths is polynomial, FindViol takes polynomial time also. Algorithm FindViol: Send L E L to (O). If L has no path, we are optimal, stop. Set V = the returned path. [Now the only S-elements on V are in T A.] Because we are thinking of T-elements as not really being saturated, when FindViol returns a violating path whose only S-elements are in T, it signals that we can augment the flow. Lemma 2.1 gives a method to unsaturate all T-elements, but using fractional flows. FindPath will find a more complicated structure that will allow us to unsaturate enough T-elements to be able to do a positive, integral augmentation. Note that we have not constructively used property (1) yet. It becomes important in FindPath. Now let P 1 = V, and if there are T-elements on P 1, let e 1 be the right-most such. Set P1 = P (e 1 ), i 1 = in(e 1 ), and P1 in = P in (e 1 ). Now compute a path P 1 contained in (P1, e 1, P 1) as guaranteed by (1) (see Figure 1). Assume that P1 in has T-elements to the left of i 1, and let e 2 be the right-most of these. Note that t(e 2 ) < t(e 1 ) by (5). Now use (1) again on (P1 in, i 1, P1 ) to get P 2. Set P2 = P (e 2 ), i 2 = in(e 2 ), and P2 in = P in (e 2 ). Use (1) again on (P2, e 2, P 2 ) to get P 2. FindPath continues in this way, and stops when it finds a P k with no T-elements in P k P It then sets j to be the final value of k. It must stop in at most E iterations, because t(e k ) is strictly decreasing in k, and t(e 1 ) is bounded by T E. Since j E, FindPath clearly takes polynomial time. Our final picture is as in Figure 1. Note, however, that the order of the elements on the P k s might be quite different from the order of the elements on the Pk s. Note that all elements of P j Pj 1 are unsaturated, for 1 < k < j all elements of P k Pk 1 Pk (which might be empty) are unsaturated, and all elements of P 1 P1 are unsaturated. We call these path subsets positive segments. Also, all Pk s are positive paths; we call the parts of the Pk s between e k and i k negative segments. For 1 k < j we call the part of Pk from its beginning up to and including e k its initial segment; we also call P k Pk the initial segment of P k. Similarly, the part of Pk from and including i k to its end is its final segment, and P k+1 P k is the final k 1. 6

7 Algorithm FindPath: Initialize P 1 = V, k = 1, and P0 =. While there is a T-element in P k P k 1 do: Let e k be the right-most of the T-elements in P k P k 1 on P k. Set Pk = P (e k ), i k = in(e k ), and Pk in = P in (e k ). Apply (1) to (Pk, e k, P k ) to get P k. [Now there can be no T-elements remaining in P k P k 1 P k, because there are no T-elements in P k P k 1 to the right of e k on P k, by definition of e k.] Apply (1) to (Pk in, i k, Pk ) to get P k+1. [Now any T-elements e in P k+1 P k have t(e) < t(e k ), because all such were T-elements to the left of i k on Pk in, see (5).] k = k + 1. [Now there are no T-elements in P k P k 1.] Set j = k, and P j = P j. segment of P k+1. Thus each P k is partitioned into its initial segment, positive segment, and final segment. Note that: The initial segment of every P k is a subset of the initial segment of Pk, and the final segment of every P k+1 is a subset of the final segment of Pk. Because all elements in positive segments are unsaturated, and all paths traversing negative segments are positive, it naively seems as if we could feasibly choose an integral ɛ > 0 such that we could increase flow by ɛ on all P k, and decrease flow by ɛ on all Pk. This apparently would have the net effect of increasing total flow on all elements in positive segments, decreasing flow on elements in negative segments, and leaving flow in other elements the same. Since there is one more P k than Pk, this would increase val(x) by ɛ. We have effectively built an augmenting path consisting of the positive segments in the forward direction, and the negative segments in the backwards direction. However, there is no guarantee that all these paths are disjoint other than at the e k s and i k s. If, e.g., there is an element e common to the positive segment of P k and the positive segment of P l, then the augmentation suggested above would increase total flow on e by (at least) 2ɛ. This could then give a non-integral bound on ɛ coming from e. We can fix this as follows. Note that there is an asymmetry between upper bounds on flow and lower bounds on flow: Flow is upper bounded in (2) by total flow through each element, whereas it is lower bounded only by non-negativity of the path flows. Thus, as long as we decrease flow only on positive paths, we will never have a problem with lower bounds causing a fractional bound on ɛ. Also, due to (7), the net contribution of our proposed flow change to an element belonging to an initial segment of Pk coming from flow changes on Pk and P k must be non-positive; similarly for final segments. Thus an element can belong to an arbitrary number of initial and/or final segments and at most one positive segment with causing a fractional bound on ɛ. Thus we need to worry only ab elements belonging to more than one positive segment, and this is taken care of by subrine DoAug. Whenever such an overlap occurs, DoAug shortcuts the augmenting path: If the positive segments of P k and P l intersect in e for l < k, then use (1) on (P k, e, P l ) and cut the part of the old augmenting path between e on P k and e on P l. This can happen at most E times before we get an augmenting path with all positive segments disjoint. Now DoAug chooses a positive integral ɛ, decreases x P by ɛ on the Pk s, and increases x P by ɛ on the P k s. All of this can clearly be done in polynomial time. Note also that the number of new positive paths resulting from the augmentation is at most E, which is also polynomial. (7) 7

8 P 1 P1 e 1 pos 1 P 1 neg P 2 P2 e 2 pos i 1 2 P1 P 2 neg P 3 P 3 e 3 pos i 2 3 P 2 P 4 P 4 e 4 P3 neg pos i 3 4 P 3 neg j 1 P j 1 e j 1 pos neg P j 1 j pos i j 1 j P j 1 Figure 1: This is a schematic picture of the path structure built up by the time FindPath exits. The Pk move from left to right, and each segment is labeled by the paths that include its elements. Segments that get a net +ɛ in the augmentation are marked pos, those that get a net ɛ are marked neg, and those with no net change are not marked. This picture is simplified; in reality, paths may overlap arbitrarily, and the order of elements on paths sharing a common segment might be different. The foregoing discussion of the subrines and their running times has established: Theorem 2.2 Subrine Augment terminates in polynomial time, and either proves that its input x is optimal, or is able to change x to an integral x such that val(x ) > val(x). Thus Augment answers the second part of Hoffman s challenge in [8] quoted above. 3 A Polynomial Scaling Algorithm for Max Flow and Min Cut Since the seminal paper by Edmonds and Karp [2], researchers have increasingly realized that scaling is an extremely useful technique for turning algorithms that augment a feasible solution into algorithms that can find an optimal solution. For example, Schulz, Weismantel, and Ziegler [11] have used scaling to show that augmentation in strongly polynomial time and optimization in strongly polynomial time are equivalent for 0-1 optimization problems. Our Augment rine is strongly polynomial, but our problem is not 0-1, so we can t use the results in [11]. However, we can still get a (weakly) polynomial algorithm by generalizing the use of scaling for max flow by Gabow [6]. 8

9 Algorithm DoAug: While the positive segments are not disjoint do: Suppose that, for l < k, the positive segments of P k and P l both contain e. Use (1) on (P k, e, P l ) to get P. Shortcut the augmenting path by deleting P i and Pi for l i < k and replacing P k by P. Renumber all P i and Pi, i k, with numbers smaller by k l to re-gain Figure 1 but with j decreased by k l. Compute ɛ as the minimum of the smallest x P for the Pk s, and the slack in (2) for elements with a net flow change of +ɛ. Decrease x P by ɛ for all Pk, and increase x P by ɛ for all P k. Define U to be the largest capacity of any element, and b = log 2 U (one less than the number of bits needed to represent the largest capacity). For 0 k b + 1, define u k e = u e/2 k, the k-th scale of u. Thus u b+1 = 0, u b is a 0-1 vector, and u 0 = u. We use this to build the overall algorithm AbsMF for abstract max flow and min cut. Algorithm AbsMF: Initialize x b+1 = 0, L b+1 = E. For k = b to 0 by 1 do: Initialize x = 2x k+1, compute u k. Do: Augment. Until x is optimal. Let x k be the optimal flow and L k be the final element subset L for scale k. Output x 0 as a max flow, and L 0 as a min cut. Theorem 3.1 Algorithm AbsMF terminates after O( E log U) calls to Augment, and correctly computes an integral max flow x 0 and a min cut L 0. Proof: Note that 2u k+1 u k 2u k (8) Thus 2x k+1 is feasible to (P) with capacities u k. Write cap k (L) for the capacity of element subset L w.r.t. u k. By weak duality between x k and L k+1, (8), and the optimality of x k+1 and L k+1 at scale k + 1, we get val(x k ) cap k (L k+1 ) 2cap k+1 (L k+1 ) + L k+1 = 2val(x k+1 ) + L k+1. Thus AbsMF makes at most O( L k+1 ) O( E ) calls to Augment at scale k. Since b = O(log U), this gives the time bound. Since u 0 = u, and by Theorem 2.2, x 0 is a max flow and L 0 is a min cut for the original data u. Also, x 0 is integral because x is initially integral in AbsMF, and Augment and AbsMF preserve integrality. Thus AbsMF answers the first part of Hoffman s challenge in [8] quoted above. Theorem 3.1 also gives a new, constructive proof for Theorem

10 4 Open Problems Hoffman [7] actually proved a more general version of Theorem 1.1 with a sort of supermodular weights on paths. The conclusion is still that there exists an integral optimal solution with integer data. It is natural to wonder if our algorithm can be generalized to this case. There are other aspects of abstract max flow that we would like to understand better. First, is AbsMF, or some simple variant of it, a strongly polynomial algorithm? I conjecture, with much evidence, that the answer to this is no. Perhaps it would be possible to use a more clever scaling scheme and achieve a strongly polynomial bound. Second, suppose that we have a somewhat stronger oracle than (O), is it then possible to prove a strongly polynomial bound on AbsMF? Given that Edmonds and Karp s classic paper [2] derives the first strongly polynomial max flow algorithm based on augmenting along shortest paths, it is natural to wonder if we would get a strongly polynomial time bound if we are guaranteed that (O) always returns a shortest path contained within F. My intuition says yes, but that it would require a somewhat different proof than in [2]. Third, LP theory tells us that there is an optimal solution to (P) with at most E positive paths. However, DoAug is rather extravagant in possibly using many positive paths. It seems as if more careful implementations of the subrines in Section 2 could maintain a basic set of positive paths. Such a result would be nice since it would give more compact optimal solutions and better running time bounds. Also, achieving some such result seems to be a necessary precursor to solving the more general version of Hoffman s model. Finally, when our max flow problem comes from an actual network, can we use oracle (O) to construct the underlying network? Some preliminary results indicate that this can be done in some cases (N. Simonetti, personal communication), but a more complete understanding of which families of paths can be realized by networks is necessary to fully answer this. Acknowledgements I thank Alan Hoffman for publicizing this interesting problem at Netflow93, and for suggesting (O). I thank Bill Pulleyblank for passing the suggested oracle along to me. I thank Maurice Queyranne for pointing reference [11], and for helpful comments on earlier drafts. References [1] Ahuja, R.K., T.L. Magnanti, and J.B. Orlin (1993). Network Flows: Theory, Algorithms and Applications. Prentice Hall, New York, NY. [2] Edmonds J., and Karp, R.M. (1972). Theoretical Improvements in Algorithmic Efficiency for Network Flow Problems. J. ACM 19, [3] Elias, P., A. Feinstein, and C.E. Shannon (1956). A Note on the Maximum Flow through a Network. IRE Transactions on Information Theory, IT 2, [4] Ford, L.R., Jr., and D.R. Fulkerson (1956). Maximal Flow through a Network. Canadian J. of Mathematics, 8, [5] Ford, L.R., Jr., and D.R. Fulkerson (1962). Flows in Networks. Princeton University Press, Princeton, NJ. [6] Gabow, H.N. (1985). Scaling Algorithms for Network Problems. J. of Comput. Sys. Sci. 35 pp

11 [7] Hoffman, A.J. (1974). A Generalization of Max Flow-Min Cut. Math. Prog., 6, [8] Hoffman, A.J. (1993). How Can One Calculate a Generalized Maximum Flow? NETFLOW93 (the program book of extended abstracts from Netflow93, 3 7 October 1993, San Miniato, Italy), Technical Report TR-21/93, Università Degli Studi Di Pisa, Dipartimento Di Informatica, [9] S.T. McCormick (1995). A Polynomial Algorithm for Abstract Maximum Flow (extended abstract). In Proceedings of the Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, [10] Schrijver, A. (1986). Theory of Linear and Integer Programming. John Wiley & Sons, New York, NY. [11] Schulz, A.S., R. Weismantel, and G.M. Ziegler (1995). 0/1-Integer Programming: Optimization and Augmentation are Equivalent. Technical Report No. 441/1995, Fachbereich Mathematik, Technische Universität Berlin. 11