    # Minmax Centered k-Partitioning of Trees and Applications to Sink Evacuation with Dynamic Confluent Flows

Let T=(V,E) be a tree with associated costs on its subtrees. A minmax k-partition of T is a partition into k subtrees, minimizing the maximum cost of a subtree over all possible partitions. In the centered version of the problem, the cost of a subtree cost is defined as the minimum cost of "servicing" that subtree using a center located within it. The problem motivating this work was the sink-evacuation problem on trees, i.e., finding a collection of k-sinks that minimize the time required by a confluent dynamic network flow to evacuate all supplies to sinks. This paper provides the first polynomial-time algorithm for solving this problem, running in O((k, n) k n ^4 n) time. The technique developed can be used to solve any Minmax Centered k-Partitioning problem on trees in which the servicing costs satisfy some very general conditions. Solutions can be found for both the discrete case, in which centers must be on vertices, and the continuous case, in which centers may also be placed on edges. The technique developed also improves previous results for finding a minmax cost k-partition of a tree given the location of the sinks in advance.

## Authors

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

The main result of this paper is the derivation of a new method for solving the general minmax centered -partitioning problem on trees. The initial motivation was the construction of quickest evacuation protocols on dynamic tree flow networks, a problem that was not solvable within previous tree partitioning frameworks. Figure 1: A 6-partition P={P1,…,P6}, of tree T. Component Pi has associated sink or center si. f(Pi,si) is the cost of servicing Pi using si. FS(P)=max1≤i≤6f(Pi,si) is the full cost of servicing T with partition P and sink set S={s1,…,s6}.

A -partition of a tree is the removal of edges to create subtrees. Let denote the cost of subtree (subtrees will be denoted by their nodes). The cost of partition is The minmax -partition problem is to find a -partition of that minimizes

may sometimes be further defined as the cost of servicing the subtree from some sink or center The cost of the partition will then be where and See Fig. 1. The minmax centered -partition problem is to find that minimizes

Becker, Perl and Schach Becker1980 introduced a shifting algorithm for constructing minmax partitions of trees when is the sum of the weights of the nodes in This technique was then improved and generalized to other functions by them and other authors becker1983shifting ; Perl1985 ; Agasi1993 ; Becker1995 . Lari2015 ; Lari2016 discuss extensions to centered partitions. These results only hold for the very restrictive class of Invariant functions (see Becker1995 for a definition). In particular, the QFP cost that will interest us and be defined below will not be an invariant function.

If all nodes have given weights and is the path-length distance from to , then defines the -center problem which has its own separate literature. Frederickson frederickson1991parametric gives an algorithm for -center in an unweighted tree, i.e.,, while the weighted case can be solved in time megiddo1981n ; Cole87 .

The problem motivating this paper arises from evacuation using Dynamic Confluent Flows. Dynamic flow networks model movement of items on a graph.

Each vertex is assigned some initial set of supplies . Supplies flow across edges. Each edge has a length – the time required to traverse it – and a capacity , limiting how much flow can enter the edge in one time unit. If all edges have the same capacity the network has uniform capacity. As supplies move around the graph, congestion can occur as supplies back up waiting to enter a vertex, increasing the time needed to send a flow.

Dynamic flow networks were introduced by Ford and Fulkerson in Ford1958a and have since been extensively used and analyzed. The Quickest Flow Problem (QFP) starts with units of flow on (source) node and asks how quickly all of this flow can be moved to designated sinks. Good surveys of the problem and applications can be found in Skutella2009 ; Aronson1989 ; Fleischer2007 ; Pascoal2006 .

One variant of the QFP is the transshipment problem in which each sink has a specified demand with total source availability equal to total demand requirement. The problem is to find the minimum time required to satisfy all of the demands. The first polynomial time algorithm for that problem was given by Hoppe2000b with later improvements by fleischer1998efficient .

A variant of the QFP can also model evacuation problems, see e.g, Higashikawa2014 for a history. In this, vertex supplies can be visualized as people in one or multiple buildings and the problem is to find a routing strategy (evacuation plan) that evacuates all of them to specified sinks (exits) in minimum time. This differs from the transshipment problem in that the problem is to fully evacuate the sources, not to satisfy the sinks; sinks do not have predefined demands and may absorb arbitrarily large units of supply.

An optimal solution to this problem could assign different paths to different units of supply starting from the same vertex. Physically, this could correspond to two people starting from the same location travelling radically different evacuation paths, possibly even to different exits.

A constrained version of the problem, the one addressed here, is for the plan to assign to each vertex exactly one evacuation edge, i.e., a sign stating “this way out”. All people starting at or passing through must evacuate through After arriving at they continue onto ’s unique evacuation edge They continue following these unique evacuation edges until reaching a sink, where they exit. The initial problem is, given the sinks, to determine a plan minimizing the maximum time needed to evacuate everyone. Note that if each has a unique evacuation edge then the must form a directed forest with the sinks being the roots of the trees. Thus, an evacuation plan of tree using sinks is a centered -partition of See Fig. 2. A different version of the problem is, given , to find the (vertex) locations of the sinks/exits and associated evacuation plan that together minimizes the evacuation time. This is the -sink location problem. Figure 2: Each vertex except for the si has a unique associated evacuation edge (the si evacuate to themselves). These edges form a forest of directed in-trees with the tree roots being the si. This forest defines a centered 5-partition of T with centers si. The cost of the partition will be the maximum time required for a node to evacuate to its assigned exit si. Flows can merge and cause congestion so this evacuation time is a function of entire subtrees and not just of individual node-sink pairs.

Flows with the property that all flows entering a vertex leave along the same edge are known as confluent111Confluent flows occur naturally in problems other than evacuations, e.g., packet forwarding and railway scheduling Dressler2010b .; even in the static case constructing an optimal confluent flow in a general graph is known to be very difficult. If P NP, then it is impossible to construct a constant-factor approximate optimal confluent flow in polynomial time on a general graph Chen2007 ; Dressler2010b ; Chen2006 ; Shepherd2015 even with only one sink.

If edge capacities are “large enough” then no congestion occurs and every person starting at node should follow the same shortest path it can to an exit. The cost of the plan will be the length of the maximum shortest path. Minimizing this is is exactly the -center problem on graphs which is already known to be NP-Hard (garey1979computers, , ND50). Unlike -center, which is polynomial-time solvable for fixed , Kamiyama et al. Kamiyama proves by reduction to Partition, that, even for , finding the min-time evacuation protocol is still NP-Hard for general graphs. This was later extended Golin2017sink to show that even for and the sink location fixed in advance, it is still impossible to approximate the QFP time to within a factor of if P NP.

The only solvable known case for the sink location problem for general is for a path bhattacharya2017improved . For paths with uniform capacities this runs in time; for paths with general capacities in time.

When is a tree, the -sink location problem can be solved Mamada2006 in time. This can be reduced Higashikawa2014 ; bhattacharya2015improved down to for the uniform capacity version, i.e., all the are identical. If the locations of the sinks are given as input, Mamada2005a gives a time algorithm evacuation protocol, where is some constant. This is the problem of partitioning the tree optimally, given that the centers are already known. For “large” , Mamada2005 reduced the time down to . The literature does not contain any algorithm for solving the sink-location problem on trees. The best solution using current known results would be to try all possible decompositions of the tree into subtrees and apply the algorithm of Mamada2006 , yielding time.

When , Mamada2005a also provides an algorithm for calculating the evacuation cost to a single known sink. For the uniform capacity case, (Higashikawa2014c, , p. 34) gives a formula that reduces the calculation time down to . These two calculation algorithms will be used as oracles in the sequel.

The discussion above implicitly assumed that the sinks must be vertices of the original graph. This is known as the discrete case. Another possibility would be to permit sinks to be located anywhere, on edges as well as vertices. This variation is known as the continuous case.

This distinction occurs in evacuation modelling, e.g., locating an emergency exit in a hallway between rooms. Historically, this distinction is also explicit in the center in a tree literature. More specifically, Frederickson’s frederickson1991parametric algorithm for -center in an unweighted tree worked in both the continuous and discrete cases. For weighted -center, though, the two cases needed two different sets of techniques. megiddo1981n gave an algorithm for the discrete case while the continuous case required time megiddo1983new . It was only later realized that a parametric searching technique Cole87 could reduce the continuous case down to as well. Weighted -center restricted to the line can be solved in in both the discrete and continuous cases but were also originally solved separately; chen2015efficient provides a good discussion of the history of that problem.

### 1.1 Our contributions

This paper gives the first polynomial time algorithm for solving the -sink location problem on trees. It uses as an oracle a known algorithm for calculating the cost of the problem when and the sink is known in advance. Our results will be applicable to both the discrete and continuous versions of the problem.

###### Theorem 1.1

The -sink evacuation problem can be solved in

• time for general-capacity edges and

• time for uniform-capacity edges.

This result will be a special case of a general technique that works for a large variety of minmax cost functions on trees. Section 2 formally defines the Sink-Evacuation problem on trees, the more general class of functions for which our technique works and then states our results.

It is instructive to compare our approach to Frederickson’s frederickson1991parametric algorithm for solving the unweighted -center problem on trees, which was built from the following two ingredients.

1. An time previously known algorithm for checking feasibility, i.e., given , testing whether a -center solution with cost exists

2. A clever parametric search method to filter the pairwise distances between nodes, one of which is the optimal cost, via the feasibility test.

The main difficulty in solving the sink-evacuation problem is that no polynomial time feasibility test for -sink evacuation on trees was previously known. The majority of this paper is devoted to constructing such a test. Section 3 derives useful properties of the feasibility problem and Section 4 utilizes these properties to construct an algorithm. This algorithm works by making (amortized) calls to the fixed-sink algorithm oracle.

There is also no small set of easily defined cost values known to contain the optimal solution. We sidestep this issue in Section 5 by doing parametric searching within our feasibility testing algorithm, leading to Theorem 1.1.

Sections 3, 4 and 5 assume the discrete version of the problem. Section 6 describes the modifications necessary to extend the algorithm to work in the continuous case.

In Section 7 we conclude by noting that a slight modification to the algorithm allows improving, for almost all , the best previously known algorithm for solving the problem when the -sink locations are predetermined; from Mamada2005 down to .

## 2 Definitions and Results

Let be an undirected graph. Each edge has a travel time ; flow leaving at time arrives at at time Each edge also has a capacity . This restricts at most units of flow to enter edge per every unit of time.

Consider units of (supply) flow waiting at vertex at time to traverse edge They enter at a rate of units of flow per unit time so the last flow enters at time This flow then travels another time to reach The total time required to move all flow from to is then .

If two edges were combined in a path from then flow from travelling to might have to wait at for all the flow to first enter . When multiple paths meet, this results in congestion that can delay evacuation time in strange ways. Figure 3: An illustration of evacuation of a tree to sink, s. Initial values wv are above v. Each edge e is labelled with a (capacity, length) pair (ce,τe). The goal is to evacuate all supplies to s. Note that the tree contains 3 different branches containing, respectively, {a}, {b,c} and {d,e,f,g,h,i} whose evacuation times can be calculated separately. The time required to evacuate all supplies to s is 48, which is when the last supply from i arrives at s.

Figure 3 illustrates different types of congestion and gives an example of calculating the evacuation time of a tree to a given sink.

Given a graph , distinguish a subset with as sinks (exits). An evacuation plan specifies, for each vertex , the unique edge along which all flow starting at or passing through evacuates. Furthermore, starting at any and following the edges will lead from to one of the (if , flow at evacuates immediately through the exit at ). As noted earlier (Figure 2) the evacuation plan defines a confluent flow. The evacuation edges form a directed forest; the root of each tree is one of the designated sinks in

Given evacuation plan and the specifying the initial flow supply starting at each node, one can calculate, for each vertex, the time (with congestion) required for all of its flow supply to evacuate. The maximum of this over all is the minimum time required to required to evacuate all items to some exit using the rules above. Call this the cost for associated with the evacuation plan and denote it by

The -sink location problem is to find a subset of size and associated that minimizes

### 2.1 General problem formulation

The input will be a tree , and a positive integer . Let . The output will be , and an associated partition of into subtrees, each containing one vertex in that minimizes over all possible such pairs.

The algorithms will not explicitly deal with the complicated mechanics of evacuation calculations. Instead they will solve the location problem for any minmax monotone cost , given an oracle for solving a one-sink problem in which the location of the sink is pre-specified.

This level of abstraction simplifies the formulation and understanding of the algorithms. It can also be useful for solving other similar problems.

#### 2.1.1 Minmax monotone cost functions.

Minmax monotone cost functions are defined below. Note that this definition is consistent with the specific properties of the evacuation problem.

###### Definition 1

Let be a tree.

Let The phrase “ is a subtree of ” will denote that the graph induced by in is a subtree of

For any , are the neighbors of . For are the neighbors of .

A Partition of is such that each is a subtree, , and , . are the blocks of .

Let will denote the set of all partitions of such that .

Nodes in are assigned to the sink . For simplicity, we often will just say that (node) is assigned to (sink)

Let be an atomic cost function. can be interpreted as the cost for sink to serve the set of nodes . This interpretation of imposes the following natural constraints:

1. For , ,

• if , then .

• if is not a subtree of , then .

• if then ;

2. Set monotonicity
If , then ,
i.e. the cost can not decrease when a sink has to serve additional nodes.

3. Path monotonicity
Let and but Then . Intuitively, this means that as a sink serving moves away from the cost of servicing can not decrease.

4. Max tree composition (Fig. 4)
Let be a subtree of and a node with neighbors. Set to be the forest created by removing from , and the respective vertices of each tree in . Then

 f(U,s)=max1≤i≤tf(Ui∪{s},s).

The subtrees will be called slices of defined by Figure 4: Example of Max-Composition. Let U denote the complete tree. Removing s creates a forest with three trees, U1,U2,U3. By definition, f(U,s)=max{f(U1∪{s},s),f(U2∪{s},s),f(U3∪{s},s)}.

Note that 1-5 only define a cost function over one subtree and one single sink. Function is now naturally extended to work on on partitions and sets (Fig. 1).

1. [resume]

2. Max partition composition

 ∀P∈Λ[S],f(P,S)=maxPsi∈Pf(P,si). (1)
###### Definition 2

A cost function that satisfies properties 1-5 is called minmax monotone.

Given , the main problem will be to find an and that satisfy

 f(P∗,S∗)=minS⊆V,|S|≤k,P∈Λ[S]f(P,S). (2)

Our algorithms make calls directly to an oracle that, given subtree of and computes . As mentioned, in our case of interest, Mamada2005a provides an oracle for general-capacity sink evacuation and (Higashikawa2014c, , p. 34) provides oracle for uniform-capacity sink evacuation.

Finally, later amortization arguments will require the following definition:

###### Definition 3

If runs in time , then is asymptotically subadditive if

• and is non-decreasing.

• For all nonnegative ,

Note that for and , any function of the form is asymptotically subadditive so, in particular, the oracles mentioned above are asymptotically subadditive.

### 2.2 Results

The remainder of the paper is devoted to deriving two algorithms.

The first algorithm and the majority of the paper, provides a feasibility test, which solves a simplified, bounded-cost version of the problem. Given and determine whether there exists a -partition with cost at most

The second algorithm is for the original general problem. To find the location of sinks that minimize the cost of a -partition.

Our first result is

###### Theorem 2.1

If is an asymptotically subadditive algorithm for solving the fixed -sink problem that runs in time, then the bounded cost minmax -sink problem can be solved in time .

Combining this algorithm with a careful application of parametric searching will yield a a solution to the general problem:

###### Theorem 2.2

If is an asymptotically subadditive algorithm for solving the fixed -sink problem that runs in time then the minmax -sink problem can be solved in time

Theorem 1.1 follows directly from this and the -sink algorithms given by Mamada2005a and (Higashikawa2014c, , p. 34).

A simple modification of the 2nd algorithm will also solve the specialized partitioning version in which the sinks are fixed in advance. We will call a minmax monotone function relaxed if the defining satisfies properties 1,2, and 4 from Section 2.1.1 but does not necessarily satisfy property 3 (path monotonicity).222Because the sinks are predefined, they never move and path monotonicity is superfluous.

###### Theorem 2.3

If is an asymptotically subadditive algorithm for solving the fixed relaxed -sink problem that runs in time and that further satisfies , then the minmax fixed-sink problem can be solved in time

For the sink evacuation problem, plugging the oracle into Theorem 2.3 leads to a time algorithm, substantially improving upon the previously known Mamada2005a and Mamada2005 algorithms when .

All the results mentioned above hold for both the discrete and the continuous versions of the problem.

### 2.3 More Applications

Although our algorithm was motivated by confluent dynamic flows it is surprisingly easy to apply to unrelated problems. We provide three examples below. The input is always a tree

Given a tree and center recall the definition of slices in the max-composition rule. The were the subtrees that resulted by removing

Example 1: Weighted -center
Each vertex has weight and each edge has length . For any pair , is the sum of the lengths of the edges on the unique path connecting

As a warm-up application we note that our algorithm immediately yields a (non-optimal) algorithm for weighted center by setting

 f(U∪{s},s)=maxu∈Uwud(s,u)

where is a subtree, but . This satisfies the minmax monotone cost function properties laid out in Section 2.1.1 and can be evaluated in time using a breadth-first search scan of the tree. Thus Theorem 2.2 yields an time algorithm for solving the weighted -center problem.

The algorithm above is slower than the algorithms of megiddo1981n ; Cole87 . But, those algorithms strongly use parametric searching in a polynomially bounded space (costs defined by pairs of vertices). It would be difficult to modify them to include general constraints. As illustrated below, Theorem 2.2 permits adding many types of constraints without any increase in running time.

Example 2: Weight constrained weighted -center
Now denote the weight of a subtree by

Consider the following combination of the weighted -center problem and minmax weight-partitioning problem Becker1980 that adds the constraint that the weight of all slices is at most some fixed threshold This can be viewed as a natural limit on the capacity of the service center

For is a subtree, but set

 f(U∪{s},s)={maxu∈Uwud(s,u)if W(U)≤W,∞Otherwise (3)

This function also satisfies the minmax monotone cost function properties and can still easily be evaluated by a breadth-first search scan of the tree in time. Solving the minmax -sink problem for this function using Theorem 2.2 exactly solves the weighted -center problem in which each slice is constrained to have weight at most in time.

Adding additional constraints is not difficult. If is defined to be the number of edges (hop distance) on the path connecting and we could replace (3) with

 f(U∪{s},s)={maxu∈Ud(s,u)if W(U)≤W and dH(u,v)≤h,∞Otherwise

and the algorithm now exactly solves the weighted -center problem in which each slice is constrained to have weight at most and no node can be more than edges from a center. The running time remains the same because can still be evaluated in time.

Example 3: Minmax range partitioning
Motivated by obtaining balanced solutions Lari2015 discusses partitioning using range criteria. In this problem the sinks are specified in the input. For every and , is a given cost of servicing with sink .

The range-cost of serviced by is

 f(U,s)=maxu,v∈U|cus−cvs|,

i.e., the difference between the maximum and minimum service costs. The problem is to do centered -partitioning of the tree so as to minimize the maximum range-cost of a subtree.

Lari2015 gives an algorithm for this problem. While our algorithm can not solve this exact problem it can solve the variation when the range-costs are restricted to slices. That is when but set

 f(U∪{s},s)=maxu,v∈U|cus−cvs|.

Note that this yields a relaxed minmax monotone function. Since the range-cost can be calculated in time, Theorem 2.3 yields an algorithm for finding a -partition in which the max range-cost of a slice is minimized, almost an order of magnitude faster than the algorithm for the original problem,

We end by noting that the algorithm would remain valid if the range-cost was defined by minimizing the ratio between servicing costs within a slice rather than the absolute difference, i.e., setting

 f(U∪{s},s)=maxu,v∈Ucuscvs.

## 3 Useful Properties of the Discrete Bounded-Cost Problem

This section derives structural properties that will permit designing an algorithm. In both this section and Section 4, and are fixed given values.

###### Definition 4
• A sink configuration is a set of sinks and associated partition .

• A feasible sink configuration is a sink configuration satisfying ; is a feasible sink placement, and is a partition witnessing the feasibility of .

• An optimal feasible configuration is a feasible sink configuration with minimum cardinality; we write .

###### Definition 5

Let and be a partition of some such that and . Then is a partial sink configuration

###### Definition 6

Let where is a subtree of . is served by if, for some partition of , for each there exists such that .

Note that being a partial sink configuration implies that is served by .

###### Definition 7

Let be a subtree of and (not necessarily in ). supports if one of the following holds:

• If , then .

• If , let be the set of nodes on the path from to , inclusive of Then .

Note that if can be served by , then for any node in , is supported by some . The converse is not generally true.

###### Definition 8

Let . denote the unique directed path from to inclusive of

### 3.1 Greedy construction

Our algorithm greedily grows , maintaining the property that it will always be able to be completed to be an optimal feasible configuration. Thus, when the algorithm stops, is either an optimal feasible configuration with , or the algorithm answers no because . The algorithm also maintains a Working Tree containing uncommitted vertices and a set of sinks that may still have more nodes committed to them.

At the start of the algorithm, and Figure 5: (a) is a partial sink current configuration. Black nodes are sinks. Gray areas are the Ps associated with those sinks. Note that the “open” sinks S={s3,s4} are leaves of the working tree T. (b) is the result of an open commit creating new sink s5 and its associated Ps5. (c) results from two closed commits performed on s3 and then s4. Note that s3 and s4 are now closed and will never have any further nodes committed to them.

At each step, the algorithm will commit a subtree block of previously unserviced nodes to a sink . There will be two types of commits, (Fig. 5) with the following properties:

• Open commit: of to new sink .

• will be added to .

• will be added to .

• is removed from working tree which remains a tree.

• becomes a leaf of .

• Closed commit: of to existing which is a leaf of

• If , it contains unique neighbor of in

• is merged into and will be closed;
no new blocks will henceforth be added to

• is removed from , which will remain a tree.

Algorithm 1 encapsulates the above.

Later subsections will define the Peaking (Section 3.2) and Reaching (Section 3.4) subroutines that, respectively, implement Open and Closed commits.

Set to be the current sinks in the working tree . By construction, the sinks in will all be leaves of

The final algorithm will maintain optimality of . Informally this means that can be completed to an optimal . Formally

###### Definition 9

A partial sink configuration is optimal relative to Working Tree if

1. [label=(C0)]

2. There exists some optimal feasible sink configuration satisfying:

3. and

1. are leaves of

2.  (follows from (a) and (b))

4. Let be the partition block in associated with

1. If then and

2. If , then and

3. If then

Finally, suppose that is an optimal partial sink configuration relative to Let and . For later use we note that from (C2) the nodes in can be ordered as follows

 S∗={Sout∖Vs1,…,si,S=Sout∩Vsi+1,…,sj,S∗∖Sout⊆Vsj+1,…,sk∗}. (4)

The intuition is that a closed commit will move a sink from to and an open commit will move a sink from to . .

The definitions below are both relative to the current and .

###### Definition 10 (Self-sufficiency)

Fig. 6.
A subtree of is self-sufficient if can be served by .

A partition of induced by its self-sufficiency is a partition of into blocks , , such that , is a subtree of and Figure 6: Self-Sufficiency. T′=(V′,E′) is the tree “below” v. It contains sinks S′=Sout∩V={s1,s2,s3}. If for i=1,2,3, f(Pi,si)≤T, then T′ is self-sufficient and P1,P2,P3 is a partition of T′ induced by its self-sufficiency.
###### Definition 11 (T−v(u))

Fig. 7
Let be an internal node of tree and be a neighbor of Removing from creates a forest of disjoint subtrees of .

denotes the unique subtree such that .

The removal of edge splits into and The blocks greedily committed by the algorithm will all be self-sufficient subtrees in these forms.

### 3.2 Subroutine: Peaking Criterion Figure 7: Peaking criterion. Note that V is partitioned into Vv=V−v(u) and Vu=V−v(u). Vu originally contains no sinks while Vv does (the black nodes). If f(Vu,u)≤T, then u can serve Vu, so no sink is needed below u; if f(Vu∪{v},v)>T, then no node in Vv can singlehandedly support Vu. This pinpoints the position of exactly one sink to be placed at u.

The definition and lemmas below will justify a mechanism for greedily performing open commits. will always be the current working tree, will always be an optimal partial sink configuration relative to and

###### Definition 12 (Peaking criterion)

The ordered pair of points

satisfies the peaking criterion (abbreviated PC) if and only if (Fig. 7)

• ,

• contains no sink in , and

• but .

###### Lemma 1 (Peaking Lemma)

Let satisfy the peaking criterion. Then adding to and committing to sink using Algorithm 1 maintains as an optimal partial sink configuration.

Note: This is exactly an “open commit” as defined in Section 3.1 (Fig. 5(b).

###### Proof

Let be the feasible sink configuration given by (C1)-(C3). Set , . Recall from (4) that can written as

 S∗={Sout∖Vs1,…,si,S=Sout∩Vsi+1,…,sj,S∗∖Sout⊆Vsj+1,…,sk∗}.

Recall too (Fig. 7) that can be partitioned into and For all , let denote the unique sink such that From (C3), , and lies in as well.

Note the following properties with their justifications

• If and , then
Because the path passes through and then

• If and , then
Because the path passes through and then

• No can support .
Otherwise, from P2, Path monotonicity then implies that can support , contradicting that satisfies the peaking criterion.

• .
Follows directly from satisfying the peaking criterion.

• must contain at least one sink
Follows directly from P3 and P4 and fact that , .

From P5, Without loss of generality assume that and set

 V′=Vu∪⎛⎝r⋃ℓ=j+1P∗ℓ⎞⎠=Vu∪V′′whereV′′=⎛⎝⎛⎝r⋃ℓ=j+1P∗ℓ⎞⎠∖Vu⎞⎠∪{u}.

Because satisfies the peaking criterion, . We claim that as well and thus . There are two possible cases.

Case (i):
Suppose for some Then, from P2, , contradicting the assumption. Thus, for all , . Then so and

Case (ii):
Since WLOG assume

From P2 and C3(c), if and