Original: BILCO: An Efficient Algorithm for Joint Alignment of Time Series
Revised: BILCO: An Efficient Algorithm for Joint Alignment of Time Series

Original: Abstract
Revised: Abstract

Original: Multiple time series data occur in many real applications and the alignment among them is usually a fundamental step of data analysis.
Revised: Multiple time series data occur in many real applications and the alignment among them is usually a fundamental step of data analysis.

Original: Frequently, these multiple time series are inter-dependent, which provides extra information for the alignment task and this information cannot be well utilized in the conventional pairwise alignment methods.
Revised: Frequently, these multiple time series are inter-dependent, which provides extra information for the alignment task and this information cannot be well utilized in the conventional pairwise alignment methods.

Original: Recently, the joint alignment was modeled as a max-flow problem, in which both the profile similarity between the aligned time series and the distance between adjacent warping functions are jointly optimized.
Revised: Recently, the joint alignment was modeled as a max-flow problem, in which both the profile similarity between the aligned time series and the distance between adjacent warping functions are jointly optimized.

Original: However, despite the new model having elegant mathematical formulation and superior alignment accuracy, the long computation time and large memory usage, due to the use of the existing general-purpose max-flow algorithms, limit significantly its well-deserved wide use.
Revised: However, despite the new model having elegant mathematical formulation and superior alignment accuracy, the long computation time and large memory usage, due to the use of the existing general-purpose max-flow algorithms, limit significantly its well-deserved wide use.

Original: In this report, we present BIdirectional pushing with Linear Component
Revised: In this report, we present BIdirectional pushing with Linear Component

Original: Operations (BILCO), a novel algorithm that solves the joint alignment max-flow problems efficiently and exactly.
Revised: Operations (BILCO), a novel algorithm that solves the joint alignment max-flow problems efficiently and exactly.

Original: We develop the strategy of linear component operations that integrates dynamic programming technique and the push-relabel approach.
Revised: We develop the strategy of linear component operations that integrates dynamic programming technique and the push-relabel approach.

Original: This strategy is motivated by the fact that the joint alignment maxflow problem is a generalization of dynamic time warping (DTW) and numerous individual DTW problems are embedded.
Revised: This strategy is motivated by the fact that the joint alignment maxflow problem is a generalization of dynamic time warping (DTW) and numerous individual DTW problems are embedded.

Original: Further, a bidirectional-pushing strategy is proposed to introduce prior knowledge and reduce unnecessary computation, by leveraging another fact that good initialization can be easily computed for the joint alignment max-flow problem.
Revised: Further, a bidirectional-pushing strategy is proposed to introduce prior knowledge and reduce unnecessary computation, by leveraging another fact that good initialization can be easily computed for the joint alignment max-flow problem.

Original: We demonstrate the efficiency of BILCO using both synthetic and real experiments.
Revised: We demonstrate the efficiency of BILCO using both synthetic and real experiments.

Original: Tested on thousands of datasets under various simulated scenarios and in three distinct application categories, BILCO consistently achieves at least 10 and averagely 20-folds increase in speed, and uses at most 1/ and averagely 1/10 memory compared with the best existing max-flow method.
Revised: Tested on thousands of datasets under various simulated scenarios and in three distinct application categories, BILCO consistently achieves at least 10 and averagely 20-folds increase in speed, and uses at most 1/ and averagely 1/10 memory compared with the best existing max-flow method.

Original: Our source code can be found at https://github.com/yu-lab-vt/BILCO.
Revised: Our source code can be found at https://github.com/yu-lab-vt/BILCO.

Original:  Introduction
Revised:  Introduction

Original: Time series data appear naturally in a wide range of fields, such as motion capture, speech recognition, and bioinformatics.
Revised: Time series data appear naturally in a wide range of fields, such as motion capture, speech recognition, and bioinformatics.

Original: As sequences are usually not directly comparable due to possible delay and distortion, alignment among them is a prerequisite step before further analysis.
Revised: As sequences are usually not directly comparable due to possible delay and distortion, alignment among them is a prerequisite step before further analysis.

Original: The most popular alignment technique, dynamic time warping (DTW) [3], finds an optimal match between two sequences in linear time using dynamic programming (DP).
Revised: The most popular alignment technique, dynamic time warping (DTW) [3], finds an optimal match between two sequences in linear time using dynamic programming (DP).

Original: However, DTW and its variants [2, 15] only compare a single pair of time series, while real data often contain structural information.
Revised: However, DTW and its variants [2, 15] only compare a single pair of time series, while real data often contain structural information.

Original: For example, in time-lapse microscopy data, the pixel intensities are recorded over time in a 2D grid, and adjacent pixels tend to have similar temporal patterns.
Revised: For example, in time-lapse microscopy data, the pixel intensities are recorded over time in a 2D grid, and adjacent pixels tend to have similar temporal patterns.

Original: Thus, joint alignment of more than a single pair is expected to achieve better performance by taking advantage of dependency from the structure.
Revised: Thus, joint alignment of more than a single pair is expected to achieve better performance by taking advantage of dependency from the structure.

Original: For a long time it was not clear how to incorporate the structural information in a principled way.
Revised: For a long time it was not clear how to incorporate the structural information in a principled way.

Original: Various heuristic tricks were developed [13, 19].
Revised: Various heuristic tricks were developed [13, 19].

Original: In a recent theoretical breakthrough, the joint alignment problem was elegantly modeled as a max-flow problem of graphical time warping (GTW) graph by optimizing both the time series pairwise similarity and the distance between warping functions [22].
Revised: In a recent theoretical breakthrough, the joint alignment problem was elegantly modeled as a max-flow problem of graphical time warping (GTW) graph by optimizing both the time series pairwise similarity and the distance between warping functions [22].

Original: GTW was shown to have superior alignment accuracy in many applications, such as brain activity analysis [21] and liquid chromatography-mass spectrometry (LC-MS) proteomics [23], where warping functions represent the delay of the real signal at each time point relative to the reference time series and adjacent time series should propagate similarly.
Revised: GTW was shown to have superior alignment accuracy in many applications, such as brain activity analysis [21] and liquid chromatography-mass spectrometry (LC-MS) proteomics [23], where warping functions represent the delay of the real signal at each time point relative to the reference time series and adjacent time series should propagate similarly.

Original: The binocular stereo vision formulation in [11] is also a special case of GTW, where warping functions denote the depth information contained in two views and it is natural to assume the depths are close in adjacent positions.
Revised: The binocular stereo vision formulation in [11] is also a special case of GTW, where warping functions denote the depth information contained in two views and it is natural to assume the depths are close in adjacent positions.

Original: By adding penalties on warping function dissimilarity, GTW utilizes the structural information and could obtain better alignment performance, as shown in Fig.1(e)(f).
Revised: By adding penalties on warping function dissimilarity, GTW utilizes the structural information and could obtain better alignment performance, as shown in Fig.1(e)(f).

Original: However, the long computation time and large memory usage severely limit its potential broad applications, because GTW was solved by existing general-purpose max-flow algorithms and the graph is often huge.
Revised: However, the long computation time and large memory usage severely limit its potential broad applications, because GTW was solved by existing general-purpose max-flow algorithms and the graph is often huge.

Original: Indeed, for a typical dataset with 5000 pairs of time series, if each time series containstime points, all popular methods, such as incremental breadth-first search (IBFS) [8], Hochbaum’s pseudoflow (HPF)[10], Boykov-Kolmogorov (BK) max-flow [4, 12], and highest-label push-relabel (HIPR)
Revised: Indeed, for a typical dataset with 5000 pairs of time series, if each time series containstime points, all popular methods, such as incremental breadth-first search (IBFS) [8], Hochbaum’s pseudoflow (HPF)[10], Boykov-Kolmogorov (BK) max-flow [4, 12], and highest-label push-relabel (HIPR)

Original: [9, 5], cost hours and more than 100 gigabytes memory.
Revised: [9, 5], cost hours and more than 100 gigabytes memory.

Original: In this paper, we identify two important properties of the joint alignment max-flow problem and show that they can be leveraged to design a novel algorithm with improvements in both speed and memory efficiency.
Revised: In this paper, we identify two important properties of the joint alignment max-flow problem and show that they can be leveraged to design a novel algorithm with improvements in both speed and memory efficiency.

Original: Specifically, first, joint alignment is a generalization of pairwise alignment and numerous individual DTW problems are embedded, as shown in Fig.1(a)-(d).
Revised: Specifically, first, joint alignment is a generalization of pairwise alignment and numerous individual DTW problems are embedded, as shown in Fig.1(a)-(d).

Original: If the dependency is neglected, it is reduced to multiple independent DTW problems, which can be solved in linear time through DP.
Revised: If the dependency is neglected, it is reduced to multiple independent DTW problems, which can be solved in linear time through DP.

Original: Although the dependency makes the problem more complex, the property of the DTW problem can still be utilized.
Revised: Although the dependency makes the problem more complex, the property of the DTW problem can still be utilized.

Original: Second, a coarse approximate solution to joint alignment can be readily estimated in many applications.
Revised: Second, a coarse approximate solution to joint alignment can be readily estimated in many applications.

Original: Such prior knowledge can be incorporated to accelerate the max-flow algorithms.
Revised: Such prior knowledge can be incorporated to accelerate the max-flow algorithms.

Original: Taking advantage of these two properties, we develop BIdirectional pushing with Linear Component
Revised: Taking advantage of these two properties, we develop BIdirectional pushing with Linear Component

Original: Operations (BILCO), a novel algorithm that solves the joint alignment max-flow problem exactly and more efficiently.
Revised: Operations (BILCO), a novel algorithm that solves the joint alignment max-flow problem exactly and more efficiently.

Original: The algorithm consists of two major strategies: (a) By utilizing the first property, we propose Excess pushing with Linear Component Operations (ELCO) that integrates DP and the push-relabel approach [9].
Revised: The algorithm consists of two major strategies: (a) By utilizing the first property, we propose Excess pushing with Linear Component Operations (ELCO) that integrates DP and the push-relabel approach [9].

Original: Each component is defined as a small subgraph including connected nodes and their related edges.
Revised: Each component is defined as a small subgraph including connected nodes and their related edges.

Original: The components are automatically and adaptively determined.
Revised: The components are automatically and adaptively determined.

Original: We show that all operations on each component can be achieved in linear time by combining DP and subgraph properties.
Revised: We show that all operations on each component can be achieved in linear time by combining DP and subgraph properties.

Original: With linear component operations, ELCO can achieve higher efficiency than the generic push-relabel approach.
Revised: With linear component operations, ELCO can achieve higher efficiency than the generic push-relabel approach.

Original: (b) By leveraging the second property, we design a bidirectional-pushing strategy to utilize prior knowledge as initialization.
Revised: (b) By leveraging the second property, we design a bidirectional-pushing strategy to utilize prior knowledge as initialization.

Original: The strategy simplifies the original problem into two smaller sub-problems with opposite pushing directions.
Revised: The strategy simplifies the original problem into two smaller sub-problems with opposite pushing directions.

Original: In each sub-problem, ELCO is applied, but the separation of two pushing directions dramatically reduces unnecessary computation.
Revised: In each sub-problem, ELCO is applied, but the separation of two pushing directions dramatically reduces unnecessary computation.

Original: BILCO has the same theoretical time complexity as the best popular methods such as HIPR, but it provides a significant empirical efficiency boost without sacrificing the accuracy in the task of joint alignment.
Revised: BILCO has the same theoretical time complexity as the best popular methods such as HIPR, but it provides a significant empirical efficiency boost without sacrificing the accuracy in the task of joint alignment.

Original: Its effectiveness is evidenced through both synthetic and real experiments.
Revised: Its effectiveness is evidenced through both synthetic and real experiments.

Original: Compared with IBFS, HPF, BK, and HIPR on thousands of datasets under various simulated scenarios and three real applications in distinct categories, BILCO improves the speed by 10 - 50 folds and costs averagely 1 / 10 memory relative to the best peer method.
Revised: Compared with IBFS, HPF, BK, and HIPR on thousands of datasets under various simulated scenarios and three real applications in distinct categories, BILCO improves the speed by 10 - 50 folds and costs averagely 1 / 10 memory relative to the best peer method.

Original:  Problem formulation
Revised:  Problem formulation

Original: The joint alignment problem can be formulated as [22]:
Revised: The joint alignment problem can be formulated as [22]:

Original: [Equation]
Revised: [Equation]

Original: where P n denotes the warping path for the n th time series pair, N is the total number of time series pairs that are jointly aligned, cost ( P n ) is the alignment cost of the n th time series pair, dist ( P m , P n ) is the warping path distance defined by the area of the region bounded by P m and P n .
Revised: where P n denotes the warping path for the n th time series pair, N is the total number of time series pairs that are jointly aligned, cost ( P n ) is the alignment cost of the n th time series pair, dist ( P m , P n ) is the warping path distance defined by the area of the region bounded by P m and P n .

Original: Neib is the set of pair indices ( m, n ) representing the adjacent time series, and κ is the hyperparameter to balance the alignment cost term and the distance term.
Revised: Neib is the set of pair indices ( m, n ) representing the adjacent time series, and κ is the hyperparameter to balance the alignment cost term and the distance term.

Original: For example, for 2D grid time-series data, Neib may include the pair of neighboring pixels, and κ represents a prior similarity between the pixels.
Revised: For example, for 2D grid time-series data, Neib may include the pair of neighboring pixels, and κ represents a prior similarity between the pixels.

Original: As shown in Fig.1, Equation (1) can be converted to a flow network and solved by finding the min-cut of it.
Revised: As shown in Fig.1, Equation (1) can be converted to a flow network and solved by finding the min-cut of it.

Original: The constructed graph, GTW graph, consisting of N GTW subgraphs { G k =
Revised: The constructed graph, GTW graph, consists of N GTW subgraphs { G k =

Original: ( V k , E k ) | 1 ≤ n ≤ N } and cross edges E cross with capacity κ 2 (Fig.1(d)).
Revised: ( V k , E k ) | 1 ≤ n ≤ N } and cross edges E cross with capacity κ 2 (Fig.1(d)).

Original: The edges within GTW subgraph are called E within .
Revised: The edges within GTW subgraph are called E within .

Original: For convenience, in the following content, we refer to “GTW subgraph” as “subgraph”.
Revised: For convenience, in the following content, we refer to “GTW subgraph” as “subgraph”.

Original: Each subgraph G k is dual to a DTW graph, which represents the warping between a pair of time series.
Revised: Each subgraph G k is dual to a DTW graph, which represents the warping between a pair of time series.

Original: The cut within a subgraph is dual to a warping path of the time series pair [1] (Fig.1(b)-(c)), and thus the min-cut of one DTW graph can be solved in linear time through DP by finding the shortest path.
Revised: The cut within a subgraph is dual to a warping path of the time series pair [1] (Fig.1(b)-(c)), and thus the min-cut of one DTW graph can be solved in linear time through DP by finding the shortest path.

Original: The cross edges constrain the difference between cuts in neighboring subgraphs, corresponding to the distance term in Equation (1) (Fig.1(d)).
Revised: The cross edges constrain the difference between cuts in neighboring subgraphs, corresponding to the distance term in Equation (1) (Fig.1(d)).

Original: To ensure the monotonicity and continuity of warping paths, the capacities of reverse edges in each subgraph are set infinite [22].
Revised: To ensure the monotonicity and continuity of warping paths, the capacities of reverse edges in each subgraph are set infinite [22].

Original: It is worth noting that GTW framework is flexible, broadly applicable, and can be used as a building block in solving many problems while utilizing structural information.
Revised: It is worth noting that GTW framework is flexible, broadly applicable, and can be used as a building block in solving many problems while utilizing structural information.

Original: The assumed neighbor structure and similarity strength can be application-specific or user-designed.
Revised: The assumed neighbor structure and similarity strength can be application-specific or user-designed.

Original: For example, for different pairs of warping functions, GTW can set different hyperparameters κ .
Revised: For example, for different pairs of warping functions, GTW can set different hyperparameters κ .

Original: For simplicity, in this paper we use the same hyperparameter κ for all warping function pairs in the following.
Revised: For simplicity, in this paper we use the same hyperparameter κ for all warping function pairs in the following.

Original:  Method
Revised:  Method

Original: BILCO contains two major parts, ELCO and bidirectional pushing, as discussed in Sections 3.1 and 3.2, respectively.
Revised: BILCO contains two major parts, ELCO and bidirectional pushing, as discussed in Sections 3.1 and 3.2, respectively.

Original: Based on the initialization of warping functions, the bidirectional-pushing strategy converts a max-flow problem into two sub-problems and we solve each of them with ELCO.
Revised: Based on the initialization of warping functions, the bidirectional-pushing strategy converts a max-flow problem into two sub-problems and we solve each of them with ELCO.

Original: The integration leads to BILCO (Section 3.3), followed by the analysis of time complexity and memory usage in Section 3.4 and 3.5.
Revised: The integration leads to BILCO (Section 3.3), followed by the analysis of time complexity and memory usage in Section 3.4 and 3.5.

Original: All lemmas and theorems are proved in the supplementary.
Revised: All lemmas and theorems are proved in the supplementary.

Original: operation: water flows from an active component to a neighbor component in another water tank where water needs to concentrate at the connecting tube first.
Revised: operation: water flows from an active component to a neighbor component in another water tank where water needs to concentrate at the connecting tube first.

Original: (d) After (c), the previously inactive component in G 2 becomes active and water can be drained again.
Revised: (d) After (c), the previously inactive component in G 2 becomes active and water can be drained again.

Original: Due to the concentration step in (c), there is one new partition in G 1 that further segments it into three components
Revised: Due to the concentration step in (c), there is one new partition in G 1 that further segments it into three components

Original: (e) One intermediate stage of a tank, where multiple components are segmented in a subgraph and some tubes are blocked.
Revised: (e) One intermediate stage of a tank, where multiple components are segmented in a subgraph and some tubes are blocked.

Original: 3.1 Excess pushing with linear component operations (ELCO)
Revised: 3.1 Excess pushing with linear component operations (ELCO)

Original: Since GTW graph contains many subgraphs dual to DTW graphs and each DTW graph can be linearly solved by DP, we hope the DTW graph and DP algorithm can be exploited in our approach.
Revised: Since GTW graph contains many subgraphs dual to DTW graphs and each DTW graph can be linearly solved by DP, we hope the DTW graph and DP algorithm can be exploited in our approach.

Original: While the cross edges between subgraphs prohibit the direct use of DP, we found that the component as defined in Subsection 3.1.1 is the maximum subgraph that can allow the use of DP.
Revised: While the cross edges between subgraphs prohibit the direct use of DP, we found that the component as defined in Subsection 3.1.1 is the maximum subgraph that can allow the use of DP.

Original: By combining the newly designed graph conversion strategy (Fig.3) and DP, we establish that the operations on components, “Drain” and “Discharge” (defined in Subsections 3.1.1), can indeed be linearly implemented as in
Revised: By combining the newly designed graph conversion strategy (Fig.3) and DP, we establish that the operations on components, “Drain” and “Discharge” (defined in Subsections 3.1.1), can indeed be linearly implemented as in

Original: Subsections 3.1.2 and 3.1.3.
Revised: Subsections 3.1.2 and 3.1.3.

Original: To guarantee global optimality, we design a new labeling function as in
Revised: To guarantee global optimality, we design a new labeling function as in

Original: Subsection 3.1.4 and use that to guide our component operations.
Revised: Subsection 3.1.4 and use that to guide our component operations.

Original: 3.1.1 The basic unit of operation is component, not node or subgraph
Revised: 3.1.1 The basic unit of operation is component, not node or subgraph

Original: To exploit the property of each subgraph, ELCO borrows the idea from the generic push-relabel algorithm, whose operations are localized.
Revised: To exploit the property of each subgraph, ELCO borrows the idea from the generic push-relabel algorithm, whose operations are localized.

Original: ELCO allows the existence of excess, which is the surplus between the entering flow and outgoing flow of one node.
Revised: ELCO allows the existence of excess, which is the surplus between the entering flow and outgoing flow of one node.

Original: The nodes that carry excess are regarded as “active”.
Revised: The nodes that carry excess are regarded as “active”.

Original: Based on the location of flow exchanges, we define two operations, “Drain” and “Discharge”.
Revised: Based on the location of flow exchanges, we define two operations, “Drain” and “Discharge”.

Original: “Drain” pushes excess to the sink through E within , which is a within-subgraph operation.
Revised: “Drain” pushes excess to the sink through E within , which is a within-subgraph operation.

Original: While “Discharge” is a cross-subgraph operation that pushes excess to neighbor subgraphs through E cross .
Revised: While “Discharge” is a cross-subgraph operation that pushes excess to neighbor subgraphs through E cross .

Original: By alternatively executing these two operations, more and more excess can be sent to sink (Fig.2).
Revised: By alternatively executing these two operations, more and more excess can be sent to sink (Fig.2).

Original: The spread of excess leads to many edges being saturated, resulting in multiple cuts in the same subgraph.
Revised: The spread of excess leads to many edges being saturated, resulting in multiple cuts in the same subgraph.

Original: These cuts segment the subgraph into different components (Fig.2(e)).
Revised: These cuts segment the subgraph into different components (Fig.2(e)).

Original: Formally, we define one component as a subset of GTW subgraph bounded by two adjacent cuts.
Revised: Formally, we define one component as a subset of GTW subgraph bounded by two adjacent cuts.

Original: ELCO uses component, instead of node or subgraph, as the basic operation unit, because it is the largest possible unit to use
Revised: ELCO uses component, instead of node or subgraph, as the basic operation unit, because it is the largest possible unit to use

Original: DP to push flows.
Revised: DP to push flows.

Original: Lemma 1: If two nodes are in the same component, then there is at least one path linking them.
Revised: Lemma 1: If two nodes are in the same component, then there is at least one path linking them.

Original: By Lemma 1, if one node in a component is active, the excess can spread anywhere in the same component.
Revised: By Lemma 1, if one node in a component is active, the excess can spread anywhere in the same component.

Original: Thus, the whole component can be seen as one unit.
Revised: Thus, the whole component can be seen as one unit.

Original: On the contrary, cuts block the flow across components in the same subgraph, it is inapplicable to take a whole subgraph as one unit.
Revised: On the contrary, cuts block the flow across components in the same subgraph, it is inapplicable to take a whole subgraph as one unit.

Original: Using the component as the basic operation unit, ELCO can be described as follows:
Revised: Using the component as the basic operation unit, ELCO can be described as follows:

Original: Initially, each subgraph is one active component.
Revised: Initially, each subgraph is one active component.

Original: “Drain” operation sends maximum excess directly to the sink through E within .
Revised: “Drain” operation sends maximum excess directly to the sink through E within .

Original: A new cut will be generated, which blocks some excess in the segmented components near the source.
Revised: A new cut will be generated, which blocks some excess in the segmented components near the source.

Original: Then it is the turn of “Discharge” to seek opportunities to move excess across subgraph toward components that can execute “Drain”.
Revised: Then it is the turn of “Discharge” to seek opportunities to move excess across subgraph toward components that can execute “Drain”.

Original: By executing these two component operations alternatively, the global max-flow can be achieved.
Revised: By executing these two component operations alternatively, the global max-flow can be achieved.

Original: An illustrative example is shown in the supplementary.
Revised: An illustrative example is shown in the supplementary.

Original: In the following,
Revised: In the following,

Original: we will
Revised: we will

Original: “Drain” and “Discharge” operations can be implemented in linear time complexity.
Revised: “Drain” and “Discharge” operations can be implemented in linear time complexity.

Original: 3.1.2 Linear time implementation of "Drain" component operation
Revised: 3.1.2 Linear time implementation of "Drain" component operation

Original: Regarding “Drain” operation, we only need to calculate the min-cut of one active component that links to the sink, then all the excess above the new cut is drained and the part below the new cut is identified as a new active component (Fig.2(b)(c)).
Revised: Regarding “Drain” operation, we only need to calculate the min-cut of one active component that links to the sink, then all the excess above the new cut is drained and the part below the new cut is identified as a new active component (Fig.2(b)(c)).

Original: As mentioned, the min-cut can be quickly solved by DP on its dual graph.
Revised: As mentioned, the min-cut can be quickly solved by DP on its dual graph.

Original: However, with flows on E cross , DP cannot be applied directly.
Revised: However, with flows on E cross , DP cannot be applied directly.

Original: The graph is not planar anymore (Fig.3(a)(b)) and its dual graph does not exist.
Revised: The graph is not planar anymore (Fig.3(a)(b)) and its dual graph does not exist.

Original: Here we design a linear-time graph conversion strategy as shown in Fig.3 (see algorithms in the supplementary), which can incorporate known flows on E cross into E within and obtain an equivalent planar graph where DP can still be applied.
Revised: Here we design a linear-time graph conversion strategy as shown in Fig.3 (see algorithms in the supplementary), which can incorporate known flows on E cross into E within and obtain an equivalent planar graph where DP can still be applied.

Original: Combining linear conversion strategy with DP, the “Drain” component operation can be implemented in linear time.
Revised: Combining linear conversion strategy with DP, the “Drain” component operation can be implemented in linear time.

Original: Lemma 2: The corresponding cut values/path costs before and after graph conversion are the same.
Revised: Lemma 2: The corresponding cut values/path costs before and after graph conversion are the same.

Original: 3.1.3 Linear time implementation of "Discharge" component operation
Revised: 3.1.3 Linear time implementation of "Discharge" component operation

Original: To discharge one component, we try to push excess out on each node as much as possible to make sure the component has sent all the excess it can since excess can flow anywhere in the same component.
Revised: To discharge one component, we try to push excess out on each node as much as possible to make sure the component has sent all the excess it can since excess can flow anywhere in the same component.

Original: Lemma 3: The amount of maximum possible excess on node v is the min-cut value in residual graph by taking v as sink.
Revised: Lemma 3: The amount of maximum possible excess on node v is the min-cut value in residual graph by taking v as sink.

Original: Working on the modified DTW graph, DP can still be applied to calculate such excess by finding the difference between the shortest path below v and the shortest path of the whole graph.
Revised: Working on the modified DTW graph, DP can still be applied to calculate such excess by finding the difference between the shortest path below v and the shortest path of the whole graph.

Original: The difference can represent the min-cut value mentioned in Lemma 3.
Revised: The difference can represent the min-cut value mentioned in Lemma 3.

Original: To implement linear-complexity component discharge operation, here we use another layer of DP that reuses the stored dynamic matrices that save the shortest distance recursively.
Revised: To implement linear-complexity component discharge operation, here we use another layer of DP that reuses the stored dynamic matrices that save the shortest distance recursively.

Original: The detailed algorithm of “Discharge” is given in the supplementary.
Revised: The detailed algorithm of “Discharge” is given in the supplementary.

Original: 3.1.4 A new labeling function to guide excess approaching the sink across components
Revised: 3.1.4 A new labeling function to guide excess approaching the sink across components

Original: We design a new labeling function to guide excess approaching t across components from high label to low label.
Revised: We design a new labeling function to guide excess approaching t across components from high label to low label.

Original: Different from the one in generic push-relabel [9], our labeling function implies the distance from one component to sink rather than from the node.
Revised: Different from the one in generic push-relabel [9], our labeling function implies the distance from one component to sink rather than from the node.

Original: Since the cut blocks the connection of components in the same subgraph, only E cross is counted.
Revised: Since the cut blocks the connection of components in the same subgraph, only E cross is counted.

Original: Derived from such distance, we define our labeling function d : V → N to be valid if for all residual edges,
Revised: Derived from such distance, we define our labeling function d : V → N to be valid if for all residual edges,

Original: [Equation]
Revised: [Equation]

Original: With such definitions, we have,
Revised: With such definitions, we have,

Original: Lemma 4: All nodes in the same component have the same label.
Revised: Lemma 4: All nodes in the same component have the same label.

Original: Lemma 5: The new labeling function (2) is consistent with generic push-relabel labeling function if treating each component as one unit.
Revised: Lemma 5: The new labeling function (2) is consistent with generic push-relabel labeling function if treating each component as one unit.

Original: Algorithm
Revised: Algorithm

Original: R k
Revised: R k

Original: =
Revised: =

Original: G k , d ( R k )
Revised: G k , d ( R k )

Original: = 0 , cut =
Revised: = 0 , cut =

Original: Drain ( R k ) , Split ( R k , cut ) for k = 1 , 2 , ..., N ▷ Initialization while active region exists do
Revised: Drain ( R k ) , Split ( R k , cut ) for k = 1 , 2 , ..., N ▷ Initialization while active region exists do

Original: Pick active region with highest label, R i ▷ Highest-label selection rule
Revised: Pick active region with highest label, R i ▷ Highest-label selection rule

Original: if d ( R i ) = 0 then ▷ sink component cut =
Revised: if d ( R i ) = 0 then ▷ sink component cut =

Original: Drain ( R i ) , Split ( R i , cut )
Revised: Drain ( R i ) , Split ( R i , cut )

Original: ▷ First type operation and update else
Revised: ▷ First type operation and update else

Original: ▷ No direct edge linking to sink if ∃ R j that R i → R j and d ( R i ) =
Revised: ▷ No direct edge linking to sink if ∃ R j that R i → R j and d ( R i ) =

Original: d ( R j ) + 1 then cut =
Revised: d ( R j ) + 1 then cut =

Original: Discharge ( R i ) , Split ( R i , cut )
Revised: Discharge ( R i ) , Split ( R i , cut )

Original: ▷ Second type operation and update else
Revised: ▷ Second type operation and update else

Original: Relabel ( R i )
Revised: Relabel ( R i )

Original: ▷ Relabel
Revised: ▷ Relabel

Original: Gap-relabel heuristic ▷ Relabel may result in label gap end if end if end while
Revised: Gap-relabel heuristic ▷ Relabel may result in label gap end if end if end while

Original: Algorithm d minCross = min { d ( R j ) | R → R j , R j / ∈ G k } ▷ Lowest reachable label in neighbor subgraphs d minWithin = min { d ( R j ) | R → R j , R j ∈ G k } ▷ Lowest reachable label in same subgraph if d minCross < d minWithin then d ( R ) =
Revised: Algorithm d minCross = min { d ( R j ) | R → R j , R j / ∈ G k } ▷ Lowest reachable label in neighbor subgraphs d minWithin = min { d ( R j ) | R → R j , R j ∈ G k } ▷ Lowest reachable label in same subgraph if d minCross < d minWithin then d ( R ) =

Original: d minCross +else ▷ Consider the validity d ( R ) =
Revised: d minCross +else ▷ Consider the validity d ( R ) =

Original: d minWithin
Revised: d minWithin

Original: R = R (cid:83) { R j | R → R j , d ( R ) =
Revised: R = R (cid:83) { R j | R → R j , d ( R ) =

Original: d ( R j ) , R ∈
Revised: d ( R j ) , R ∈

Original: G
Revised: G

Original: k , R j ∈ G k } into R ▷ Merge
Revised: k , R j ∈ G k } into R ▷ Merge

Original: Relabel ( R ) end if
Revised: Relabel ( R ) end if

Original: Lemma 4 suggests that we can set the same label to one component and all the nodes in it.
Revised: Lemma 4 suggests that we can set the same label to one component and all the nodes in it.

Original: And lemma 5 implies that ELCO can be seen as an alternative push-relabel approach that uses component as the operation unit, and all the statements in the generic push-relabel approach [9] hold on the component level.
Revised: And lemma 5 implies that ELCO can be seen as an alternative push-relabel approach that uses component as the operation unit, and all the statements in the generic push-relabel approach [9] hold on the component level.

Original: Since the validity of the labeling function is maintained in ELCO (see the proof in supplementary), the optimal solution can be achieved in polynomial component operations.
Revised: Since the validity of the labeling function is maintained in ELCO (see the proof in supplementary), the optimal solution can be achieved in polynomial component operations.

Original: The ELCO is outlined in Algo.1 and Algo
Revised: The ELCO is outlined in Algo.1 and Algo

Original: 3.2 Bidirectional-pushing strategy
Revised: 3.2 Bidirectional-pushing strategy

Original: Generic push-relabel methods, and ELCO alike, attempts to push as much as excess to the sink.
Revised: Generic push-relabel methods, and ELCO alike, attempts to push as much as excess to the sink.

Original: If part of the excess fails to reach the sink due to the limited edge capacity, they need to be absorbed back by the source, which may take a long time and incur high computational cost.
Revised: If part of the excess fails to reach the sink due to the limited edge capacity, they need to be absorbed back by the source, which may take a long time and incur high computational cost.

Original: Since this part of excess can neither make an impact on the max-flow nor change the final cut, such computation is redundant.
Revised: Since this part of excess can neither make an impact on the max-flow nor change the final cut, such computation is redundant.

Original: ELCO reduces part of the redundancy within each component through linear component operations, but it cannot solve the problem across components, especially with large κ (large capacities of E cross ).
Revised: ELCO reduces part of the redundancy within each component through linear component operations, but it cannot solve the problem across components, especially with large κ (large capacities of E cross ).

Original: Under large κ , E within are easier to be saturated and components are more likely to be segmented into a smaller size.
Revised: Under large κ , E within are easier to be saturated and components are more likely to be segmented into a smaller size.

Original: Thus, the redundancy is hard to be reduced if we focus on each component alone.
Revised: Thus, the redundancy is hard to be reduced if we focus on each component alone.

Original: Consider an extreme case in which all nodes are divided into the source side V T according to the cut.
Revised: Consider an extreme case in which all nodes are divided into the source side V T according to the cut.

Original: All excess can then reach the sink and all push operations are not redundant.
Revised: All excess can then reach the sink and all push operations are not redundant.

Original: In the other extreme, all nodes belong to the source side V S .
Revised: In the other extreme, all nodes belong to the source side V S .

Original: Most excess cannot reach the sink but is still pushed, leading to redundant computation.
Revised: Most excess cannot reach the sink but is still pushed, leading to redundant computation.

Original: Reversely, rather than pushing excess from the source, a better strategy is pushing deficit from the sink.
Revised: Reversely, rather than pushing excess from the source, a better strategy is pushing deficit from the sink.

Original: Deficit means input flow is less than output flow.
Revised: Deficit means input flow is less than output flow.

Original: Pushing deficit is just pushing excess in a graph with source and sink switched.
Revised: Pushing deficit is just pushing excess in a graph with source and sink switched.

Original: Since all nodes are divided into
Revised: Since all nodes are divided into

Original: V S , all operations for pushing deficit in the opposite direction are not redundant.
Revised: V S , all operations for pushing deficit in the opposite direction are not redundant.

Original: In conclusion, pushing excess in the sink side V T or pushing deficit in the source side V S will not result in invalid computation.
Revised: In conclusion, pushing excess in the sink side V T or pushing deficit in the source side V S will not result in invalid computation.

Original: If prior knowledge is available to guide us to find an initialization of warping paths, we only need to push excess on the sink side and deficit on the source side.
Revised: If prior knowledge is available to guide us to find an initialization of warping paths, we only need to push excess on the sink side and deficit on the source side.

Original: After that, little computation would be wasted.
Revised: After that, little computation would be wasted.

Original: This idea motivates us to design the bidirectional-pushing strategy (Fig.4):
Revised: This idea motivates us to design the bidirectional-pushing strategy (Fig.4):

Original: • Initialization: Estimate initial cut C 0 for GTW graph.
Revised: • Initialization: Estimate initial cut C 0 for GTW graph.

Original: The corresponding source side and sink side are denoted as V S 

Revised: The corresponding source side and sink side are denoted as V S

Original: and V T 0 , respectively.
Revised: and V T 0 , respectively.

Original: • Push excess: Replace all the nodes in V S 0 by source, solve the max-flow problem by pushing excess.
Revised: • Push excess: Replace all the nodes in V S 0 by source, solve the max-flow problem by pushing excess.

Original: The new sink side segmented by the new min-cut C 1 is denoted as V T 1 .
Revised: The new sink side segmented by the new min-cut C 1 is denoted as V T 1 .

Original: • Push deficit: Replace all the nodes in V T 1 by sink, solve the max-flow problem by pushing deficit.
Revised: • Push deficit: Replace all the nodes in V T 1 by sink, solve the max-flow problem by pushing deficit.

Original: The obtained min-cut C 2 is the min-cut of the original GTW graph.
Revised: The obtained min-cut C 2 is the min-cut of the original GTW graph.

Original: The strategy is guaranteed to achieve an optimal solution by the following statements:
Revised: The strategy is guaranteed to achieve an optimal solution by the following statements:

Original: Lemma 6: Assume the min-cut segments the nodes V into source side V S and sink side V T , then replacing the nodes in V S or V T by source or sink does not impact the min-cut.
Revised: Lemma 6: Assume the min-cut segments the nodes V into source side V S and sink side V T , then replacing the nodes in V S or V T by source or sink does not impact the min-cut.

Original: Lemma 7: Assume V T represents the nodes of sink side segmented by the real min-cut of original
Revised: Lemma 7: Assume V T represents the nodes of sink side segmented by the real min-cut of original

Original: GTW graph, then V T 1 ⊆ V T .
Revised: GTW graph, then V T 1 ⊆ V T .

Original: Theorem 1: The obtained min-cut in bidirectional strategy is the min-cut of the original graph.
Revised: Theorem 1: The obtained min-cut in bidirectional strategy is the min-cut of the original graph.

Original: In joint alignment problem, since the final cuts tend to be similar because larger κ brings larger similarity penalty, a good initialization is easy to be found.
Revised: In joint alignment problem, since the final cuts tend to be similar because larger κ brings larger similarity penalty, a good initialization is easy to be found.

Original: 3.3 Bidirectional pushing with linear component operations
Revised: 3.3 Bidirectional pushing with linear component operations

Original: We propose BILCO as the top-level algorithm integrating ELCO and the bidirectional-pushing strategy, its source code can be found at https://github.com/yu-lab-vt/BILCO.
Revised: We propose BILCO as the top-level algorithm integrating ELCO and the bidirectional-pushing strategy, its source code can be found at https://github.com/yu-lab-vt/BILCO.

Original: Under small κ , the component is usually large so that ELCO can work efficiently.
Revised: Under small κ , the component is usually large so that ELCO can work efficiently.

Original: While under large κ , the cuts in different subgraphs are similar and the initial solution can be easily estimated.
Revised: While under large κ , the cuts in different subgraphs are similar and the initial solution can be easily estimated.

Original: Therefore, the bidirectional-pushing strategy works well.
Revised: Therefore, the bidirectional-pushing strategy works well.

Original: By setting initialization on each subgraph as the optimal warping path of the averaged subgraph, which is also the solution of joint alignment with infinite κ , BILCO could take both advantages and has a good performance under any κ .
Revised: By setting initialization on each subgraph as the optimal warping path of the averaged subgraph, which is also the solution of joint alignment with infinite κ , BILCO could take both advantages and has a good performance under any κ .

Original: We use such initialization in our experiments and get good performance.
Revised: We use such initialization in our experiments and get good performance.

Original: Therefore, we recommend it as the default setting for BILCO, at least for similar applications.
Revised: Therefore, we recommend it as the default setting for BILCO, at least for similar applications.

Original: 3.4 Complexity
Revised: 3.4 Complexity

Original: Bidirectional-pushing strategy can convert the original problem into two smaller sub-problems, which may help accelerate any max-flow methods.
Revised: Bidirectional-pushing strategy can convert the original problem into two smaller sub-problems, which may help accelerate any max-flow methods.

Original: For example, in the best case, the initialization is accurate and divides the problem into two half-size sub-problems.
Revised: For example, in the best case, the initialization is accurate and divides the problem into two half-size sub-problems.

Original: Then the speed for one O ( | V | 2 (cid:112)
Revised: Then the speed for one O ( | V | 2 (cid:112)

Original: | E | ) method may be accelerated nearly 3 times since both | V | and | E | are halved.
Revised: | E | ) method may be accelerated nearly 3 times since both | V | and | E | are halved.

Original: Even with a bad initialization, the strategy can only increase the operation number without impacting the complexity bound.
Revised: Even with a bad initialization, the strategy can only increase the operation number without impacting the complexity bound.

Original: ELCO is somehow like the integration of DTW (with complexity Θ( | V | ) ) and HIPR (with complexity
Revised: ELCO is somehow like the integration of DTW (with complexity Θ( | V | ) ) and HIPR (with complexity

Original: O ( | V | 2 (cid:112)
Revised: O ( | V | 2 (cid:112)

Original: | E | ) [5]).
Revised: | E | ) [5]).

Original: On one hand, E cross makes ELCO more complex than DTW, thus it has a lower bound Ω( | V | ) .
Revised: On one hand, E cross makes ELCO more complex than DTW, thus it has a lower bound Ω( | V | ) .

Original: On the other hand, using linear component operations to push excess, ELCO has fewer operation units and less complexity than HIPR.
Revised: On the other hand, using linear component operations to push excess, ELCO has fewer operation units and less complexity than HIPR.

Original: Even in the worst case where each component contains only one node, ELCO is still equivalent to HIPR with the same upper bound.
Revised: Even in the worst case where each component contains only one node, ELCO is still equivalent to HIPR with the same upper bound.

Original: Therefore, the worst complexity of BILCO is O ( | V | 2 (cid:112) | E | ) .
Revised: Therefore, the worst complexity of BILCO is O ( | V | 2 (cid:112) | E | ) .

Original: 3.5 Memory usage
Revised: 3.5 Memory usage

Original: BILCO can also improve memory efficiency by utilizing the structure of GTW graph.
Revised: BILCO can also improve memory efficiency by utilizing the structure of GTW graph.

Original: In general max-flow methods, the majority of memory is used to record the relationship between nodes and edges.
Revised: In general max-flow methods, the majority of memory is used to record the relationship between nodes and edges.

Original: With a known graph structure, BILCO stores nodes and edges in coordinate order so that the relationship can be derived from their positions.
Revised: With a known graph structure, BILCO stores nodes and edges in coordinate order so that the relationship can be derived from their positions.

Original: The expense for storing components is insignificant in real applications since the component number is usually neglectable compared with large | V | and | E | .
Revised: The expense for storing components is insignificant in real applications since the component number is usually neglectable compared with large | V | and | E | .

Original: Table 1 compares the memory usage of BILCO and peer methods based on their implementation.
Revised: Table 1 compares the memory usage of BILCO and peer methods based on their implementation.

Original: [Table]
Revised: [Table]

Original:  Experiments
Revised:  Experiments

Original: In this section, we compare the efficiency of BILCO with four peer methods IBFS, HPF, BK, and
Revised: In this section, we compare the efficiency of BILCO with four peer methods IBFS, HPF, BK, and

Original: HIPR under synthetic simulation and real applications.
Revised: HIPR under synthetic simulation and real applications.

Original: All experiments were conducted in MATLAB with Intel(R)
Revised: All experiments were conducted in MATLAB with Intel(R)

Original: Xeon(R)
Revised: Xeon(R)

Original: Gold 6140@2.30Hz, 128GB memory, Windows 10 64-bit, and Microsoft
Revised: Gold 6140@2.30Hz, 128GB memory, Windows 10 64-bit, and Microsoft

Original: VC++ compiler.
Revised: VC++ compiler.

Original: No GPU is used.
Revised: No GPU is used.

Original: All methods are implemented in C/C++ with MATLAB wrapper.
Revised: All methods are implemented in C/C++ with MATLAB wrapper.

Original: 4.1 Synthetic data
Revised: 4.1 Synthetic data

Original: Following a similar scheme in [22], we simulated an image signal propagation dataset with varying pixels ( N ) and frames ( T ).
Revised: Following a similar scheme in [22], we simulated an image signal propagation dataset with varying pixels ( N ) and frames ( T ).

Original: 4-connected neighbors are used and thus the GTW graph has around | V | = 2 NT 2 nodes and | E | = 7 NT 2 edges.
Revised: 4-connected neighbors are used and thus the GTW graph has around | V | = 2 NT 2 nodes and | E | = 7 NT 2 edges.

Original: A bell-shaped signal propagated from the center of the image to the boundary.
Revised: A bell-shaped signal propagated from the center of the image to the boundary.

Original: Gaussian noise was added so that the signal-to-noise ratio is 10dB, which mimics a real scenario.
Revised: Gaussian noise was added so that the signal-to-noise ratio is 10dB, which mimics a real scenario.

Original: To make hyperparameter κ comparable, we normalized the synthetic data by dividing the standard deviation of the noise.
Revised: To make hyperparameter κ comparable, we normalized the synthetic data by dividing the standard deviation of the noise.

Original: We tested 20 instances for each combination of N , T , and κ .
Revised: We tested 20 instances for each combination of N , T , and κ .

Original: Fig.5 (a-d) compares BILCO and peer methods under different graph sizes, where BILCO is at least 10 times faster than any peer method and costs only 1 / 10 memory.
Revised: Fig.5 (a-d) compares BILCO and peer methods under different graph sizes, where BILCO is at least 10 times faster than any peer method and costs only 1 / 10 memory.

Original: The impact of hyperparameter κ is demonstrated in Fig.5 (e), where HIPR combined with our bidirectional-pushing strategy (BI-HIPR) and ELCO method are also compared.
Revised: The impact of hyperparameter κ is demonstrated in Fig.5 (e), where HIPR combined with our bidirectional-pushing strategy (BI-HIPR) and ELCO method are also compared.

Original: As shown, the running time of the majority of the methods
Revised: As shown, the running time of the majority of the methods

Original: [Table]
Revised: [Table]

Original: grows as κ becomes larger, because larger capacities of E cross give more freedom to exchange flow and make the graph more complex.
Revised: grows as κ becomes larger, because larger capacities of E cross give more freedom to exchange flow and make the graph more complex.

Original: Among all methods, BILCO shows the best efficiency under any κ .
Revised: Among all methods, BILCO shows the best efficiency under any κ .

Original: By comparing ELCO with BILCO, or HIPR with BI-HIPR, we find that the bidirectional-pushing strategy speeds up both methods, especially under large κ .
Revised: By comparing ELCO with BILCO, or HIPR with BI-HIPR, we find that the bidirectional-pushing strategy speeds up both methods, especially under large κ .

Original: It’s because the default initialization in Section 3.3 gets closer to the optimal solution when κ gets larger, which effectively removes unnecessary computation.
Revised: It’s because the default initialization in Section 3.3 gets closer to the optimal solution when κ gets larger, which effectively removes unnecessary computation.

Original: Fig.5(e) also shows that the two strategies, ELCO and bidirectional pushing are complementary and synergistic.
Revised: Fig.5(e) also shows that the two strategies, ELCO and bidirectional pushing are complementary and synergistic.

Original: When κ is small, ELCO dominates the acceleration.
Revised: When κ is small, ELCO dominates the acceleration.

Original: When κ is large, the bidirectional pushing makes a bigger impact.
Revised: When κ is large, the bidirectional pushing makes a bigger impact.

Original: Interestingly, the two strategies synergistically improve the speed for the large κ .
Revised: Interestingly, the two strategies synergistically improve the speed for the large κ .

Original: For example, under the largest κ , both BI-HIPR and ELCO are nearly 4 times faster than HIPR, suggesting a speedup of 16 folds for independent effects, while
Revised: For example, under the largest κ , both BI-HIPR and ELCO are nearly 4 times faster than HIPR, suggesting a speedup of 16 folds for independent effects, while

Original: BILCO shows around 100 -fold speedup compared to HIPR.
Revised: BILCO shows around 100 -fold speedup compared to HIPR.

Original: 4.2 Real data
Revised: 4.2 Real data

Original: Here we compare our BILCO with four peer methods in three distinct application categories: calculating signal propagation [21], extracting depth information [11], and signature identification [13].
Revised: Here we compare our BILCO with four peer methods in three distinct application categories: calculating signal propagation [21], extracting depth information [11], and signature identification [13].

Original: Since all these max-flow methods would give the same results, here we only compare running time and memory usage, as shown in Table.
Revised: Since all these max-flow methods would give the same results, here we only compare running time and memory usage, as shown in Table.

Original: 2, where ∗ in the name represents the spatially downsampled data.
Revised: 2, where ∗ in the name represents the spatially downsampled data.

Original: BILCO is used as the baseline and we show how many times others cost.
Revised: BILCO is used as the baseline and we show how many times others cost.

Original: The first application is similar to the one in Section 4.1 and we won’t go into detail here.
Revised: The first application is similar to the one in Section 4.1 and we won’t go into detail here.

Original: In the second application, the depth can be derived from the misalignment of the same row between two images, while the depth distributions in adjacent rows are assumed to be similar.
Revised: In the second application, the depth can be derived from the misalignment of the same row between two images, while the depth distributions in adjacent rows are assumed to be similar.

Original: To avoid unnecessary computation while allowing relatively large disparity, we set a window size with 1 / 5 sequence length in this experiment.
Revised: To avoid unnecessary computation while allowing relatively large disparity, we set a window size with 1 / 5 sequence length in this experiment.

Original: In the third application, 20 persons’ signatures [14] are identified where totally 500 real signatures and 500 forgeries are compared with the reference signature.
Revised: In the third application, 20 persons’ signatures [14] are identified where totally 500 real signatures and 500 forgeries are compared with the reference signature.

Original: Smoothness is imposed on the feature sequences of the same signature, and in the table we show the summation of running time and maximum memory usage for two signature categories.
Revised: Smoothness is imposed on the feature sequences of the same signature, and in the table we show the summation of running time and maximum memory usage for two signature categories.

Original: The detailed preprocessing steps and experiment settings are given in the supplementary.
Revised: The detailed preprocessing steps and experiment settings are given in the supplementary.

Original: As shown, BILCO always performs best for all these joint alignment applications.
Revised: As shown, BILCO always performs best for all these joint alignment applications.

Original: It shows around 10 to 50 times speed improvement and only costs nearly 1 / 10 memory compared with the best peer method.
Revised: It shows around 10 to 50 times speed improvement and only costs nearly 1 / 10 memory compared with the best peer method.

Original: Especially for the application of estimating signal propagation, BILCO performs averagely 29 times (range from 18 to 50 ) faster than other methods.
Revised: Especially for the application of estimating signal propagation, BILCO performs averagely 29 times (range from 18 to 50 ) faster than other methods.

Original: Considering these applications are diverse and the dependency structures are various from 2-connected neighbors for depth, 4-connected neighbors for propagation, to all-connected neighbors for signature, this forcefully demonstrates the superiority and broad applicability of BILCO.
Revised: Considering these applications are diverse and the dependency structures are various from 2-connected neighbors for depth, 4-connected neighbors for propagation, to all-connected neighbors for signature, this forcefully demonstrates the superiority and broad applicability of BILCO.

Original:  Conclusion and discussion
Revised:  Conclusion and discussion

Original: Compared with DTW, joint alignment utilizes the dependency in the data and could obtain better performance, however, at the expense of speed and memory.
Revised: Compared with DTW, joint alignment utilizes the dependency in the data and could obtain better performance, however, at the expense of speed and memory.

Original: In this paper, we developed BILCO algorithm to minimize such an expense by exploiting the special properties of the problem.
Revised: In this paper, we developed BILCO algorithm to minimize such an expense by exploiting the special properties of the problem.

Original: It can efficiently solve joint alignment max-flow problems and get exactly the global optimal solution without sacrificing accuracy.
Revised: It can efficiently solve joint alignment max-flow problems and get exactly the global optimal solution without sacrificing accuracy.

Original: Besides theoretical analysis, we demonstrated the efficiency of BILCO through both synthetic experiments and real applications, where BILCO showed around 10 to 50 times speed improvement and only cost averagely 1 / 10 memory compared with the best one among peer methods IBFS, HPF, BK, and HIPR.
Revised: Besides theoretical analysis, we demonstrated the efficiency of BILCO through both synthetic experiments and real applications, where BILCO showed around 10 to 50 times speed improvement and only cost averagely 1 / 10 memory compared with the best one among peer methods IBFS, HPF, BK, and HIPR.

Original: The testing was conducted on a wide range of scenarios, suggesting the broad applicability of BILCO.
Revised: The testing was conducted on a wide range of scenarios, suggesting the broad applicability of BILCO.

Original: We expect our work could facilitate greatly the application of joint alignment and help obtain better performance in different fields.
Revised: We expect our work could facilitate greatly the application of joint alignment and help obtain better performance in different fields.

Original: We observed that the bidirectional-pushing strategy can not only be regarded as a general push-relabel acceleration trick but also work synergistically with linear component operations for BILCO.
Revised: We observed that the bidirectional-pushing strategy can not only be regarded as a general push-relabel acceleration trick but also work synergistically with linear component operations for BILCO.

Original: Because of the bidirectional strategy, the graph is separated so that the less unnecessary excess or deficit needs to be pushed, the fewer saturated edges and cuts appear, and then the larger components will be.
Revised: Because of the bidirectional strategy, the graph is separated so that the less unnecessary excess or deficit needs to be pushed, the fewer saturated edges and cuts appear, and then the larger components will be.

Original: With larger components, the number of operations can be reduced greatly, which makes BILCO even faster (100 × ) than the multiplication of BI-HIPR (4 × ) and ELCO (4 × ) when compared to HIPR as mentioned in Section 4.1.
Revised: With larger components, the number of operations can be reduced greatly, which makes BILCO even faster (100 × ) than the multiplication of BI-HIPR (4 × ) and ELCO (4 × ) when compared to HIPR as mentioned in Section 4.1.

Original: Our BILCO algorithm is a specialized approach to a specific max-flow problem.
Revised: Our BILCO algorithm is a specialized approach to a specific max-flow problem.

Original: While inventing max-flow algorithms has a long history, all the existing methods fail to solve our problem efficiently, no matter whether they are based on augmenting path [4, 12, 8], localized operations as in pushrelabel [9, 5], the combination of the two [17, 7], or integrating graph decomposition [18, 6, 17].
Revised: While inventing max-flow algorithms has a long history, all the existing methods fail to solve our problem efficiently, no matter whether they are based on augmenting path [4, 12, 8], localized operations as in pushrelabel [9, 5], the combination of the two [17, 7], or integrating graph decomposition [18, 6, 17].

Original: To the best of our knowledge, we are the first of integrating DP and the generic push-relabel method to solve max-flow problems.
Revised: To the best of our knowledge, we are the first of integrating DP and the generic push-relabel method to solve max-flow problems.

Original: Although there is a general feeling in the field that initialization does not help much for max-flow algorithms, we showed bidirectional pushing is a good strategy to leverage initialization and it is particularly powerful when coupled with linear component operations.
Revised: Although there is a general feeling in the field that initialization does not help much for max-flow algorithms, we showed bidirectional pushing is a good strategy to leverage initialization and it is particularly powerful when coupled with linear component operations.

Original: We hope our efforts here will be not only useful for the application of joint alignment but also inspiring for the methodology development of specific network flow problems.
Revised: We hope our efforts here will be not only useful for the application of joint alignment but also inspiring for the methodology development of specific network flow problems.

Original: We have a general sense that while it is hard to invent better generic algorithms for classical problems, there are a lot of opportunities for more specialized problems and indeed great demands due to the super large scale of recent problems.
Revised: We have a general sense that while it is hard to invent better generic algorithms for classical problems, there are a lot of opportunities for more specialized problems and indeed great demands due to the super large scale of recent problems.

Original: Acknowledgments and Disclosure of Funding
Revised: Acknowledgments and Disclosure of Funding

Original: We thank the anonymous reviewers for their helpful suggestions.
Revised: We thank the anonymous reviewers for their helpful suggestions.

Original: This work was supported by grants
Revised: This work was supported by grants

Original: NIH R01MH110504, U19NS123719, and NSF 1750931.
Revised: NIH R01MH110504, U19NS123719, and NSF 1750931.

Original: Checklist
Revised: Checklist

Original: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contribu- tions and scope?
Revised: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contribu- tions and scope?

Original: [Yes] (b) Did you describe the limitations of your work?
Revised: [Yes] (b) Did you describe the limitations of your work?

Original: [Yes] See Section(c)
Revised: [Yes] See Section(c)

Original: Did you discuss any potential negative societal impacts of your work?
Revised: Did you discuss any potential negative societal impacts of your work?

Original: [No] Not applicable (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
Revised: [No] Not applicable (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?

Original: [Yes] 2.
Revised: [Yes] 2.

Original: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
Revised: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?

Original: [Yes] See Section(b)
Revised: [Yes] See Section(b)

Original: Did you include complete proofs of all theoretical results?
Revised: Did you include complete proofs of all theoretical results?

Original: [Yes] All given in supplementary due to the space limitation.
Revised: [Yes] All given in supplementary due to the space limitation.

Original: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
Revised: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] See supplemental material (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
Revised: [Yes] See supplemental material (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?

Original: [Yes] See the default hyperparameter setting in supplementary (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
Revised: [Yes] See the default hyperparameter setting in supplementary (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?

Original: [Yes] See Fig.
Revised: [Yes] See Fig.

Original: (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
Revised: (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?

Original: [Yes] See Section4.
Revised: [Yes] See Section4.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] (b) Did you mention the license of the assets?
Revised: [Yes] (b) Did you mention the license of the assets?

Original: [No] All referenced methods are public.
Revised: [No] All referenced methods are public.

Original: Part of the data are obtained from the coauthor, part of the data are public and cited.
Revised: Part of the data are obtained from the coauthor, part of the data are public and cited.

Original: (c) Did you include any new assets either in the supplemental material or as a URL?
Revised: (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [Yes] Our code of new method is given through in supplemental material.
Revised: [Yes] Our code of new method is given through in supplemental material.

Original: (d) Did you discuss whether and how consent was obtained from people whose data you’re us- ing/curating?
Revised: (d) Did you discuss whether and how consent was obtained from people whose data you’re us- ing/curating?

Original: [No] Part of the data are obtained from the coauthor, part of the data are public and cited.
Revised: [No] Part of the data are obtained from the coauthor, part of the data are public and cited.

Original: (e) Did you discuss whether the data you are using/curating contains personally identifiable informa- tion or offensive content?
Revised: (e) Did you discuss whether the data you are using/curating contains personally identifiable informa- tion or offensive content?

Original: [No] The data does not contain personally identifiable information or offensive content.
Revised: [No] The data does not contain personally identifiable information or offensive content.

Original: If you used crowd sourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
Revised: If you used crowd sourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

Original: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
Revised: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
Revised: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?

Original: [N/A]
Revised: [N/A]