Memory Efficient Max Flow for Multi-label Submodular MRFs

TL;DR

This paper introduces a memory-efficient max-flow algorithm that enables the optimal solution of large-scale multi-label submodular MRFs on standard computers, overcoming previous memory limitations.

Contribution

A novel max-flow algorithm variant that significantly reduces memory usage for multi-label submodular MRFs, enabling practical large-scale applications.

Findings

Reduces memory requirements from quadratic to linear in the number of labels.

Allows solving large multi-label submodular MRFs on standard hardware.

Maintains optimality of solutions despite memory efficiency improvements.

Abstract

Multi-label submodular Markov Random Fields (MRFs) have been shown to be solvable using max-flow based on an encoding of the labels proposed by Ishikawa, in which each variable $X_i$ is represented by $\ell$ nodes (where $\ell$ is the number of labels) arranged in a column. However, this method in general requires $2\,\ell^2$ edges for each pair of neighbouring variables. This makes it inapplicable to realistic problems with many variables and labels, due to excessive memory requirement. In this paper, we introduce a variant of the max-flow algorithm that requires much less storage. Consequently, our algorithm makes it possible to optimally solve multi-label submodular problems involving large numbers of variables and labels on a standard computer.

Tables

Table 1. TABLE I : Memory consumption and runtime comparison with state-of-the-art baselines for quadratic regularizer (see para. 2 of Sec.  8 , for details on the algorithms). A “*” indicates a memory estimate, and “ > > ” indicates that the algorithm did not converge to the optimum within the specified time. Note that our algorithm has a memory consumption 𝒪 ​ ( ℓ ) 𝒪 ℓ \mathcal{O}(\ell) times lower than the max-flow-based methods and is an order of magnitude faster than message-passing algorithms. Compared to EIBFS, our algorithm is only 4 – 7 times slower, but requires 12 – 23 times less memory, which makes it applicable to more realistic problems. In all stereo problems, TRWS cached the pairwise potentials in an array for faster retrieval, but in the case of inpainting, it was not possible due to excessive memory requirement.

Problem	Memory [MB]						Time [s]
	BK	EIBFS	DDSG	ADSal	TRWS	MEMF	BK	EIBFS	DDSG	ADSal	TRWS	MEMF
Tsukuba	3195	2495	258	252	287	211	14	4	$>$9083	$>$7065	198	28
Venus	7626	5907	424	418	638	396	35	9	$>$18156	1884	206	59
Sawtooth	7566	5860	415	415	633	393	31	8	$>$16238	10478	455	35
Map	6454	4946	171	208	494	219	57	9	$>$9495	$>$1679	187	36
Cones	*72303	*55063	657	939	5024	1200	-	-	$>$50000	$>$17866	1095	364
Teddy	*72303	*55063	659	939	5025	1200	-	-	$>$50000	$>$50000	6766	2055
KITTI	*88413	*67316	1422	1802	6416	2215	-	-	$>$50000	$>$50000	$>$45408	18665
Penguin	*173893	*130728	236	1123	215	663	-	-	$>$50000	$>$50000	$>$50000	6504
House	*521853	*392315	689	2389	643	1986	-	-	$>$50000	$>$50000	$>$50000	9001

Table 2. TABLE II : Memory consumption and runtime comparison of IRGC+expansion with either the BK method or our MEMF algorithm as subroutine (see Sec.  8.2 ). Here, “Penguin-128/10” corresponds to the Penguin problem with 128 labels and the truncated quadratic function with truncation value 10 as regularizer. A “*” indicates a memory estimate. Compared to BK method, MEMF is only 4 – 11 times slower but requires 13 – 18 times less memory, which makes it applicable to much larger MRFs.

Problem	Memory [MB]		Time [s]
	BK	MEMF	BK	MEMF
Penguin-128/10	4471	332	224	2566
House-64/15	8877	498	106	409
Penguin-256/20	*17143	663	-	17748
House-256/60	*137248	1986	-	19681

Table 3. TABLE III : Memory consumption and runtime comparison with state-of-the-art baselines for Huber regularizer (see Sec.  8.3 ). A “*” indicates a memory estimate, and “ > > ” indicates that the algorithm did not converge to the optimum within the specified time. Note that our algorithm has a much lower memory consumption than the max-flow-based methods and is an order of magnitude faster than message-passing algorithms. Compared to EIBFS, our algorithm is 7 – 11 times slower, but requires 7 – 10 times less memory, which makes it applicable to more realistic problems. In all stereo problems, TRWS cached the pairwise potentials in an array for faster retrieval, but in the case of inpainting, it was not possible due to excessive memory requirement.

Problem	Memory [MB]				Time [s]
	BK	EIBFS	TRWS	MEMF	BK	EIBFS	TRWS	MEMF
Tsukuba	1715	1385	287	211	8	3	198	28
Venus	3375	2719	638	396	17	5	211	57
Sawtooth	3348	2698	633	393	15	4	467	34
Map	2680	2116	494	219	22	5	$>$2953	36
Cones	*42155	*32167	5025	1200	-	-	1118	363
Teddy	*42155	*32167	5025	1200	-	-	6879	2064
KITTI	*42161	*32627	6416	2215	-	-	$>$30165	18923
Penguin	*33487	*25423	215	663	-	-	$>$50000	6277
House	*100494	*76295	643	1986	-	-	$>$50000	8568

Equations

$$E(\mathbf{x})=\sum _{i\in \mathcal{V}}{\theta }_i(x_i)+\sum _{(i,j)\in \mathcal{E}}{\theta }_{ij}(x_i,x_j),$$

$${\theta }_{ij}({\lambda }^{\prime },\mu )+{\theta }_{ij}(\lambda ,{\mu }^{\prime })-{\theta }_{ij}(\lambda ,\mu )-{\theta }_{ij}({\lambda }^{\prime },{\mu }^{\prime })\ge 0,$$

$$\hat{\mathcal{V}}$$

$$\hat{\mathcal{E}}$$

$${\hat{\mathcal{E}}}_v$$

$${\hat{\mathcal{E}}}_c$$

$${\theta }_i(\lambda )$$

$${\theta }_{ij}(\lambda ,\mu )$$

$$\sum _{j,\mu \mid e_{ji:\mu \lambda }\in \hat{\mathcal{E}}}{\psi }_{ji:\mu \lambda }=0\forall U_{i:\lambda }\in \hat{\mathcal{V}}.$$

$${\Sigma }_{ij:\lambda }=\sum _{\mu }{\psi }_{ij:\lambda \mu }.$$

$${\psi }_{i:\lambda }-\left({\psi }_{i:\lambda -1}+\sum _{(i,j)\in {\mathcal{E}}^{+}}{\Sigma }_{ij:\lambda }\right)=0,$$

$${\Sigma }_{ij:\lambda }$$

$${\Sigma }_{ji:\mu }$$

$${\Delta }_{i:{\lambda }^{\prime }}$$

$${\Delta }_{ij:\lambda \mu }$$

$${\Delta }_{ji:\mu \lambda }$$

$${\Delta }_{j:{\mu }^{\prime }}$$

$${\Sigma }_{ij:3}={\Sigma }_{ij:3}+{\alpha }_1,$$

$${\Sigma }_{ji:1}={\Sigma }_{ji:1}-{\alpha }_1,$$

$${\Sigma }_{ij:4}={\Sigma }_{ij:4}+{\alpha }_2,$$

$${\Sigma }_{ji:4}={\Sigma }_{ji:4}-{\alpha }_2.$$

$$E_{\theta }(\mathbf{x})=\sum _{i\in \mathcal{V}}\sum _{\lambda \in \mathcal{L}}{\theta }_{i:\lambda }{x}_{i:\lambda }+\sum _{(i,j)\in \mathcal{E}}\sum _{\lambda ,\mu \in \mathcal{L}}{\theta }_{ij:\lambda \mu }{x}_{i:\lambda }{x}_{j:\mu },$$

$${\theta }_{ij:\lambda \mu }^{\prime }$$

$${\theta }_{i:\lambda }^{\prime }$$

$${\theta }_c=\sum _{i\in \mathcal{V}}\underset{\lambda \in \mathcal{L}}{\min }{\theta }_{i:\lambda }.$$

$${\theta }_{i:\lambda }>0\forall \lambda \in \mathcal{L},$$

$$m_{ij:{\lambda }^{\prime }}$$

$$m_{ji:{\mu }^{\prime }}$$

$${\varphi }_{i:{\lambda }^{\prime }}^{\prime }$$

$${\varphi }_{j:{\mu }^{\prime }}^{\prime }$$

$${\varphi }_{ij:\lambda \mu }^{\prime }$$

$${\varphi }_{ji:\mu \lambda }^{\prime }$$

$${\theta }_{i:{\lambda }^{\prime }}^{\prime }$$

$${\theta }_{j:{\mu }^{\prime }}^{\prime }$$

$${\theta }_{ij:{\lambda }^{\prime }{\mu }^{\prime }}^{\prime }$$

$${\theta }_{ij:\lambda \mu }^{\prime }$$

$${\theta }_{i:\lambda }^{\prime }$$

$$m_{ij:{\lambda }^{\prime }}$$

$$m_{ji:{\mu }^{\prime }}$$

$${\Sigma }_{ij:\lambda }$$

Full text

1 Introduction

Ishikawa [1] introduced a max-flow-based method to globally minimize the energy of multi-label MRFs with convex edge terms. In [2], this method was extended to energy functions satisfying the multi-label submodularity condition, analogous to the submodularity condition for MRFs with binary labels. In the general case, however, this method requires $2\,\ell^{2}$ directed edges for each pair of neighbouring variables. For instance, for a $1000\times 1000$, 4-connected image with 256 labels, it would require approximately $1000\times 1000\times 2\times 256^{2}\times 2\times 4\approx 1000$ GB of memory to store the edges (assuming 4 bytes per edge). Clearly, this is beyond the storage capacity of most computers.

In this paper, we introduce a variant of the max-flow algorithm that requires storing only two $\ell$-dimensional vectors per variable pair instead of the $2\,\ell^{2}$ edge capacities of the standard max-flow algorithm. In the example discussed above, our algorithm would therefore use only 4 GB of memory for the edges. As a result, our approach lets us optimally solve much larger problems.

More specifically, in contrast to the usual augmenting path algorithm [3], we do not store the residual edge capacities at each iteration. Instead, our algorithm records two $\ell$-dimensional flow-related quantities for every pair of neighbouring variables. We show that, at any stage of the algorithm, the residual edge capacities can be computed from these flow-related quantities and the initial edge capacities. This, of course, assumes that the initial capacities can be computed by some memory-efficient routine, which is almost always the case in computer vision.

The optimality of Ishikawa’s formalism made it a method of choice as a subroutine in many approximate energy minimization algorithms, such as multi-label moves [4, 5] and IRGC [6]. Since our approach can simply replace the standard max-flow algorithm [7] in Ishikawa-type graphs, it also allows us to minimize the energy of much larger non-submodular MRFs in such approximate techniques. Furthermore, due to the similarity to standard max-flow, our algorithm can easily be extended to handle dynamic MRFs [8] and also be accelerated using the parallel max-flow technique [9].

We demonstrate the effectiveness of our algorithm on the problems of stereo correspondence estimation and image inpainting. Our experimental evaluation shows that our method can solve much larger problems than standard max-flow on a standard computer and is an order of magnitude faster than state-of-the-art message-passing algorithms [10, 11, 12]. Our code is available at https://github.com/tajanthan/memf.

A preliminary version of this paper is appeared in [13]. This extended version contains a polynomial time version of the MEMF algorithm, a discussion on the equivalence with min-sum message passing and an experiment to evaluate the empirical time complexity.

2 Preliminaries

Let $X_{i}$ be a random variable taking label $x_{i}\in\mathcal{L}$. A pairwise MRF defined over a set of such random variables can be represented by an energy of the form

[TABLE]

where $\theta_{i}$ and $\theta_{ij}$ denote the unary potentials (i.e., data costs) and pairwise potentials (i.e., interaction costs), respectively. Here, $\mathcal{V}$ is the set of vertices, e.g., corresponding to pixels or superpixels in an image, and $\mathcal{E}$ is the set of edges in the MRF, e.g., encoding a 4-connected or 8-connected grid over the image pixels.

In this work, we consider a pairwise MRF with an ordered label set $\mathcal{L}=\{0,1,\cdots,\ell-1\}$, and we assume that the pairwise terms satisfy the multi-label submodularity condition [2]:

[TABLE]

for all $\lambda,\lambda^{\prime},\mu,\mu^{\prime}\in\mathcal{L}$, where $\lambda<\lambda^{\prime}$ and $\mu<\mu^{\prime}$. Furthermore, we assume that the pairwise potentials can be computed either by some routine or can be stored in an efficient manner. In other words, we assume that we do not need to store each individual pairwise term. Note that, in computer vision, this comes at virtually no loss of generality.

2.1 The Ishikawa Graph

Ishikawa [1] introduced a method to represent the multi-label energy function (1) in a graph. The basic idea behind the Ishikawa construction is to encode the label $X_{i}=x_{i}$ of a vertex $i\in\mathcal{V}$ using binary-valued random variables $U_{i:\lambda}$, one for each label $\lambda\in\mathcal{L}$. In particular, the encoding is defined as $u_{i:\lambda}=1$ if and only if $x_{i}\geq\lambda$, and [math] otherwise. The Ishikawa graph is then an $st$-graph $\hat{\mathcal{G}}=(\hat{\mathcal{V}}\cup\{0,1\},\hat{\mathcal{E}})$111Some authors denote the nodes 0 and 1 by $s$ and $t$., where the set of nodes and the set of edges are defined as follows:

[TABLE]

where $\hat{\mathcal{E}}_{v}$ is the set of vertical edges and $\hat{\mathcal{E}}_{c}$ is the set of cross edges. Note that, the nodes $U_{i:\ell}$ and $U_{i:0}$ are identified as node 0 and node 1 respectively. We denote the Ishikawa edges by $e_{ij:\lambda\mu}\in\hat{\mathcal{E}}$ (contains edges in both directions) and their capacities by $\phi_{ij:\lambda\mu}$. We also denote by $e_{i:\lambda}$ the downward edge $(U_{i:\lambda+1},U_{i:\lambda})$. An example of an Ishikawa graph is shown in Fig. 1.

In an $st$-graph, a labeling $\mathbf{x}$ is represented by a “cut” in the graph (a “cut” partitions the nodes in the graph into two disjoint subsets $\hat{\mathcal{V}}_{0}$ and $\hat{\mathcal{V}}_{1}$, with $0\in\hat{\mathcal{V}}_{0}$ and $1\in\hat{\mathcal{V}}_{1}$). Then, the value of the energy function $E(\mathbf{x})$ is equal to the sum of the capacities on the edges from $\hat{\mathcal{V}}_{0}$ to $\hat{\mathcal{V}}_{1}$. In an Ishikawa graph, if the downward edge $e_{i:\lambda}$ is in the “cut”, then vertex $i$ takes label $\lambda$. In MRF energy minimization, each vertex $i$ takes exactly one label $x_{i}$, which means that exactly one edge $e_{i:\lambda}$ must be in the min-cut of the Ishikawa graph. This is ensured by having infinite capacity for each upward edge $e_{ii:\lambda\lambda+1}$, i.e., $\phi_{ii:\lambda\lambda+1}=\infty$ for all $i\in\mathcal{V}$ and $\lambda\in\mathcal{L}$. Note that, by construction of the Ishikawa graph, the capacities $\phi$ and the energy parameters $\theta$ are related according to the following formula:

[TABLE]

Finding the minimum energy labeling is a min-cut problem, which can be solved optimally using the max-flow algorithm [3] when the edge capacities are non-negative. As shown in [2], a multi-label submodular energy function can be represented by an Ishikawa graph with non-negative edge capacities $\phi$ and can therefore be minimized optimally by max-flow.

2.2 Max Flow

The most popular max-flow algorithm in computer vision [7] is an augmenting path algorithm that finds a path from node 0 to node 1 through positive edges (called an augmenting path) and then pushes the maximum flow without exceeding the edge capacities (called augmentation). The augmentation operation changes the edge capacities in the graph, and therefore, the residual graph needs to be stored. That is, when applied to the Ishikawa graph, the max-flow algorithm stores $2\,\ell^{2}$ values per pair of neighbouring variables. For large number of labels and of variables, the memory requirement is high and, in many practical problems, exceeds the capacity of most computers.

2.3 Our Idea

Let us assume that the max-flow algorithm is applied to the Ishikawa graph. As the algorithm proceeds, the capacities on the edges in the graph change in response to the flow. Here, instead of storing the residual graph, we propose recording the flow that has been applied to the graph.

However, since storing the flow would also require $2\,\ell^{2}$ values per variable pair, we propose recording two $\ell$-dimensional quantities related to the flow between pair of variables. More precisely, for each directed edge222$\mathcal{E}^{+}$ denotes the set of directed edges between the vertices in the MRF, i.e., if $(i,j)\in\mathcal{E}$ then, $(i,j)\in\mathcal{E}^{+}$ and $(j,i)\in\mathcal{E}^{+}$. $(i,j)\in\mathcal{E}^{+}$, we record the sum of outgoing flows from each node $U_{i:\lambda}$ to the nodes $U_{j:\mu}$ for all $\mu\in\{1,\cdots,\ell-1\}$. We call this quantity an exit-flow, denoted by $\Sigma_{ij:\lambda}$ (defined below in Eq. 6). We show that these exit-flows allow us to reconstruct a permissible flow (defined below in Def. 3.3), which in turn lets us compute the residual edge capacities from the initial ones. Importantly, while flow reconstruction is not unique, we show that all such reconstructions are equivalent up to a null flow (Def. 3.4), which does not affect the energy function. Note that this idea can be applied to any augmenting path algorithm, as long as the residual graph can be rapidly constructed.

For increased efficiency, we then show how finding an augmenting path can be achieved in a simplified Ishikawa graph (called block-graph) that amalgamates the nodes in each column into blocks. We then perform augmentation, which translates to updating our exit-flows, in this block-graph. As a side effect, since an augmenting path in our block-graph corresponds to a collection of augmenting paths in the Ishikawa graph, our algorithm converges in fewer iterations than the standard max-flow implementation of [7].

3 Memory efficient flow encoding

Before we introduce our memory efficient max flow algorithm, let us describe how the cumulative flow can be stored in a memory efficient manner. This technique can be used in any augmenting path flow algorithm, by reconstructing the residual edge capacities whenever needed.

Let us assume that the max-flow algorithm is applied to the Ishikawa graph. At some point in the algorithm, flow has passed along many of the edges of the graph.

Definition 3.1**.**

A flow is a mapping $\psi:\hat{\mathcal{E}}\to{\rm I\!R}$, denoted by $\psi_{ij:\lambda\mu}$ for the edges $e_{ij:\lambda\mu}$, that satisfies the anti-symmetry condition $\psi_{ij:\lambda\mu}=-\psi_{ji:\mu\lambda}$ for all $e_{ij:\lambda\mu}\in\hat{\mathcal{E}}$.

A flow is called conservative333A conservative flow is often referred to as a flow in the literature. if the total flow into a node is zero for all nodes, except for the source and the terminal, i.e.,

[TABLE]

Given $\psi$, the residual capacities of the Ishikawa graph are updated as $\phi=\phi^{0}-\psi$, where $\phi^{0}$ represents the initial edge capacities. Furthermore, we call the flow restricted to each column column-flows, which we denote by $\psi_{i:\lambda}\,;\,i\in\mathcal{V},\lambda\in\mathcal{L}$.

At first sight, it might seem that, to apply the max-flow algorithm, it is necessary to keep track of all the values $\psi_{ij:\lambda\mu}$, which would require the same order of storage as recording all the edge capacities. Below, however, we show that it is necessary to store only $\mathcal{O}(\ell)$ values for each $(i,j)\in\mathcal{E}$, instead of $\mathcal{O}(\ell^{2})$.

To this end, the flow values that we store in our algorithm, namely source-flows and exit-flows are defined below.

Definition 3.2**.**

For each $i\in\mathcal{V}$, the flow out from the source node $\psi_{i:\ell-1}$ is called a source-flow. 2. 2.

For each $(i,j)\in\mathcal{E}^{+}$ and $\lambda\in\{1,\cdots,\ell-1\}$, we define an exit-flow as

[TABLE]

We will show that these source-flows and exit-flows permit the flow $\psi$ to be reconstructed up to equivalence.

Now, let us define some additional properties of flow, which will be useful in our exposition.

Definition 3.3**.**

A flow $\psi$ is called permissible if $\phi^{0}_{ij:\lambda\mu}-\psi_{ij:\lambda\mu}\geq 0$ for all $e_{ij:\lambda\mu}\in\hat{\mathcal{E}}$.

Definition 3.4**.**

A flow $\psi$ is called null if the total flow into a node is zero for all nodes including the source and the terminal, i.e., satisfies Eq. 5 for all $U_{i:\lambda}\in\hat{\mathcal{V}}\cup\{0,1\}$.

Note that a null flow does not change the energy function represented by the $st$-graph and it is identical to passing flow around loops. Also, if $\psi$ is a null flow then so is $-\psi$.

Furthermore, note that the energy function encoded by an $st$-graph is a quadratic pseudo-boolean function [14], and a reparametrization of such a function is identical to a null flow in the corresponding $st$-graph.

Lemma 3.1**.**

Two sets of capacities $\phi$ and $\phi^{\prime}$ represent the same energy function exactly (not up to a constant), written as $E_{\phi}\equiv E_{\phi^{\prime}}$, if and only if $\phi^{\prime}-\phi$ is a null flow.

Proof.

This lemma is a restatement of the reparametrization lemma of [10, 15] in the context of $st$-graphs. ∎

Let $\phi$ and $\phi^{\prime}$ be two sets of residual capacities obtained from an initial set of capacities $\phi^{0}$ by passing two flows $\psi$ and $\psi^{\prime}$, i.e., $\phi=\phi^{0}-\psi$ and $\phi^{\prime}=\phi^{0}-\psi^{\prime}$. If $\phi$ and $\phi^{\prime}$ are equivalent, then, by Lemma 3.1, $(\phi^{0}-\psi)-(\phi^{0}-\psi^{\prime})=\psi^{\prime}-\psi$ is a null flow. Hence $\psi^{\prime}$ can be obtained from $\psi$ by passing flow around loops in the graph. See Fig. 2.

We can now state our main theorem.

Theorem 3.1**.**

Let $\phi^{0}$ be the initial capacities of an Ishikawa graph, and let $\Sigma$ be a set of exit-flows. Suppose that $\psi$ and $\psi^{\prime}$ are two conservative flows compatible with $\Sigma$, meaning that (6) holds for both $\psi$ and $\psi^{\prime}$, and that $\psi$ and $\psi^{\prime}$ have identical source-flows. Then $E_{\phi^{0}-\psi}\equiv E_{\phi^{0}-\psi^{\prime}}$.

The idea is then as follows. If a permissible conservative flow $\psi$ is obtained during an augmenting path flow algorithm, but only the exit-flows $\Sigma_{ij:\lambda}$ are retained for each $(i,j)\in\mathcal{E}^{+}$ and label $\lambda$, then one wishes, when required, to reconstruct the flow $\psi$ on a given edge $(i,j)\in\mathcal{E}$. Although the reconstructed flow $\psi^{\prime}$ may not be identical with the flow $\psi$, the two will result in equivalent energy functions (not just equal up to a constant, but exactly equal for all assignments). In the augmenting path algorithm, the current flow values are only needed temporarily, one edge at a time, to find a new augmenting path, and hence do not need to be stored, as long as they can be rapidly computed.

Now we prove Theorem 3.1.

Proof.

First we will prove that $\psi$ and $\psi^{\prime}$ have identical column-flows. For a conservative flow

[TABLE]

for all $i\in\mathcal{V}$ and $\lambda\in\{1,\ldots,\ell-1\}$. Since $\psi$ and $\psi^{\prime}$ are compatible with $\Sigma$ and have identical source-flows, $\psi_{i:\lambda}=\psi^{\prime}_{i:\lambda}$ for all $i\in\mathcal{V}$ and $\lambda=\mathcal{L}$. Hence they have identical column-flows.

Now we will prove the equivalence. Given a flow $\psi$, let us denote its restriction to the edges $e_{ij:\lambda\mu}$ for all $\lambda,\mu\in\{1,\ldots,\ell-1\}$ for some $(i,j)\in\mathcal{E}$ by $\psi_{ij}$, i.e. restriction to cross edges only. Since both $\psi_{ij}$ and $\psi^{\prime}_{ij}$ satisfy Eq. 6, $\psi^{\prime}_{ij}-\psi_{ij}$ is a null flow. Furthermore, since both $\psi$ and $\psi^{\prime}$ have identical column-flows, $\psi^{\prime}-\psi=(\phi^{0}-\psi)-(\phi^{0}-\psi^{\prime})$ is a null flow and, by Lemma 3.1, $E_{\phi^{0}-\psi}\equiv E_{\phi^{0}-\psi^{\prime}}$. ∎

3.1 Flow Reconstruction

Note that, from Eq. 7 it is clear that given the source-flows $\psi_{i:\ell-1}\,;\,i\in\mathcal{V}$, the column-flows $\psi_{i:\lambda}\,;\,i\in\mathcal{V},\lambda\in\mathcal{L}$ can be computed in a top-down fashion. Now we turn to the problem of finding the flows along the cross-edges $e_{ij:\lambda\mu}$.

Given the set of exit-flows $\Sigma$, the objective is to find a permissible flow $\psi^{\prime}$ satisfying Eq. 6. Note that there exists a permissible conservative flow $\psi$ compatible with $\Sigma$ and hence we find $\psi^{\prime}$ such that $\psi^{\prime}-\psi$ is a null flow. We do this by considering one edge $(i,j)\in\mathcal{E}$ at a time and reconstruct the flow by formulating a small max-flow problem.

Considering all the nodes $U_{i:\lambda}$ and $U_{j:\mu}$ for a given pair $(i,j)$, we join them with edges with initial capacities $\phi^{0}_{ij:\lambda\mu}$. Nodes with positive exit-flow $\Sigma_{ij:\lambda}$ are joined to the source with edges of capacities $\left|\Sigma_{ij:\lambda}\right|$. Similarly, those with negative exit-flow are joined to the terminal. See Fig. 3.

Note that, in this network, the edges from the source can be thought of as “supply” and the edges to the terminal can be thought of as “demand”. Since the total supply equals the total demand in this network and there exists a permissible flow $\psi_{ij}$ compatible with $\Sigma$ (i.e., satisfying the supply-demand equality), the maximum flow solution of this network $\psi^{\prime}_{ij}$ is compatible with $\Sigma$, i.e., satisfies Eq. 6. In fact we are interested in non-negative residual capacities $\phi^{\prime}_{ij}=\phi^{0}_{ij}-\psi^{\prime}_{ij}$ which are readily available in this network.

This problem can be solved using a greedy augmenting path algorithm. While this graph has $\mathcal{O}(\ell)$ nodes and $\mathcal{O}(\ell^{2})$ edges, this remains perfectly tractable, since we only consider one edge $(i,j)$ at a time. Therefore, ultimately, flow reconstruction can be done efficiently.

At this point, given the initial capacities $\phi^{0}$, the source-flows $\psi_{i:\ell-1}\,;\,i\in\mathcal{V}$ and the set of exit-flows $\Sigma$, we have shown how to reconstruct the non-negative residual edge capacities $\phi^{\prime}$. This requires $\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|\,\ell)$ values to be stored.

4 Polynomial Time Memory Efficient Max Flow

We now introduce our polynomial time memory efficient max flow algorithm, which minimizes multi-label submodular MRF energies with pairwise interactions. Our algorithm follows a similar procedure as the standard Edmonds-Karp algorithm [16], in that it iteratively finds the shortest augmenting path and then pushes the maximum flow through it without exceeding the edge capacities. However, instead of storing the residual graph, we store exit-flows as proposed in Section 3, which, at any stage of the algorithm, would allow us to compute the residual graph. Below, we discuss how one can find an augmenting path and update the exit-flows, i.e., perform augmentation, without storing the full Ishikawa graph.

4.1 Finding an Augmenting Path

Our algorithm finds an augmenting path in a subgraph of the Ishikawa graph, called lower-graph. In particular, the lower-graph contains only a subset of Ishikawa edges which satisfy the lowest-cross-edge property.

Definition 4.1**.**

Consider a directed edge $(i,j)\in\mathcal{E}^{+}$. For each node $U_{i:\lambda}$, the lowest-cross-edge is defined as, the edge $e_{ij:\lambda\mu}$ where $\mu$ is the smallest value such that $\phi_{ij:\lambda\mu}>0$.

More specifically, in addition to the vertical edges $\hat{\mathcal{E}}_{v}$, the lower-graph contains the lowest-cross-edges. Therefore, we only store $\mathcal{O}(\ell)$ edges per variable pair $(i,j)$. Now, the relationship between augmenting paths in the original Ishikawa graph and the lower-graph can be characterized by the following theorem.

Theorem 4.1**.**

Given the Ishikawa graph, there is an augmenting path in the lower-graph if and only if there exists an augmenting path in the Ishikawa graph.

Proof.

Since the lower-graph is a subgraph of the Ishikawa graph, if there is an augmenting path in the lower-graph, then there exists an augmenting path in the Ishikawa graph.

We will now prove the converse. Consider a directed edge $(i,j)\in\mathcal{E}^{+}$. Let $e_{ij:\lambda\mu}$ and $e_{ij:\lambda\mu^{\prime}}$ be two positive capacity edges from $U_{i:\lambda}$ and $e_{ij:\lambda\mu^{\prime}}$ be the lowest-cross-edge. Then, due to the upward infinite capacity edges from $U_{j:\mu^{\prime}}\leadsto U_{j:\mu}$, there is a positive capacity path from $U_{i:\lambda}\leadsto U_{j:\mu}$ through the lowest-cross-edge $e_{ij:\lambda\mu^{\prime}}$. This proves the theorem.

∎

This enables us to find all the augmenting paths in the Ishikawa graph by searching in a smaller graph that has $\mathcal{O}(\ell)$ edges per variable pair $(i,j)$.

Note that, as mentioned earlier, we find the shortest augmenting path in this lower-graph. However, by contrast to the Edmonds-Karp algorithm [16], the path distance is computed considering zero distance for the infinite capacity edges and unit distance for other edges, instead of unit distance for all the edges. The intuition for this modification is that, the infinite capacity edges will never become saturated (or eliminated from the graph) for the entire course of the algorithm. Note that, with this definition of path distance, the augmenting paths in both lower-graph and Ishikawa graph have same length. This will enable us to prove the polynomial time bound of our algorithm in a similar manner as the standard Edmonds-Karp algorithm. Note that, even in this case, the shortest augmenting path can be found using a Breadth First Search (BFS) scheme.

4.2 Augmentation

Now, given an augmenting path $p$, we want to push the maximum permissible flow through it. The edges in the augmenting path $p$ are updated in the similar manner as in the usual max-flow algorithm. In addition to that, for each cross edge $e_{ij:\lambda\mu}\in\hat{\mathcal{E}}_{c}$ that is in the augmenting path, the exit-flows are updated as follows:

[TABLE]

where $\alpha$ is the maximum possible flow along the path $p$.

After the flow augmentation, the lower-graph needs to be updated to maintain the lowest-cross-edge property. Note that the lowest-cross-edge property may be violated due to the following reasons:

A new lowest-cross-edge $e_{ij:\lambda\mu}$ is created due to a flow along the edge $e_{ji:\mu\lambda}$. 2. 2.

A new lowest-cross-edge $e_{ij:\lambda\mu}$ is created due to a saturating flow along $e_{ij:\lambda\mu^{\prime}}$ for some $\mu^{\prime}<\mu$, i.e., the edge $e_{ij:\lambda\mu^{\prime}}$ disappears from the Ishikawa graph.

Note that, during an augmentation, if a new lowest-cross-edge is created due to a flow in the opposite direction (case-1 above), then the new lowest-cross-edge is known and the lower-graph can be updated directly, i.e., the new lowest-cross-edge can be stored.

On the other hand, if a cross edge becomes saturated (case-2), then we need to run the flow reconstruction algorithm to find the new lowest-cross-edge and update the lower-graph. This can be done in a memory efficient manner, since it only involves one edge $(i,j)\in\mathcal{E}$ at a time.

4.3 Summary

Our polynomial time memory efficient max flow is summarized in Algorithm 1. Let us briefly explain the subroutines below.

lower-graph

Given the initial Ishikawa edge capacities $\phi^{0}$, this subroutine constructs the lower-graph (with edge capacities $\bar{\phi}$) by retaining the lowest-cross-edges from each node $U_{i:\lambda}\in\hat{\mathcal{V}}$, for each directed edge $(i,j)\in\mathcal{E}^{+}$ (see Sec. 4.1). If the input to this subroutine is the Ishikawa capacities $\phi_{ij}$ corresponding to the edge $(i,j)\in\mathcal{E}$, then it retains the lowest-cross-edges $\bar{\phi}_{ij}$.

shortest_augmenting_path

Given the lower-graph parameters $\bar{\phi}$, this subroutine finds the shortest augmenting $p$ using BFS, as discussed in Section 4.1.

augment

Given the path $p$, this subroutine finds the maximum possible flow through the path and updates the lower-graph and the set of exit-flows, as discussed in Section 4.2. In addition, if a new lowest-cross-edge is created due to a flow in the opposite direction (case-1 in Sec. 4.2), then it also updates the lower-graph capacities $\bar{\phi}$.

compute_edges

Given the initial Ishikawa edge capacities $\phi^{0}$ and the set of exit-flows $\Sigma$, this subroutine computes the non-negative residual Ishikawa capacities $\phi_{ij}$ corresponding to the given edge $(i,j)$. This is accomplished by solving a small max-flow problem (see Sec. 3.1).

get_labelling

This subroutines finds the partition of the lower-graph by running BFS.

As discussed above, the exit-flows $\Sigma$ require $\mathcal{O}(\ell)$ storage for each edge $(i,j)\in\mathcal{E}$. In addition, the lower-graph can have at most $\mathcal{O}(|\mathcal{V}|\,\ell)$ nodes and $\mathcal{O}(|\mathcal{E}|\,\ell)$ edges. Furthermore, recall that we assume that the initial Ishikawa edge capacities $\phi^{0}$ can be stored efficiently. Therefore, ultimately, the space complexity of our algorithm is $\mathcal{O}((|\mathcal{V}|+|\mathcal{E}|)\,\ell)=\mathcal{O}(|\mathcal{E}|\,\ell)$. Let us now prove the polynomial time bound of our algorithm.

4.4 Time Complexity Analysis

We follow the time complexity analysis of the standard Edmonds-Karp algorithm [16] to derive a polynomial time bound on our algorithm. In particular, first the analysis proves that the shortest path distance from source (node 0) to any node is monotonically increasing with each flow augmentation. Then, it derives a bound on the number of augmentations. In fact, the number of augmentations of our MEMF algorithm also has the same bound as the Edmonds-Karp algorithm.

Theorem 4.2**.**

If the MEMF algorithm is run on the Ishikawa graph $\hat{\mathcal{G}}=(\hat{\mathcal{V}}\cup\{0,1\},\hat{\mathcal{E}})$ with source [math] and terminal $1$, then the total number of augmentations performed by the algorithm is $\mathcal{O}(|\hat{\mathcal{V}}||\hat{\mathcal{E}}|)$.

Proof.

The proof follows the steps of standard proof of the Edmonds-Karp algorithm. See Appendix A for details. ∎

Let us analyze the time complexity of each subroutine below. Note that, both the subroutines shortest_augmenting_path and augment runs in $\mathcal{O}(|\mathcal{E}|\,\ell)$ time, since, in the worst case, both subroutines need to check each edge in the lower-graph. However, compute_edges required to run the flow reconstruction algorithm which takes $\mathcal{O}(\ell^{3})$ time for each variable pair $(i,j)$ (assuming a small max-flow problem with $2\,\ell$ nodes and $\ell^{2}$ edges, solved using the most efficient algorithm [17], see Sec. 3.1). Also lower-graph requires $\mathcal{O}(\ell^{2})$ time for each variable pair $(i,j)$, since it needs to check each of the Ishikawa edges. Hence, the worst case running time of each iteration (i.e., augmentation step) is $\mathcal{O}(|\mathcal{E}|\,\ell+K\,(\ell^{3}+\ell^{2}))=\mathcal{O}(|\mathcal{E}|\,\ell+|\mathcal{E}|\,\ell^{3})=\mathcal{O}(|\mathcal{E}|\,\ell^{3})$, where $K$ is the maximum number of flow-reconstructions (i.e., saturated cross edges) at an augmentation step. Since the number of augmentations is bounded by $\mathcal{O}(|\hat{\mathcal{V}}||\hat{\mathcal{E}}|)$, the worst case running time of the entire execution of the MEMF algorithm is $\mathcal{O}(|\mathcal{V}|\,\ell\,|\mathcal{E}|\,\ell^{2}\,|\mathcal{E}|\,\ell^{3})=\mathcal{O}(|\mathcal{V}||\mathcal{E}|^{2}\,\ell^{6})$. This is $\mathcal{O}(\ell)$ slower than the standard Edmonds-Karp algorithm on the Ishikawa graph. Note that, however, MEMF requires $\mathcal{O}(\ell)$ less memory.

5 Efficient algorithm

In the previous section, we have provided a general purpose polynomial time max-flow algorithm that is also memory efficient. However, for computer vision applications, the BK algorithm [7] is shown to be significantly faster than the standard max-flow implementations, even though it lacks the polynomial time guarantee. The basic idea is to maintain a search tree throughout the algorithm instead of building the search tree from scratch at each iteration.

Motivated by this, we also propose doing search-tree-recycling similar to the BK algorithm. Since we lose the polynomial time guarantee, for increased efficiency, we further simplify the Ishikawa graph. In particular, we find an augmenting path in a block-graph, that amalgamates the nodes in each column into blocks. Since an augmenting path in our block-graph corresponds to a collection of augmenting paths in the Ishikawa graph, our algorithm converges in fewer iterations than the BK algorithm.

5.1 Efficiently Finding an Augmenting Path

As mentioned above, we find an augmenting path in a block-graph444We called this a simplified graph in [13]., whose construction is detailed below.

Given the parameters $\phi$, we rely on the fact that there exists a label $\lambda$ such that $\phi_{i:\lambda}=0$ for each $i\in\mathcal{V}$. In fact, it is easy to see that in each column $i$, if all $\phi_{i:\lambda}$ are positive, then there exists a trivial augmenting path from $U_{i:\ell}$ to $U_{i:0}$, and the minimum along the column can be subtracted from each $\phi_{i:\lambda}$. Now, at each column $i$, we partition the nodes $U_{i:\lambda}$ for all $\lambda\in\{1,\cdots,\ell-1\}$ into a set of blocks, such that each node in a block is connected with positive edges $\phi_{i:\lambda}$. Let us denote these blocks by $B_{i:\gamma}$, where $\gamma$ is indexed from bottom to top starting from 0. Note that there is no edge between $B_{i:\gamma}$ and $B_{i:\gamma\pm 1}$. As depicted by Fig. 4, our block-graph then contains only the blocks and the edges between the blocks.

The edges in the block-graph are obtained as follows. Let us consider a directed edge $(i,j)\in\mathcal{E}^{+}$. We add an edge $B_{i:\gamma}\to B_{j:\delta}$, where $\delta$ is the smallest value such that $\phi_{ij:\lambda\mu}>0$ for some $U_{i:\lambda}\in B_{i:\gamma}$ and $U_{j:\mu}\in B_{j:\delta}$. While doing this, we also enforce that there is no edge $B_{i:\gamma^{\prime}}\to B_{j:\delta^{\prime}}$ such that $\gamma^{\prime}>\gamma$ and $\delta^{\prime}<\delta$. The reasoning behind this is that, because of the upward infinite-capacity edges between the nodes $U_{i:\lambda}$ and $U_{i:\lambda+1}$, we have the following:

If a node $U_{j:\mu}$ can be reached from $U_{i:\lambda}$ through positive edges, then the nodes $U_{j:\mu^{\prime}}$, for all $\mu^{\prime}\geq\mu$, can also be reached. 2. 2.

If a node $U_{j:\mu}$ can be reached from $U_{i:\lambda}$ through positive edges, then it can also be reached from the nodes $U_{i:\lambda^{\prime}}$, for all $\lambda^{\prime}\leq\lambda$.

Hence, an edge $B_{i:\gamma}\to B_{j:\delta}$ indicates the fact that there is some positive flow possible from any node $U_{i:\lambda}\in B_{i:\gamma^{\prime}}$, for all $\gamma^{\prime}\leq\gamma$, to any node $U_{j:\mu}\in B_{j:\delta^{\prime}}$, for all $\delta^{\prime}\geq\delta$. In other words, the set of edges obtained by this procedure is sufficient.

Now, the relationship between augmenting paths in the original Ishikawa graph and in our block-graph can be characterized by the following theorem.

Theorem 5.1**.**

Given the set of Ishikawa graph parameters $\phi$, there is an augmenting path in the block-graph if and only if there exists an augmenting path in the Ishikawa graph.

Proof.

The basic idea of this proof is the same as the proof of Theorem 4.1. See Appendix B. ∎

Note that the block-graph can only be used to find an augmenting path; the quantity of the maximum permissible flow cannot be determined in this graph. Therefore, the capacity of an edge $B_{i:\gamma}\to B_{j:\delta}$ is not important, but it is important to have these edges. Note also that the block-graph is constructed incrementally for each edge $(i,j)\in\mathcal{E}$. Hence, it only requires us to store the Ishikawa graph parameters $\phi_{ij}$ corresponding to the edge $(i,j)$. Furthermore, since the block-graph $\mathcal{G}_{b}$ is sparse, an augmenting path can be found fairly quickly.

Furthermore, similar to the BK algorithm, we find an augmenting path $P_{b}$ using BFS and maintain the search tree throughout the algorithm, by repairing it whenever the block-graph is updated. However, since the block-graph needs to be reconstructed after each augmentation, for simplicity, we maintain a single tree555The BK algorithm maintains two trees, source-tree and sink-tree, but we only maintain the source-tree.. More specifically, we grow the search tree from source (node 0), in a breadth first manner, and if sink (node 1) is reached, then the augmenting path $P_{b}$ is found.

5.2 Augmentation in the Block-graph

Now, given an augmenting path $P_{b}$ in the block-graph, we want to push the maximum permissible flow through it. More specifically, since $P_{b}$ corresponds to a set of augmenting paths $\{p_{b}\}$ in the Ishikawa graph, we will push the maximum flow through each path $p_{b}$, until no such path exists. This could be achieved by constructing the subgraph $\hat{\mathcal{G}}^{p}$ of the Ishikawa graph corresponding to the augmenting path $P_{b}$, and then finding each of the augmenting path $p_{b}$ by searching in $\hat{\mathcal{G}}^{p}$. This would require us to either store $\hat{\mathcal{G}}^{p}$ (not memory efficient) or call the flow reconstruction algorithm too many times.

Instead, we propose breaking down the augmentation operation in the block-graph into a sequence of flow-loops and a subtraction along a column. Then, the maximum flow through the path can be pushed in a greedy manner, by pushing the maximum flow through each flow-loop. Before describing this procedure in detail, we introduce the following definitions.

Definition 5.1**.**

A flow-loop $m(\lambda,\mu,\alpha)$ in the Ishikawa graph is defined as the following sequence of operations: First, a value $\alpha$ is pushed down the left column from $U_{i:\ell}$ to $U_{i:\lambda}$, then across from $U_{i:\lambda}$ to $U_{j:\mu}$, and finally up the right column from $U_{j:\mu}$ to $U_{j:\ell}$. Thus, applying the flow-loop $m(\lambda,\mu,\alpha)$ corresponds to replacing $\phi$ by $\phi+\Delta$, where

[TABLE]

Definition 5.2**.**

A flow-loop $\tilde{m}(\gamma,\delta,\alpha)$ in the block-graph $\mathcal{G}_{b}$ is defined by the following sequence of operations: First a value $\alpha$ is pushed down the left column from $U_{i:\ell}$ to $B_{i:\gamma}$, then across from $B_{i:\gamma}$ to $B_{j:\delta}$, and finally up the right column from $B_{j:\delta}$ to $U_{j:\ell}$.

Note that, for a flow-loop $\tilde{m}(\gamma,\delta,\alpha)$ to be permissible, block $B_{i:\gamma}$ must contain node $U_{i:\ell-1}$. Note also that the flow-loop $\tilde{m}(\gamma,\delta,\alpha)$ can be thought of as a summation of flow-loops $m(\lambda,\mu,\alpha^{\prime})$, where $U_{i:\lambda}\in B_{i:\gamma}$ and $U_{j:\mu}\in B_{j:\delta^{\prime}}$, for all $\delta^{\prime}\geq\delta$ (see Fig. 5).

Given these definitions, one can easily see that the augmentation operation along the path $P_{b}$ can be broken down into a sequence of flow-loops $\tilde{m}(\gamma,\delta,\alpha)$ and a subtraction along the last column $k$, as illustrated in Fig. 6. Now, we push the maximum permissible flow through $P_{b}$, using the following greedy approach.

For each edge $B_{i:\gamma}\to B_{j:\delta}$ that is part of the path $P_{b}$, we apply a flow-loop $\tilde{m}(\gamma,\delta,\alpha_{ij})$, where $\alpha_{ij}$ is the maximum permissible flow through the edge $B_{i:\gamma}\to B_{j:\delta}$. In fact, applying this flow-loop translates to reconstructing the Ishikawa edge capacities $\phi_{ij}$ corresponding to edge $(i,j)$ and then applying flow-loops $m(\lambda,\mu,\alpha^{\prime})$ for all $\lambda\geq\check{\lambda}$ and $\mu\geq\check{\mu}$, starting from $\check{\lambda}$ and $\check{\mu}$, until no permissible flow-loop $m(\lambda,\mu,\alpha^{\prime})$ exists, with $\check{\lambda}$ and $\check{\mu}$ the smallest values such that $U_{i:\lambda}\in B_{i:\gamma}$ and $U_{j:\mu}\in B_{j:\delta}$. Finally, in the last column $k$, all the values $\phi_{k:\lambda}$ are positive, and the minimum along column $k$ is subtracted from each $\phi_{k:\lambda}$. It is easy to see that this approach pushes the maximum permissible flow through the path $P_{b}$.

Since, for each edge $(i,j)$, we do not store all the $2\,\ell^{2}$ capacities, but only the $2\,\ell$ exit-flows $\Sigma$, augmentation must then also update these values. Fortunately, there is a direct relation between the flow-loops and $\Sigma$. To see this, let us consider the example flow-loop $\tilde{m}(1,0,\alpha_{ij})$ shown in Fig. 5. Applying this flow-loop updates the corresponding exit-flows as

[TABLE]

Similar updates can be done for all flow-loops in our procedure. Note that the edge $B_{i:\gamma}\to B_{j:\delta}$ represents a collection of possible paths from all the nodes $U_{i:\lambda}\in B_{i:\gamma}$ to all the nodes $U_{j:\mu}\in B_{j:\delta^{\prime}}$, for all $\delta^{\prime}\geq\delta$. Therefore, unlike in the full Ishikawa graph, after applying a flow-loop, the portion of the graph $\mathcal{G}_{b}^{ij}$ corresponding to edge $(i,j)\in\mathcal{E}$ needs to be reconstructed. This, however, can be done in a memory efficient manner, since it only involves one edge $(i,j)$ at a time.

5.3 Summary

Our memory efficient max-flow (MEMF) method is summarized in Algorithm 2. Let us briefly explain the subroutines below.

block-graph

Given the initial Ishikawa parameters $\phi^{0}$, this subroutine constructs the block-graph by amalgamating nodes into blocks as described in Section 5.1. If the input to the subroutine is the Ishikawa capacities $\phi_{ij}$ corresponding to the edge $(i,j)\in\mathcal{E}$, then it constructs the block-graph portion $\mathcal{G}_{b}^{ij}$.

augmenting_path

Given the block-graph $\mathcal{G}_{b}$ and the search tree $T$, this subroutine finds an augmenting path $P_{b}$ by growing the search tree, as discussed in Section 5.1.

augment

Given the path $P_{b}$, this subroutine pushes the maximum permissible flow through it by applying flow-loops $\tilde{m}(\gamma,\delta,\alpha)$ and then subtracting the minimum from the last column, as discussed in Section 5.2.

compute_edges

This is the same subroutine as in Algorithm 1. (see Sec. 4.3).

repair_tree

This subroutine is similar to the adoption stage of the BK algorithm. Given the reconstructed block-graph, the search tree $T$ is repaired by checking for valid parent for each orphan node. See section 3.2.3 in [7] for more detail.

get_labelling

This subroutine directly reads the optimal labelling from the search tree $T$.

As discussed Section 4.3, the space complexity of our algorithm is $\mathcal{O}(|\mathcal{E}|\,\ell)$. For the rest of the paper, this efficient version of the algorithm is referred to as MEMF.

6 Equivalence with Message passing

In this section, we will give a more insightful interpretation of our max-flow algorithm, by showing equivalence with the min-sum message passing algorithm. In particular, first we will characterize the notion of an augmenting path in the message passing context. Then, we will show that, the max-flow algorithm is, in spirit, equivalent to min-sum message passing, for multi-label submodular MRFs. Finally, we observe the relationship between the set of exit-flows in our algorithm and the set of messages in the message passing algorithm. To this end, first let us define the multi-label graph which will be used to explain the equivalence.

6.1 The Mutli-label Graph

An alternative way of representing the multi-label energy function (1) is by defining indicator variables $x_{i:\lambda}\in\{0,1\}$, where $x_{i:\lambda}=1$ if and only if $x_{i}=\lambda$. For a given $i$, exactly one of $x_{i:\lambda}$ ;  $\lambda\in\mathcal{L}$ can have value 1. In terms of the indicator variables, the energy function (1) may be written as

[TABLE]

where the values $\theta$ are a particular set of parameters determining the energy function. One may define a graph, called a multi-label graph, with nodes denoted by $X_{i:\lambda}\,;\,i\in\mathcal{V},\,\lambda\in\mathcal{L}$, as shown in Fig. 7. This graph represents the energy function. Given a labelling $\mathbf{x}$, the value of the energy function is obtained by summing the weights on all nodes with $x_{i:\lambda}=1$ (in other words $x_{i}=\lambda$) plus the weights $\theta_{ij:\lambda\mu}$ such that $x_{i:\lambda}=1$ and $x_{j:\mu}=1$.

Furthermore, given the Ishikawa edge capacities $\phi$ the parameters $\theta$ can be calculated using Eq. 4. Note that, in this case, $E_{\theta}(\mathbf{x})=E_{\phi}(\mathbf{x})$ for all labellings $\mathbf{x}$.

6.1.1 Reparametrization

The energy function (10) can be written in different ways as a sum of unary and pairwise terms . In particular, there may exist a different set of parameters $\theta^{\prime}$ such that $E_{\theta}(\mathbf{x})=E_{\theta^{\prime}}(\mathbf{x})$ for all $\mathbf{x}$, denoted as $E_{\theta}\equiv E_{\theta^{\prime}}$. The conditions under which $E_{\theta}\equiv E_{\theta^{\prime}}$ are well known [10, 15].

Lemma 6.1**.**

Two energy functions $E_{\theta}$ and $E_{\theta^{\prime}}$ are equivalent if and only if there exist values $m_{ij:\lambda}$ and $m_{ji:\mu}$ for $(i,j)\in\mathcal{E}$ and $\lambda,\mu\in\mathcal{L}$ such that

[TABLE]

The values of $m_{ij:\lambda}$ constitute a message $m_{ij}$ passed from the edge $(i,j)$ to the node $i$; it may be thought of as a message vector (indexed by $\lambda$). A message $m_{ij}$ causes values $m_{ij:\lambda}$ to be swept out of all the edges $\theta_{ij:\lambda\mu}$ and adds onto the nodes $\theta_{i:\lambda}$. Messages are passed in both directions from an edge $(i,j)$.

Note that, reparametrization provides an alternative way of implementing the min-sum message passing algorithm. In particular, the objective of min-sum message passing is to reparametrize the energy function so that the constant term $\theta_{c}$ is maximized, while keeping the parameters $\theta$ non-negative, where the constant term is defined as follows:

[TABLE]

For more details see [18, 10].

6.2 The Notion of an Augmenting Path in the Multi-label Graph

We will now give an equivalent notion of an augmenting path in the context of the multi-label graph. To this end, we will first understand the motivation behind finding an augmenting path in the Ishikawa graph.

Let us consider an augmenting path in the Ishikawa graph. If it is a trivial augmenting path, i.e., it is an augmenting path along a column from nodes $U_{i:\ell}$ to $U_{i:0}$, then pushing the maximum flow along the path translates into subtracting the minimum value from each $\phi_{i:\lambda}\,;\,\lambda\in\mathcal{L}$. In the multi-label graph, it is trivially equivalent to subtracting the minimum from each $\theta_{i:\lambda}\,;\,\lambda\in\mathcal{L}$.

Let us consider a more interesting augmenting path in the Ishikawa graph, which contains at least one cross edge $e_{ij:\lambda\mu}\in\hat{\mathcal{E}}_{c}$. Similar to the discussion in Section 5.2, one can easily see that, the augmentation operation can be broken down into a sequence of flow-loops $m(\lambda,\mu,\alpha)$ (see Def. 5.1) and a subtraction along a column. This intuitively suggests that an augmenting path in the Ishikawa graph can be translated into a trivial augmenting path by passing flow around loops, i.e., they differ by a null flow. Therefore, the motivation of finding an augmenting path, is to pass flow around loops to get a trivial augmenting path.

Note that, the notion of a trivial augmenting path in the multi-label graph is,

[TABLE]

for some $i\in\mathcal{V}$. Furthermore, by Lemma 3.1 and by Lemma 6.1, a flow-loop (or null flow) corresponds to a reparametrization of the multi-label energy function. Hence, the notion of an augmenting path in the multi-label graph can be characterized as, finding a set of reparametrizations that makes $\theta_{i:\lambda}$ positive for all $\lambda\in\mathcal{L}$ for some $i\in\mathcal{V}$.

6.3 Equivalence of Max-flow and Min-sum Message Passing

Note that, as we have discussed above, an augmenting path in the Ishikawa graph can be translated into a trivial augmenting path by passing flow around loops. Furthermore, pushing the maximum flow through a trivial augmenting path is simply a subtraction of the minimum value $\min_{\lambda\in\mathcal{L}}\phi_{i:\lambda}$ from each $\phi_{i:\lambda}$. In fact, one can accumulate the total flow passed from source to sink, which is exactly the constant term defined in Eq. 11. Hence, max-flow tries to maximize $\theta_{c}$, by passing flow around loops (i.e., reparametrizing), while keeping the edge capacities $\phi$ non-negative. This is, in spirit, equivalent to the min-sum message passing algorithm. Note that, the optimality of min-sum message passing for the case of multi-label submodular MRFs, is observed in [15, 19].

6.4 Flow-loop as a Reparametrization

As mentioned above, from Lemma 3.1 and Lemma 6.1, it is clear that, a flow-loop corresponds to a reparametrization of the multi-label energy function. In this section, we will find the equivalent reparametrization of a flow-loop $m(\lambda,\mu,\alpha)$. This will later allow us to understand the relationship between the set of exit-flows and the set of messages. Let us now state and prove our theorem.

Theorem 6.1**.**

Applying a flow-loop $m(\lambda,\mu,\alpha)$ in the Ishikawa graph is equivalent to a reparametrization in the multi-label graph, with messages

[TABLE]

Proof.

Let the Ishikawa parameters be $\phi$ and the multi-label graph parameters be $\theta$ and assume that the flow is applied between columns $i$ and $j$. Also after the flow the parameters be $\phi^{\prime}$ and $\theta^{\prime}$ respectively. Since $\theta$ can be calculated from $\phi$ using Eq. 4, $E_{\theta}\equiv E_{\phi}$. Similarly $E_{\phi^{\prime}}\equiv E_{\theta^{\prime}}$. Also from Lemma 3.1, $E_{\phi}\equiv E_{\phi^{\prime}}$. Hence, $E_{\theta}\equiv E_{\phi}\equiv E_{\phi^{\prime}}\equiv E_{\theta^{\prime}}$. Now from Definition 5.1,

[TABLE]

Substituting in Eq. 4,

[TABLE]

Now, since $E_{\theta}\equiv E_{\theta^{\prime}}$, by Lemma 6.1, there exists messages $m_{ij:\lambda}$ and $m_{ji:\mu}$ such that,

[TABLE]

With a little bit of calculation, one can see that, the messages take the following form

[TABLE]

Note that, for a permissible flow $m(\lambda,\mu,\alpha)$, the parameters $\phi^{\prime}$ and $\theta^{\prime}$ are non-negative. ∎

This equivalence is shown in Fig. 8 for an example flow-loop $m(2,1,\alpha)$. Note that, as shown in the figure, the flow $\alpha$ through an edge $\phi_{ij:\lambda\mu}$ may be recorded in the set of exit-flows $\Sigma$. Furthermore, as shown in the figure, the relationship between the set of exit-flows and the set of messages can be written as,

[TABLE]

7 Related work

The approaches that have been proposed to minimize multi-label submodular MRFs can be roughly grouped into two categories: Those based on max-flow and those based on an LP relaxation of the problem. Below, we briefly review representative techniques in each category.

7.1 Max-flow-based Methods

The most popular method to minimize a multi-label submodular MRF energy is to construct the Ishikawa graph [1] and then apply a max-flow algorithm to find the min-cut solution. Broadly speaking, there are three different kinds of max-flow algorithms: those relying on finding augmenting paths [3], the push-relabel approach [20] and the pseudo-flow techniques [21]. Even though numerous implementations are available, the BK method [7] is arguably the fastest implementation for 2D and sparse 3D graphs. Recently, for dense problems, the IBFS algorithm [22] was shown to outperform the BK method in a number of experiments [23]. All the above-mentioned algorithms, however, require the same order of storage as the Ishikawa graph and hence scale poorly. Two approaches have nonetheless been studied to scale the max-flow algorithms. The first one explicitly relies on the N-D grid structure of the problem at hand [24, 25]. The second one makes use of distributed computing [26, 9, 27]. Unfortunately, both these approaches require additional resources (disk space or clusters) to run max-flow on an Ishikawa graph. By contrast, our algorithm lets us efficiently minimize the energy of much larger Ishikawa-type graphs on a standard computer. Furthermore, using the method of [9], it can also be parallelized.

7.2 LP Relaxation-based Methods

One memory-efficient way to minimize a multi-label submodular MRF energy consists of formulating the problem as a linear program and then maximize the dual using message-passing techniques [18]. Many such algorithms have been studied [10, 11, 12, 15]. Even though these algorithms are good at approximating the optimal solution (also theoretically optimal for multi-label submodular MRFs [19]), as evidenced by the comparison of [28] and by our experiments, they usually take much longer to converge to the optimal solution than max-flow-based techniques.

8 Experiments

We evaluated our algorithm on the problems of stereo correspondence estimation and image inpainting. For stereo correspondence estimation, we employed six instances from the Middlebury dataset [29, 30]: Tsukuba, Venus, Sawtooth, Map, Cones and Teddy, and one instance from the KITTI dataset [31] (see Fig. 9). For Tsukuba and Venus, we used the unary potentials of [32], and for all other stereo cases, those of [33]. For inpainting, we used the Penguin and House images employed in [32], and we used the same unary potentials as in [32]. In all the above cases, we used pairwise potentials that can be expressed as

[TABLE]

where, unless stated otherwise, the regularizer $\theta(\left|x_{i}-x_{j}\right|)$ is the quadratic function. Furthermore, we employed a 4-connected neighbourhood structure, in all our experiments.

We compare our results with two max-flow implementations: the BK algorithm [7] and Excesses Incremental Breadth First Search (EIBFS) [34] (which we ran on the Ishikawa graph), and three LP relaxation-based algorithms: Tree Reweighted Message Passing (TRWS) [10], Subgradient based Dual Decomposition (DDSG) [11] and the Adaptive Diminishing Smoothing algorithm (ADSal) [12]. For DDSG and ADSal, we used the Opengm [35] implementations. For the other algorithms, we employed the respective authors’ implementations.

In practice, we only ran the BK algorithm and EIBFS if the graph could be stored in RAM. Otherwise, we provide an estimate of their memory requirement. For LP relaxation-based methods, unless they converged, we ran the algorithms either for 10000 iterations, or for 50000 seconds, whichever occurred first. Note that the running times reported for our algorithm include graph construction. All our experiments were conducted on a 3.4 GHz i7-4770 CPU with 16 GB RAM.

The memory consumption and running times of the algorithms are provided in Table I. Altogether, our algorithm lets us solve much larger problems than the BK algorithm and EIBFS, and is an order of magnitude faster than state-of-the-art message-passing algorithms.

8.1 MEMF analysis

In this section, we empirically analyze various properties of our algorithm. First, note that, at each iteration, i.e., at each augmentation step, our algorithm performs more computation than standard max-flow. Therefore, we would like our algorithm to find short augmenting paths and to converge in fewer iterations than standard max-flow. Below, we analyze these two properties empirically.

In Fig. 10, we show the distribution of the lengths of the augmenting paths found by our algorithm for the Tsukuba stereo instance. Note that the median length is only 5. As a matter of fact, the maximum length observed over all our experiments was 1073 for the KITTI data. Nevertheless, even in that image, the median length was only 15. Note that, since our algorithm finds augmenting paths in the block-graph, the path lengths are not directly comparable to those found by other max-flow-based methods. In terms of number of augmentations, we found that our algorithm only required between 35% and 50% of the total number of augmentations of the BK algorithm.

Next, we fixed the number of labels but varied the image size and compare the running times of the max-flow algorithms, for Tsukuba and Penguin instances in Fig. 11(a), 11(b). Similarly, we fixed the image size but varied the number of labels and report the running times in Fig. 11(c), 11(d). By doing this, we try to estimate the empirical time complexity of our algorithm. Note that, similar to other max-flow algorithms, MEMF exhibited near-linear performance with respect to the image size and near-cubic performance with respect to the number of labels, in these experiments.

Finally, we report the percentage of time taken by each subroutine of our algorithm, for Tsukuba and Penguin instances in Fig. 12. Note that the individual time complexities of the subroutines compute_edges and block-graph are $\mathcal{O}(\ell^{3})$ and $\mathcal{O}(\ell^{2})$, respectively. Therefore, they become dominant when the number of labels is large, and hence the corresponding percentages of time are high, particularly for Penguin.

8.2 Minimizing Non-submodular MRFs

Since our algorithm can simply replace standard max-flow in Ishikawa-type graphs, we replaced the BK method with our MEMF procedure in the IRGC algorithm [6], which minimizes MRFs with some non-convex pairwise potentials (or regularizers) by iteratively building and solving an Ishikawa graph. This lets us tackle much larger non-submodular problems. In particular, we computed inpainting results on Penguin by using all $256$ labels, as opposed to the down-sampled label sets used in [6]. The results of the IRGC+expansion algorithm, with the BK method and with MEMF are summarized in Table II.

8.3 Robust Regularizer

Since robust regularizers are highly effective in computer vision, we tested our algorithm by choosing Huber loss function [36] as the regularizer,

[TABLE]

where $\delta$ is the Huber value. The results are summarized in Table III. In this experiment, the Huber value was set to 4 for Tsukuba, Venus and Sawtooth, 6 for Map, 20 for Cones and Teddy, 10 for KITTI and 25 for Penguin and House. Note that, the Ishikawa graph for a Huber regularizer is significantly smaller, i.e., the number of edges per variable pair is $\mathcal{O}(\delta\ell)$, instead of $\mathcal{O}(\ell^{2})$. Even in this case, our algorithm lets us solve much larger problems than the BK algorithm and EIBFS, and is an order of magnitude faster than state-of-the-art message-passing algorithms.

8.4 Parallelization

We parallelized our algorithm based on the dual-decomposition technique of [9] and evaluated on the same six stereo instances from the Middlebury dataset [29, 30]. The relative times $t_{m}/t_{s}$, where $t_{m}$ stands for the multi-thread time and $t_{s}$ for the single-thread one, are shown in Fig. 13 for two and four threads. In this experiment, for all problems, the image grid was split vertically into two and four equally-sized blocks, respectively. Note that this spliting strategy is fairly arbitrary, and may affect the performance of the multi-threaded algorithm. In fact finding better splits may itself be a possible future direction.

9 Conclusion

We have introduced a variant of the max-flow algorithm that can minimize multi-label submodular MRF energies optimally, while requiring much less storage. Furthermore, our experiments have shown that our algorithm is an order of magnitude faster than state-of-the-art methods. We therefore believe that our algorithm constitutes the method of choice to minimize Ishikwa type graphs when the complete graph cannot be stored in memory.

Appendix A Time Complexity Analysis of the Polynomial time

version of MEMF

Let us denote the Ishikawa graph with $\hat{\mathcal{G}}=(\hat{\mathcal{V}}\cup\{0,1\},\hat{\mathcal{E}})$ and the lower-graph with $\hat{\mathcal{G}}^{s}=(\hat{\mathcal{V}}\cup\{0,1\},\hat{\mathcal{E}}^{s})$666The superscript $s$ is used to restate the fact, that the lower-graph is a subgraph of the Ishikawa graph.. In this section, we denote the nodes with $u$, $v$, etc. Also the notation $u_{1}\leq u$ means, the node $u_{1}$ and $u$ are in the same column where $u_{1}$ is below $u$. Let $\hat{\mathcal{G}}^{s}_{f}$ denotes the residual graph of the lower-graph after the flow $f$ and similarly $\hat{\mathcal{E}}^{s}_{f}$ denotes the set of non-zero residual edges. Let $d_{f}(u,v)$ denotes the shortest path distance from $u$ to $v$ calculated by MEMF.

Lemma A.1**.**

If the MEMF algorithm is run on the Ishikawa graph $\hat{\mathcal{G}}=(\hat{\mathcal{V}}\cup\{0,1\},\hat{\mathcal{E}})$ with source [math] and terminal $1$, then for any node $v\in\hat{\mathcal{V}}$, the shortest path distance $d_{f}(0,v)$ in the residual lower-graph $\hat{\mathcal{G}}^{s}_{f}$ increases monotonically with each flow augmentation.

Proof.

We will suppose that for some node $v\in\hat{\mathcal{V}}$, there is a flow augmentation that causes the shortest path distance from [math] to $v$ to decrease, and then we will derive a contradiction. Let $f$ be the flow just before the first augmentation that decreases some shortest path distance, and let $f^{\prime}$ be the flow just afterward. Let $v$ be the node with the minimum $d_{f^{\prime}}(0,v)$ whose distance was decreased by the augmentation, so that $d_{f^{\prime}}(0,v)<d_{f}(0,v)$. Let $p=0\leadsto u\to v$ be a shortest path from [math] to $v$ in $\hat{\mathcal{G}}^{s}_{f^{\prime}}$, so that $(u,v)\in\hat{\mathcal{E}}^{s}_{f^{\prime}}$ and

[TABLE]

Because of how we chose $v$, we know that the distance of node $u$ from the source [math] did not decrease, i.e.,

[TABLE]

We claim that $(u,v)\notin\hat{\mathcal{E}}^{s}_{f}$. Why? If we had $(u,v)\in\hat{\mathcal{E}}^{s}_{f}$, then we would also have

[TABLE]

which contradicts our assumption that $d_{f^{\prime}}(0,v)<d_{f}(0,v)$. The above argument simply follows even if $(u,v)$ is an infinite capacity edge. Hence $(u,v)\notin\hat{\mathcal{E}}^{s}_{f}$.

How can we have $(u,v)\notin\hat{\mathcal{E}}^{s}_{f}$ and $(u,v)\in\hat{\mathcal{E}}^{s}_{f^{\prime}}$? Note that, in this case, $(u,v)$ cannot be an infinite capacity edge. There can be two reasons:

A new lowest edge $(u,v)$ is created due to the flow from $v$ to $u$. That means the augmentation must have increased the flow from $v$ to $u$. The MEMF algorithm always augments flow along shortest paths, and therefore the shortest path from [math] to $u$ in $\hat{\mathcal{G}}^{s}_{f}$ has $(v,u)$ as its last edge. Therefore,

[TABLE]

which contradicts our assumption that $d_{f^{\prime}}(0,v)<d_{f}(0,v)$. 2. 2.

A new edge $(u,v)$ is created due to a saturating flow from $u$ to $v_{1}$ for some $v_{1}<v$. The MEMF algorithm always augments flow along shortest paths, and therefore the shortest path from [math] to $v_{1}$ in $\hat{\mathcal{G}}^{s}_{f}$ has $(u,v_{1})$ as its last edge. Since $d_{f}(0,v)\leq d_{f}(0,v_{1})$, due to the upward infinite capacity edges, we have,

[TABLE]

which contradicts our assumption that $d_{f^{\prime}}(0,v)<d_{f}(0,v)$.

We conclude that our assumption that such a node $v$ exists is incorrect. ∎

The next theorem bounds the number of iterations of the MEMF algorithm.

Theorem A.1**.**

If the MEMF algorithm is run on the Ishikawa graph $\hat{\mathcal{G}}=(\hat{\mathcal{V}}\cup\{0,1\},\hat{\mathcal{E}})$ with source [math] and sink $1$, then the total number of augmentations performed by the algorithm is $\mathcal{O}(|\hat{\mathcal{V}}||\hat{\mathcal{E}}|)$.

Proof.

We say that an edge $(u,v)$ in a residual lower-graph $\hat{\mathcal{G}}^{s}_{f}$ is critical on an augmenting path $p$ if the residual capacity of $p$ is the residual capacity of $(u,v)$, i.e., if $c_{f}(p)=c_{f}(u,v)$. After we have augmented flow along an augmenting path, any critical edge on the path disappears from the residual graph. Moreover, at least one edge on any augmenting path must be critical. We will show that each of the $|\hat{\mathcal{E}}|$ edges can become critical at most $|\hat{\mathcal{V}}|/2+1$ times. Furthermore, note that, an infinite capacity edge cannot be critical at any point of the algorithm.

Let $u$ and $v$ be nodes in $\hat{\mathcal{V}}\cup\{0,1\}$ that are connected by an edge in $\hat{\mathcal{E}}^{s}$. Since augmenting paths are shortest paths, when $(u,v)$ is critical for the first time, we have

[TABLE]

Once the flow is augmented, the edge $(u,v)$ disappears from the residual graph. Since we maintain the lowest-cross-edge property, there cannot be an edge $(u,v_{1})$ in $\hat{\mathcal{G}}^{s}_{f}$ for some $v_{1}<v$. Therefore, the edge $(u,v)$ cannot reappear later on another augmenting path until after the flow from $u$ to $v_{1}$ for some $v_{1}\leq v$ is decreased, which occurs only if $(v_{1},u)$ appears on an augmenting path. If $f^{\prime}$ is the flow when this event occurs, then we have

[TABLE]

Since $d_{f^{\prime}}(0,v)\leq d_{f^{\prime}}(0,v_{1})$, due to the upward infinite capacity edges, and $d_{f}(0,v)\leq d_{f^{\prime}}(0,v)$ by Lemma A.1, we have

[TABLE]

Consequently, from the time $(u,v)$ becomes critical to the time when it next becomes critical, the distance of $u$ from the source increases by at least 2. The distance of $u$ from the source is initially at least 0. The intermediate nodes on a shortest path from [math] to $u$ cannot contain [math], $u$ or $1$ (since $(u,v)$ on an augmenting path implies that $u\neq 1$). Therefore, until $u$ becomes unreachable from the source, if ever, its distance is at most $|\hat{\mathcal{V}}|$. Thus, after the first time that $(u,v)$ becomes critical, it can become critical at most $|\hat{\mathcal{V}}|/2$ times more, for a total of $|\hat{\mathcal{V}}|/2+1$ times. Since there are $\mathcal{O}(|\hat{\mathcal{E}}|)$ pairs of nodes that can have an edge between them in a residual graph, the total number of critical edges during the entire execution of the MEMF algorithm is $\mathcal{O}(|\hat{\mathcal{V}}||\hat{\mathcal{E}}|)$. Each augmenting path has at least one critical edge, and hence the theorem follows. ∎

Appendix B Proof of Theorem 5.1

Theorem**.**

Given the set of Ishikawa graph parameters $\phi$, there is an augmenting path in the block-graph if and only if there exists an augmenting path in the Ishikawa graph.

Proof.

First, we will prove that, if there is an augmenting path in the block-graph, then there exists an augmenting path in the Ishikawa graph. It is clear that an augmenting path in the block-graph contains an edge from node 0 to a block and then a sequence of edges $B_{i:\gamma}\to B_{j:\delta}$ and finally an edge from a block to node 1. Note that an edge from node 0 to a block $B_{i:\gamma}$ corresponds to a positive edge $e_{i:\ell-1}$ in the Ishikawa graph; similarly an edge from a block $B_{j:\delta}$ to node 1 corresponds to a positive edge $e_{j:0}$. Now, consider an edge $B_{i:\gamma}\to B_{j:\delta}$ in the augmenting path. Corresponding to this, there exists a positive edge $e_{ij:\lambda\mu}$ such that $U_{i:\lambda}\in B_{i:\gamma^{\prime}}$ for some $\gamma^{\prime}\geq\gamma$ and $U_{j:\mu}\in B_{j:\delta}$ in the Ishikawa graph. Also along the column $i$, there are upward infinite capacity edges, and nodes corresponding to a block are also connected with positive bidirectional edges. Hence, there exists an augmenting path in the Ishikawa graph, corresponding to the augmenting path in the block-graph.

Now, we will prove the converse. Consider an augmenting path in the Ishikawa graph. The path may contain a sequence of positive edges $e_{i:\lambda}$, $e_{ij:\lambda\mu}$ and infinite capacity edges $e_{ii:\lambda\lambda+1}$. Note that, by construction, the $e_{i:\lambda}$ edges either will be in the same block $B_{i:\gamma}$ in the block-graph, or will be between a block and node 0 or node 1. Furthermore, the infinite capacity edges either will be in the same block, or there will be an edge $B_{i:\gamma}\to B_{j:\delta}$ in the block-graph to represent them. Finally, if $e_{ij:\lambda\mu}$ is a positive edge, then, by construction of the block-graph, there exists an edge $B_{i:\gamma}\to B_{j:\delta^{\prime}}$ where $U_{i:\lambda}\in B_{i:\gamma}$ and $U_{j:\mu}\in B_{j:\delta}$ with $\delta^{\prime}\leq\delta$. Hence, if there is an augmenting path in the Ishikawa graph, then there exists an augmenting path in the block-graph. ∎