Open Problems

When it comes to finding flow in planar graphs with vertex capacities, three main open problems remain: (1) eliminate the dependence on k in the running times of the algorithms of Sections 3.2 and 3.3; (2) generalize our algorithms to graphs with real capacities and more than three terminals; and (3) generalize any of our algorithms to surface-embedded graphs. Unfortunately, the first two open problems seem difficult. For the first problem, all of our algorithms relies on Lemma 3.1, so designing an algorithm whose running time does not depend on the number of terminals will probably require completely new techniques. For the second problem, we can either try to generalize the algorithm of Section 3.3 to handle real capacities or try to generalize the algorithm of Section 3.4 to handle more than three terminals. The difficulty with generalizing the algorithm of Section 3.3 is that this algorithm is fundamentally a scaling algorithm, which can only handle integer capacities. If we apply the algorithm to a graph with real capacities, then the flow could keep approaching the maximum flow without ever getting to it. The difficulty with generalizing the algorithm of Section 3.4 to the case where k > 3 is as follows. Suppose that k = 4. We can define a maximum flow in G◦ as being almost feasible if we can remove δ units of flow to get a feasible flow in G, where again δ = val(G◦) − val(G). We can prove that almost-feasible flows always exist. The main problem seems to be that there is no easy way of characterizing or getting an almost-feasible flow. For example, minimizing the sum of the excesses of the two infeasible vertices x and x0 does not necessarily work. Suppose there is one flow where the infeasible vertices both have excesses of 10, and another flow where the vertices both have excesses of 7. If δ = 10, then it could be the case that the first flow is almost feasible because removing a unit of flow through x may simultaneously remove a unit of flow through x0 (i.e., we can decompose the first flow into paths and cycles such that some paths pass through both x and x0), while the second flow is not almost feasible because removing a unit of flow through x does not simultaneously remove a unit of flow through x0, and vice versa.

The third open problem – generalizing an algorithm to surface graphs – may be easier. Consider the algorithm of Section 3.3. This algorithm exploits planarity in four ways. First, it relies on Lemma 3.1, which bounds the number of saddles, uses the fact that the graph is planar. However, the lemma can be easily generalized to surface graphs as follows:

Lemma 3.12. Any directed acyclic graph embedded on an orientable surface of genus g with k1 sources and k2 sinks has at most k1 + k2− 2 + 2g saddles.

Second, our algorithm needs to compute “lifts” of feasible flows in G into a supergraph G◦ in near-linear time. If G is planar, this reduces to computing a flow in a planar graph that

is just the union of disjoint cycles. If G has genus g, then we need to compute flows in a surface-embedded graph that is just the union of cycles. Clearly such a graph is still planar, so no changes in the algorithm are needed.

Third, our algorithm uses an algorithm by Borradaile et al. [23] that computes flows in O(k)-apex graphs in O(k3_{n log}3

n) time. (An O(k)-apex graph is a graph that can become a planar graph with the removal of O(k) vertices.) If G is a graph of genus g, then instead we need to compute integer flows in graphs that become surface graphs with the removal of O(k) vertices. Currently, no such algorithm is known. However, we may be able to construct one using the same strategy that Borradaile et al. use. Essentially, they Hochstein and Weihe’s algorithm [43] to their own O(n log3n)-time algorithm for multiple-source multiple- sink maximum flow in planar graphs. The result is an algorithm for O(k)-apex graphs with multiple sources and sinks that runs in O(k3_{n log}3_{n) time. In other words, adding k vertices}

arbitrarily to the graph increases the running time by a factor O(k3_{). Now in our case,}

we have algorithms that can compute integer flows in surface graphs with a single source and sink in O(g8_{n polylog(nU )) time [42]. We can generalize this to multiple sources and}

sinks in O(k2g8n polylog(nU )) time by computing flows from each source to each sink while updating the residual graph [44]. Thus, it seems we can use Hochstein and Weihe’s algorithm to get an algorithm that finds integer flows in graphs that become a surface graphs with the removal of O(k) vertices in O(k5g8n polylog(nU )) time.

Fourth, our algorithm uses a subroutine by Kaplan and Nussbaum that cancels cycles in planar flows in a particular way in O(n) time. Roughly speaking, the subroutine first cancels clockwise cycles, and then cancels counterclockwise cycles. However, in surface graphs, cycles can be neither clockwise nor counterclockwise. Thus, generalizing the subroutine of Kaplan and Nussbaum appears to be the main technical barrier to generalizing our algorithm to surface graphs. Specifically, given a surface graph and a homotopy or homology class, we would like to be able to find a circulation in the graph such that the resulting residual graph contains no cycles in the class, in near-linear time. Even for unit-capacity flow networks embedded in the torus, no polynomial-time algorithms are known. A related problem is the following: given a maximum flow in a surface graph, compute an acyclic maximum flow in the surface graph. Currently, the fastest algorithm known takes O(m log n) time for general graphs and thus O((n + g) log n) time for surface graphs [29], but Kaplan and Nussbaum showed that O(n) time is achievable in planar graphs [22]. Are there faster algorithms that exploit the topology of surface graph? More generally, are there algorithms that can compute acyclic flows in near-planar graphs faster than O(m log n) time?