Original: A H IGHER P RECISION A LGORITHM FOR C OMPUTING THE 1 -W ASSERSTEIN D ISTANCE
Revised: A H IGHER P RECISION A LGORITHM FOR C OMPUTING THE 1 -W ASSERSTEIN D ISTANCE

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We consider the problem of computing the 1 -Wasserstein distance W ( µ, ν ) between two d -dimensional discrete distributions µ and ν that are within the unit hypercube.
Revised: We consider the problem of computing the 1 -Wasserstein distance W ( µ, ν ) between two d -dimensional discrete distributions µ and ν that are within the unit hypercube.

Original: Let A (resp.
Revised: Let A (resp.

Original: B ) be the support of µ (resp.
Revised: B ) be the support of µ (resp.

Original: ν ).
Revised: ν ).

Original: There are several algorithms that estimate W ( µ, ν ) within an additive factor of ε .
Revised: There are several algorithms that estimate W ( µ, ν ) within an additive error of ε .

Original: However, when W ( µ, ν ) is small, the additive error ε dominates leading to noisy results.
Revised: However, when W ( µ, ν ) is small, the additive error ε dominates, leading to noisy results.

Original: Consider any additive approximation algorithm with execution time T ( n, ε ) .
Revised: Consider any additive approximation algorithm with execution time T ( n, ε ) .

Original: We propose an algorithm that runs in O
Revised: We propose an algorithm that runs in O

Original: ( T ( n, ε/d ) log n ) time and boosts the accuracy of estimating W ( µ, ν )  to an  additive factor of min { ε, ( d log √ d/ε n ) W ( µ, ν ) } .
Revised: ( T ( n, ε/d ) log n ) time and boosts the accuracy of estimating W ( µ, ν ) from ε to an expected additive error of min { ε, ( d log √ d/ε n ) W ( µ, ν ) } .

Original: For the special case where every point in A ∪ B has a mass of 1 /n (also called the Euclidean Bipartite Matching problem) we describe an algorithm to boost the accuracy of any additive approximation algorithm  to  min { ε, ( d log log n ) W ( µ, ν ) } in
Revised: For the special case where every point in A ∪ B has a mass of 1 /n (also called the Euclidean Bipartite Matching problem), we describe an algorithm to boost the accuracy of any additive approximation algorithm from ε to an expected additive error of min { ε, ( d log log n ) W ( µ, ν ) } in

Original: O ( T ( n, ε/d ) log log n ) time.
Revised: O ( T ( n, ε/d ) log log n ) time.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Given two discrete probability distributions µ (with support A ) and ν (with support B ) inside a d -dimensional unit hypercube in the Euclidean space with max {| A | , | B |} = n , the 1 -Wasserstein distance W ( µ, ν ) (also called the Earth Mover’s distance) between them is the minimum cost required to transport mass from ν to µ .
Revised: Given two discrete probability distributions µ (with support A ) and ν (with support B ) inside a d -dimensional unit hypercube in the Euclidean space with max {| A | , | B |} = n , the 1 -Wasserstein distance W ( µ, ν ) (also called the Earth Mover’s distance) between them is the minimum cost required to transport mass from ν to µ .

Original: The special case where | A | = | B | = n and the mass at each point of A ∪ B is 1 /n is called the Euclidean Bipartite Matching (EBM) problem.
Revised: The special case where | A | = | B | = n and the mass at each point of A ∪ B is 1 /n is called the Euclidean Bipartite Matching (EBM) problem.

Original: In machine learning applications, one can improve a model µ by using its Earth Mover’s distance from a distribution ν built on real data.
Revised: In machine learning applications, one can improve a model µ by using its Earth Mover’s distance from a distribution ν built on real data.

Original: Consequently, it has been extensively used in generative models (Deshpande et al.
Revised: Consequently, it has been extensively used in generative models (Deshpande et al.

Original: ; Genevay et al.
Revised: ; Genevay et al.

Original: ; Salimans et al.
Revised: ; Salimans et al.

Original: (2018)), robust learning (Esfahani & Kuhn (2018)), supervised learning (Luise et al.
Revised: (2018)), robust learning (Esfahani & Kuhn (2018)), supervised learning (Luise et al.

Original: ; Janati et al.
Revised: ; Janati et al.

Original: (2019)), and parameter estimation (Liu et al.
Revised: (2019)), and parameter estimation (Liu et al.

Original: ; Bernton et al.
Revised: ; Bernton et al.

Original: One can find the 1 -Wasserstein distance between µ and ν in O ( n 3 log n ) time (Edmonds & Karp (1972)), which is computationally expensive.
Revised: One can find the 1 -Wasserstein distance between µ and ν in O ( n 3 log n ) time (Edmonds & Karp (1972); Orlin (1988)), which is computationally expensive.

Original: Therefore, there has been substantial focus on the design of approximation algorithms that estimate W ( µ, ν ) within an additive error of ε in n 2 poly { d, log n, 1 /ε } time.
Revised: Therefore, there has been substantial focus on the design of approximation algorithms that estimate W ( µ, ν ) within an additive error of ε in n 2 poly( d, log n, 1 /ε ) time.

Original: We refer to the transport cost corresponding to such approximations as an ε -close transport cost.
Revised: We refer to the transport cost corresponding to such approximations as an ε -close transport cost.

Original: When µ and ν converge, however, the cost produced by such algorithms will be unreliable as it is dominated by the error parameter ε .
Revised: When W ( µ, ν ) is significantly smaller than ε , however, the cost produced by such algorithms will be unreliable as it is dominated by the error parameter ε .

Original: To get a higher accuracy in this case, one can compute a relative approximation of the 1 -Wasserstein distance.
Revised: To get a higher accuracy in this case, one can compute a relative approximation of the 1 -Wasserstein distance.

Original: For a parameter α > 1 , an α -relative approximation is a cost that is within α W ( µ, ν ) .
Revised: For a parameter α > 1 , an α -relative approximation is a cost that is within α W ( µ, ν ) .

Original: There has been considerable effort in the design of relative approximation algorithms; however, many such methods suffer from curse of dimensionality; i.e, their execution time grows exponentially in d .
Revised: There has been considerable effort in the design of relative approximation algorithms; however, many such methods suffer from curse of dimensionality; i.e, their execution time grows exponentially in d .

Original: Furthermore, they rely on fairly involved data structures that have good asymptotic execution times but are difficult to implement and have large hidden constants within them making them impractical (Agarwal & Sharathkumar (2014);
Revised: Furthermore, they rely on fairly involved data structures that have good asymptotic execution times but are difficult to implement and have large hidden constants within them making them impractical (Agarwal & Sharathkumar (2014);

Original: Fox & Lu (2020); Agarwal et al.
Revised: Fox & Lu (2020); Agarwal et al.

Original: (2022a;b)).
Revised: (2022a;b)).

Original: The only exception to this are algorithms designed by using a simple hierarchical quadtree-based paradigm.
Revised: The only exception to this are algorithms designed by using a simple hierarchical quadtree-based paradigm.

Original: The classical algorithm in this paradigm is based on a d -dimensional quadtree and returns an O ( d log n ) -approximation of the 1 -Wasserstein distance in O ( nd ) time and has been used in various machine learning and computer vision applications (Gupta et al.
Revised: The classical algorithm in this paradigm is based on a d -dimensional quadtree and returns an O ( d log n ) -approximation of the 1 -Wasserstein distance in O ( nd ) time and has been used in various machine learning and computer vision applications (Gupta et al.

Original: ; Backurs et al.
Revised: ; Backurs et al.

Original: In the case of the Euclidean Bipartite 
Revised: In the case of the Euclidean Bipartite Matching, Agarwal & Varadarajan (2004) and Indyk

Original: (2007) generalized the algorithm in the hierarchical framework to achieve an approximation ratio of
Revised: (2007) generalized the algorithm in the hierarchical framework to achieve an approximation ratio of

Original: O ( d 2 log 1 /ε ) in ˜ O
Revised: O ( d 2 log 1 /ε ) in ˜ O

Original: ( n 1+ ε ) time 1 .
Revised: ( n 1+ ε ) time 1 .

Original: In this paper, we combine any additive approximation algorithm with the hierarchical framework for relative approximation algorithms. As a result, our algorithm is able to get better guarantees for both additive and relative approximations.
Revised: In this paper, we use any additive approximation algorithm as a black-box within the hierarchical framework for relative approximation algorithms, resulting in better guarantees for both additive and relative approximations.

Original: To our knowledge, this is the first result that combines the power of additive and relative approximation techniques leading to improvement in both settings.
Revised: To our knowledge, this is the first result that combines the power of additive and relative approximation techniques, leading to improvement in both settings.

Original: 1. P ROBLEM D EFINITION
Revised: 1. P ROBLEM D EFINITION

Original: In the 1 -Wasserstein problem, we are given two discrete distributions µ
Revised: In the 1 -Wasserstein problem, we are given two discrete distributions µ

Original: and ν .
Revised: and ν .

Original: Let A and B be the points that define µ and ν , respectively.
Revised: Let A and B be the points that define µ and ν , respectively.

Original: For the distribution µ (resp. ν ), suppose each point a ∈ A (resp.
Revised: For the distribution µ (resp. ν ), suppose each point a ∈ A (resp.

Original: b ∈ B ) has a probability of µ a (resp.
Revised: b ∈ B ) has a probability of µ a (resp.

Original: ν b ) associated with it, where (cid:80)
Revised: ν b ) associated with it, where (cid:80)

Original: a ∈
Revised: a ∈

Original: A µ a = (cid:80) b ∈ B ν b = 1 .
Revised: A µ a = (cid:80) b ∈ B ν b = 1 .

Original: Let G ( A, B ) denote the complete bipartite graph where, for any pair of points a ∈ A and b ∈ B , there is an edge from a to b of cost ∥ a − b ∥ ; i.e, the Euclidean distance between a and b .
Revised: Let G ( A, B ) denote the complete bipartite graph where, for any pair of points a ∈ A and b ∈ B , there is an edge from a to b of cost ∥ a − b ∥ , i.e, the Euclidean distance between a and b .

Original: For each point a ∈ A (resp.
Revised: For each point a ∈ A (resp.

Original: b ∈ B )
Revised: b ∈ B )

Original: , we assign a weight η ( a ) = − µ a (resp.
Revised: , we assign a weight η ( a ) = − µ a (resp.

Original: η ( b ) =
Revised: η ( b ) =

Original: ν b ).
Revised: ν b ).

Original: We refer to any point v ∈ A ∪ B with a negative (resp. positive) weight as a demand point (resp.
Revised: We refer to any point v ∈ A ∪ B with a negative (resp. positive) weight as a demand point (resp.

Original: supply point ) with a demand (resp.
Revised: supply point ) with a demand (resp.

Original: supply) of | η ( v ) | .
Revised: supply) of | η ( v ) | .

Original: Given any subset of points V ⊆
Revised: Given any subset of points V ⊆

Original: A ∪ B , the weight η ( V ) is simply the sum of the weights of its points; i.e, η ( V )
Revised: A ∪ B , the weight η ( V ) is simply the sum of the weights of its points; i.e, η ( V )

Original: =
Revised: =

Original: (cid:80) v ∈ V η ( v ) .
Revised: (cid:80) v ∈ V η ( v ) .

Original: For any edge ( a, b ) ∈
Revised: For any edge ( a, b ) ∈

Original: A × B , let the cost of transporting a supply of β from b to a be β ∥ a − b ∥ .
Revised: A × B , let the cost of transporting a supply of β from b to a be β ∥ a − b ∥ .

Original: In this problem, our goal is to transport all supplies from supply points to demand points with a minimum cost.
Revised: In this problem, our goal is to transport all supplies from supply points to demand points with a minimum cost.

Original: More formally, a transport plan is a function σ : A × B → R ≥ 0 that assigns a non-negative value to each edge of
Revised: More formally, a transport plan is a function σ : A × B → R ≥ 0 that assigns a non-negative value to each edge of

Original: G ( A, B ) indicating the quantity of supply transported along the edge.
Revised: G ( A, B ) indicating the quantity of supply transported along the edge.

Original: The transport plan σ is such that the total supplies transported into (resp.
Revised: The transport plan σ is such that the total supplies transported into (resp.

Original: from) any demand (resp.
Revised: from) any demand (resp.

Original: supply) point a ∈ A (resp.
Revised: supply) point a ∈ A (resp.

Original: b ∈ B ) is equal to − η ( a ) (resp.
Revised: b ∈ B ) is equal to − η ( a ) (resp.

Original: η ( b ) ).
Revised: η ( b ) ).

Original: The cost of the transport plan σ , denoted by w ( σ ) , is given by (cid:80) ( a,b ) ∈
Revised: The cost of the transport plan σ , denoted by w ( σ ) , is given by (cid:80) ( a,b ) ∈

Original: A × B σ ( a, b ) ∥ a − b ∥ .
Revised: A × B σ ( a, b ) ∥ a − b ∥ .

Original: The goal of this problem is to find a minimum-cost transport plan.
Revised: The goal of this problem is to find a minimum-cost transport plan.

Original: If two points a ∈ A and b ∈ B are co-located (i.e, they share the same coordinates), then due to the metric property of the Euclidean distances, if η ( b ) = − η
Revised: If two points a ∈ A and b ∈ B are co-located (i.e, they share the same coordinates), then due to the metric property of the Euclidean distances, if η ( b ) = − η

Original: ( a ) , we can match the supplies to the demands at zero cost and remove the points from the input.
Revised: ( a ) , we can match the supplies to the demands at zero cost and remove the points from the input.

Original: Otherwise, if η ( b ) ̸ = − η ( a ) , we replace the two points with a single point of weight η
Revised: Otherwise, if η ( b ) ̸ = − η ( a ) , we replace the two points with a single point of weight η

Original: ( a ) + η ( b ) .
Revised: ( a ) + η ( b ) .

Original: By definition, if the weight of the newly created point is negative (resp. positive), we consider it a demand (resp.
Revised: By definition, if the weight of the newly created point is negative (resp. positive), we consider it a demand (resp.

Original: supply) point.
Revised: supply) point.

Original: In our presentation, we always consider A and B to be the point sets obtained after replacing all the co-located points.
Revised: In our presentation, we always consider A and B to be the point sets obtained after replacing all the co-located points.

Original: Observe that the total supply U =
Revised: Observe that the total supply U =

Original: η ( B ) need not be 1 .
Revised: η ( B ) need not be 1 .

Original: However, it is easy to see that η ( B ) = − η
Revised: However, it is easy to see that η ( B ) = − η

Original: ( A ) ; i.e, the problem instance defined on A ∪ B is balanced .
Revised: ( A ) ; i.e, the problem instance defined on A ∪ B is balanced .

Original: We say that a transport plan σ is an ε -close transport plan if w ( σ ) ≤ W ( µ, ν ) + εU .
Revised: We say that a transport plan σ is an ε -close transport plan if w ( σ ) ≤ W ( µ, ν ) + εU .

Original: In many applications, the distributions µ and ν are continuous or large (possibly unknown) discrete distributions.
Revised: In many applications, the distributions µ and ν are continuous or large (possibly unknown) discrete distributions.

Original: In such cases, it might be impossible to compute W ( µ, ν ) .
Revised: In such cases, it might be impossible to compute W ( µ, ν ) .

Original: Instead, one can draw two sets A and B of n samples each from µ and ν , respectively.
Revised: Instead, one can draw two sets A and B of n samples each from µ and ν , respectively.

Original: Each point a ∈ A (resp.
Revised: Each point a ∈ A (resp.

Original: b ∈ B ) is assigned a weight of η ( a ) =
Revised: b ∈ B ) is assigned a weight of η ( a ) =

Original: − 1 /n (resp.
Revised: − 1 /n (resp.

Original: η ( b ) = 1 /n ).
Revised: η ( b ) = 1 /n ).

Original: One can approximate the 1 -Wasserstein distance between the distributions µ and ν by simply solving the 1 -Wasserstein problem defined on G ( A, B ) .
Revised: One can approximate the 1 -Wasserstein distance between the distributions µ and ν by simply solving the 1 -Wasserstein problem defined on G ( A, B ) .

Original: This special case where every point has the same demand and supply is called the
Revised: This special case where every point has the same demand and supply is called the

Original: Euclidean Bipartite Matching (EBM) problem.
Revised: Euclidean Bipartite Matching (EBM) problem.

Original: A matching M is a set of vertex-disjoint edges in
Revised: A matching M is a set of vertex-disjoint edges in

Original: G ( A, B ) and has a cost 1 /n (cid:80) ( a,b ) ∈ M ∥ a − b ∥ .
Revised: G ( A, B ) and has a cost 1 /n (cid:80) ( a,b ) ∈ M ∥ a − b ∥ .

Original: For the special case of the EBM problem, the optimal transport plan is simply a minimum-cost matching of cardinality n .
Revised: For the special case of the EBM problem, the optimal transport plan is simply a minimum-cost matching of cardinality n .

Original: For any point set P in the Euclidean space, let C max ( P ) :
Revised: For any point set P in the Euclidean space, let C max ( P ) :

Original: =
Revised: =

Original: max ( a,b ) ∈ P × P ∥ a − b ∥ denote the distance of its farthest pair and C min ( P ) :
Revised: max ( a,b ) ∈ P × P ∥ a − b ∥ denote the distance of its farthest pair and C min ( P ) :

Original: = min ( a,b ) ∈ P × P,a ̸ = b ∥ a − b
Revised: = min ( a,b ) ∈ P × P,a ̸ = b ∥ a − b

Original: ∥ denote the distance of its closest pair.
Revised: ∥ denote the distance of its closest pair.

Original: The spread of the point set, denoted by ∆( P ) , is the ratio ∆( P ) =
Revised: The spread of the point set, denoted by ∆( P ) , is the ratio ∆( P ) =

Original: C max ( P ) /C
Revised: C max ( P ) /C

Original: min ( P ) .
Revised: min ( P ) .

Original: When P is obvious from the context, we simply use C min , C max , and ∆ to denote the distance of its closest and farthest pair and its spread.
Revised: When P is obvious from the context, we simply use C min , C max , and ∆ to denote the distance of its closest and farthest pair and its spread.

Original: 1. R ELATED W ORK
Revised: 1. R ELATED W ORK

Original: Relative Approximations:
Revised: Relative Approximations:

Original: In fixed dimensional settings, i.e., d = O (1) , there is extensive work on the design of near-linear time (1 + ε ) -relative approximation for 1 -Wasserstein and EBM problems.
Revised: In fixed dimensional settings, i.e., d = O (1) , there is extensive work on the design of near-linear time (1 + ε ) -relative approximation for 1 -Wasserstein and EBM problems.

Original: The execution time of these algorithms are Ω( n ( dε − 1 log n ) d ) (Khesin et al.
Revised: The execution time of these algorithms are Ω( n ( dε − 1 log n ) d ) (Khesin et al.

Original: ; Raghvendra & Agarwal (2020); Fox & Lu (2020); Agarwal et al. (2022a)).
Revised: ; Raghvendra & Agarwal (2020); Fox & Lu (2020); Agarwal et al. (2022a)).

Original: A recent algorithm presented by Agarwal et al.
Revised: A recent algorithm presented by Agarwal et al.

Original: (2022b) improved the dependence on d slightly and achieved an execution time of n ( dε − 1 log log n ) d .
Revised: (2022b) improved the dependence on d slightly and achieved an execution time of n ( dε − 1 log log n ) d .

Original: Nonetheless, the exponential dependence on d make it unsuitable for higher dimensions.
Revised: Nonetheless, the exponential dependence on d make it unsuitable for higher dimensions.

Original: For higher dimensions, a quad-tree based greedy algorithm provides an  O ( d log n ) approximation in O ( nd ) time.
Revised: For higher dimensions, a quad-tree based greedy algorithm provides an expected O ( d log n ) approximation in O ( nd ) time.

Revised: This algorithm constructs a randomly-shifted recursive partition of space by splitting each cell into 2 d cells with half the side-length.

Revised: For every cell of the quad-tree, the algorithm moves excess supply present inside its child to meet any demand present inside another child.

Original: Agarwal & Varadarajan (2004) combined the hierarchical greedy paradigm with an exact solver to get an  O ( d 2 log 1 /ε ) -approximation in ˜ O
Revised: Agarwal & Varadarajan (2004) combined a different hierarchical partition with an exact solver to get an expected O ( d 2 log 1 /ε ) -approximation in ˜ O

Original: ( n 1+ ε ) time.
Revised: ( n 1+ ε ) time.

Original: Indyk (2007) combined the hierarchical greedy framework with importance sampling to estimate the cost of the Euclidean bipartite matching within a constant factor of the optimal.
Revised: Indyk (2007) combined the hierarchical greedy framework with importance sampling to estimate the cost of the Euclidean bipartite matching within a constant factor of the optimal.

Original: Additionally, there are ˜ O ( nd ) time algorithms that approximate the matching cost with a factor of O (log 2 n ) (Andoni et al.
Revised: Additionally, there are ˜ O ( nd ) time algorithms that approximate the matching cost with a factor of O (log 2 n ) (Andoni et al.

Original: There are also exact and approximation algorithms that run in ˜ O
Revised: There are also exact and approximation algorithms that run in ˜ O

Original: ( n 2 ) time; however, these algorithms rely on several black-box reductions and at present, there are no usable implementations of these algorithms (Agarwal & Sharathkumar (2014); Sherman (2017)).
Revised: ( n 2 ) time; however, these algorithms rely on several black-box reductions and at present, there are no usable implementations of these algorithms (Agarwal & Sharathkumar (2014); Sherman (2017)).

Original: The lack of fast exact and relative approximations that are also implementable have motivated machine learning researchers to design additive approximation algorithms which we discuss next.
Revised: The lack of fast exact and relative approximations that are also implementable have motivated machine learning researchers to design additive approximation algorithms which we discuss next.

Original: Additive Approximations: Cuturi (2013) introduced a regularized version of the optimal transport problem that produces an ε -close transport plan, which can be solved using the Sinkhorn method.
Revised: Additive Approximations: Cuturi (2013) introduced a regularized version of the optimal transport problem that produces an ε -close transport plan, which can be solved using the Sinkhorn method.

Original: For input points within the unit hypercube, such an algorithm produces an ε -close transport plan in ˜ O
Revised: For input points within the unit hypercube, such an algorithm produces an ε -close transport plan in ˜ O

Original: n 2 d/ε 2 ) 2 time (Lin et al.
Revised: n 2 d/ε 2 ) 2 time (Lin et al.

Original: One can also adapt graph theoretic approaches including the algorithm by Gabow & Tarjan (1989) to obtain an ε -close solution in O ( n 2 √ d/ε + nd/ε 2 ) time for points within the unit hypercube (Lahn et al.
Revised: One can also adapt graph theoretic approaches including the algorithm by Gabow & Tarjan (1989) to obtain an ε -close solution in O ( n 2 √ d/ε + nd/ε 2 ) time for points within the unit hypercube (Lahn et al.

Original: Some of the additive approximation methods, including the Sinkhorn method, are also highly parallelizable.
Revised: Some of the additive approximation methods, including the Sinkhorn method, are also highly parallelizable.

Original: For instance, the algorithm by Jambulapati et al.
Revised: For instance, the algorithm by Jambulapati et al.

Original: (2019) has a parallel depth of ˜ O
Revised: (2019) has a parallel depth of ˜ O

Original: (1 /ε ) ; see also Altschuler et al.
Revised: (1 /ε ) ; see also Altschuler et al.

Original: Blanchet et al.
Revised: Blanchet et al.

Original: ; Quanrud (2018); Dvurechensky et al.
Revised: ; Quanrud (2018); Dvurechensky et al.

Original: ; Guo et al.
Revised: ; Guo et al.

Original: 1. O UR R ESULTS
Revised: 1. O UR R ESULTS

Original: Let T ( n, ε ) be the time taken by an ε -additive approximation algorithm on an input of n points in the unit hypercube.
Revised: Let T ( n, ε ) be the time taken by an ε -additive approximation algorithm on an input of n points in the unit hypercube.

Original: In Theorem 1.1 and Theorem 1.2, we present new algorithms that improve the accuracy of any additive approximation algorithm for the 1 -Wasserstein problem and the EBM problem, respectively.
Revised: In Theorem 1.1 and Theorem 1.2, we present new algorithms that improve the accuracy of any additive approximation algorithm for the 1 -Wasserstein problem and the EBM problem, respectively.

Original: Theorem 1.1.
Revised: Theorem 1.1.

Original: There exists a randomized algorithm that, given two discrete distributions µ and ν in the d -dimensional unit hypercube with a spread of ∆ = n O (1) and a parameter ε > 0 , computes a transport plan with an expected additive error of min { ε, ( d log √ d/ε n ) W ( µ, ν ) } in
Revised: There exists a randomized algorithm that, given two discrete distributions µ and ν in the d -dimensional unit hypercube with a spread of ∆ = n O (1) and a parameter ε > 0 , computes a transport plan with an expected additive error of min { ε, ( d log √ d/ε n ) W ( µ, ν ) } in

Original: O ( T ( n, ε/d ) log √ d/ε n ) time; here, W ( µ, ν ) is the 1 -Wasserstein distance between µ and ν .
Revised: O ( T ( n, ε/d ) log √ d/ε n ) time; here, W ( µ, ν ) is the 1 -Wasserstein distance between µ and ν .

Original: Theorem 1.2.
Revised: Theorem 1.2.

Original: There exists an algorithm that, given two sets of samples A and B each from distributions µ and ν in the d -dimensional unit hypercube , where | A | = | B | = n , and a parameter ε > 0 , computes, with high probability, a matching that is within an expected additive error of min { ε, ( d log log n ) w ∗ } from the optimal matching cost w ∗ in O ( T ( n, ε/d ) log log n ) time.
Revised: There exists an algorithm that, given two sets of samples A and B each from distributions µ and ν in the d -dimensional unit hypercube , where | A | = | B | = n , and a parameter ε > 0 , computes, with high probability, a matching that is within an expected additive error of min { ε, ( d log log n ) w ∗ } from the optimal matching cost w ∗ in O ( T ( n, ε/d ) log log n ) time.

Original: Typical additive approximation algorithms run in T ( n, ε ) =
Revised: Typical additive approximation algorithms run in T ( n, ε ) =

Original: ˜ O ( n 2 ) time and compute an ε -close transport plan for any arbitrary cost function; i.e, they make no assumption about the distance between points.
Revised: ˜ O ( n 2 ) time and compute an ε -close transport plan for any arbitrary cost function; i.e, they make no assumption about the distance between points.

Original: The inputs to our algorithm, on the other hand, are point sets in the Euclidean space.
Revised: The inputs to our algorithm, on the other hand, are point sets in the Euclidean space.

Original: Therefore, one can use an approximate dynamic nearest neighbor data structure to improve the execution time of such additive approximation algorithms.
Revised: Therefore, one can use an approximate dynamic nearest neighbor data structure to improve the execution time of such additive approximation algorithms.

Original: In particular, the algorithm by Lahn et al.
Revised: In particular, the algorithm by Lahn et al.

Original: (2019) executes in O (1 /ε ) phases, where in each phase, they execute one iteration of GabowTarjan’s algorithm.
Revised: (2019) executes in O (1 /ε ) phases, where in each phase, they execute one iteration of GabowTarjan’s algorithm.

Original: As shown by Agarwal & Sharathkumar (2014), one can use a 1 √ ε -approximate dynamic nearest neighbor data structure with a query/update time of O ( n ε + d log n ) (Andoni et al.
Revised: As shown by Agarwal & Sharathkumar (2014), one can use a 1 √ ε -approximate dynamic nearest neighbor data structure with a query/update time of O ( n ε + d log n ) (Andoni et al.

Original: to execute each iteration of Gabow-Tarjan’s algorithm in ˜ O
Revised: to execute each iteration of Gabow-Tarjan’s algorithm in ˜ O

Original: ( n 1+ ε ) time.
Revised: ( n 1+ ε ) time.

Original: Combining with the algorithms from Theorem 1.1 and Theorem 1.2, we obtain the following relative approximation algorithms.
Revised: Combining with the algorithms from Theorem 1.1 and Theorem 1.2, we obtain the following relative approximation algorithms.

Original: The details are provided in Appendix D.
Revised: The details are provided in Appendix D.

Original: Theorem 1.3.
Revised: Theorem 1.3.

Original: There exists a randomized algorithm that, given two discrete distributions µ and ν in the d -dimensional unit hypercube in Euclidean space with a spread of ∆ = n O (1) and a parameter ε > 0 , computes a O ( d/ε 3 / 2 ) -approximate transport plan in O ( d 2 n 1+ ε /ε ) time.
Revised: There exists a randomized algorithm that, given two discrete distributions µ and ν in the d -dimensional unit hypercube in Euclidean space with a spread of ∆ = n O (1) and a parameter ε > 0 , computes a O ( d/ε 3 / 2 ) -approximate transport plan in O ( d 2 n 1+ ε /ε ) time.

Original: Theorem 1.4.
Revised: Theorem 1.4.

Original: There exists an algorithm that, given two sets of samples A and B each from distributions µ and ν in the d -dimensional unit hypercube in Euclidean space, where | A | = | B | = n , and a parameter ε > 0 , computes, with high probability, an O ( d √ ε log dε ) -approximate matching in
Revised: There exists an algorithm that, given two sets of samples A and B each from distributions µ and ν in the d -dimensional unit hypercube in Euclidean space, where | A | = | B | = n , and a parameter ε > 0 , computes, with high probability, an O ( d √ ε log dε ) -approximate matching in

Original: O ( dn 1+ ε log dε ) time.
Revised: O ( dn 1+ ε log dε ) time.

Original: In contrast to our results, for the EBM problem, Agarwal & Varadarajan (2004) compute an
Revised: In contrast to our results, for the EBM problem, Agarwal & Varadarajan (2004) compute an

Original: O ( d 2 log 1 ε ) -approximate
Revised: O ( d 2 log 1 ε ) -approximate

Original: matching in the same running time.
Revised: matching in the same running time.

Original: Therefore, our algorithm computes a more accurate EBM when d > 1 √ ε .
Revised: Therefore, our algorithm computes a more accurate EBM when d > 1 √ ε .

Original: For instance, consider the case where d = √ log n .
Revised: For instance, consider the case where d = √ log n .

Original: For any arbitrarily small constant ε > 0 , the algorithm of Theorem 1.4 will run in ˜ O
Revised: For any arbitrarily small constant ε > 0 , the algorithm of Theorem 1.4 will run in ˜ O

Original: n 1+ ε ) time and return an O ( √ log n ) -approximation.
Revised: n 1+ ε ) time and return an O ( √ log n ) -approximation.

Original: In contrast, all previous methods that achieve sub-logarithmic approximation require Ω( n 5 / 4 ) time (Agarwal & Sharathkumar (2014)).
Revised: In contrast, all previous methods that achieve sub-logarithmic approximation require Ω( n 5 / 4 ) time (Agarwal & Sharathkumar (2014)).

Original: We also note that all of our algorithms extend to any ℓ p norm in a straight-forward way 3 .
Revised: We also note that all of our algorithms extend to any ℓ p norm in a straight-forward way 3 .

Original: For simplicity, we restrict our presentation only to the Euclidean case.
Revised: For simplicity, we restrict our presentation only to the Euclidean case.

Original: Overview of the Algorithm:
Revised: Overview of the Algorithm:

Original: Our algorithm uses the hierarchical greedy paradigm.
Revised: Our algorithm uses the hierarchical greedy paradigm.

Original: In our presentation, we refer to a hypercube as a cell .
Revised: In our presentation, we refer to a hypercube as a cell .

Original: For any cell □ , let V □ be the set of all points of A ∪ B that lies inside □ .
Revised: For any cell □ , let V □ be the set of all points of A ∪ B that lies inside □ .

Original: Unlike in the quad-tree greedy algorithm, instead of splitting each cell □ into 2 d cells, we split it into min {| V □ | , (4 √ d/ε ) d } cells.
Revised: Unlike in the quadtree greedy algorithm, instead of splitting each cell □ into 2 d cells, we split it into min {| V □ | , (4 √ d/ε ) d } cells.

Original: Thus, the height of the resulting tree T reduces from O (log n ) to O (log √ d/ε n ) .
Revised: Thus, the height of the resulting tree T reduces from O (log n ) to O (log √ d/ε n ) .

Original: For any cell □ of T and any child □ ′ of □ , we move any excess supply or demand inside □ ′ to its center.
Revised: For any cell □ of T and any child □ ′ of □ , we move any excess supply or demand inside □ ′ to its center.

Original: Let A □ (resp.
Revised: Let A □ (resp.

Original: B □ ) be a set consisting of the center points of all children of □ with excess demand (resp.
Revised: B □ ) be a set consisting of the center points of all children of □ with excess demand (resp.

Original: supply).
Revised: supply).

Original: For any child □ ′ of □ with excess demand (resp.
Revised: For any child □ ′ of □ with excess demand (resp.

Original: supply), we assign a weight of η ( V □ ′ ) to its center point in A □ (resp.
Revised: supply), we assign a weight of η ( V □ ′ ) to its center point in A □ (resp.

Original: B □ ).
Revised: B □ ).

Original: Using an additive approximation algorithm, we compute an ( ε/d ) -close transport cost between A □ and 
Revised: Using an additive approximation algorithm, we compute an ( ε/d ) -close transport cost between A □ and B □ in

Original: B □ in T ( | V □ | , ε/d ) time.
Revised: T ( | V □ | , ε/d ) time.

Original: We report the sum of the transport costs computed at all cells of T as an approximate 1 -Wasserstein distance.
Revised: We report the sum of the transport costs computed at all cells of T as an approximate 1 -Wasserstein distance.

Original: This simple algorithm guarantees improvement in the quality of the solutions produced by both additive and relative approximation algorithms.
Revised: This simple algorithm guarantees improvement in the quality of the solutions produced by both additive and relative approximation algorithms.

Original: From the stand-point of relative approximation algorithms, Agarwal & Varadarajan (2004) as well as Indyk (2007) have utilized a very similar hierarchical framework to design approximation algorithms.
Revised: From the stand-point of relative approximation algorithms, Agarwal & Varadarajan (2004) as well as Indyk (2007) have utilized a very similar hierarchical framework to design approximation algorithms.

Original: However, unlike our algorithm, they used an exact solver that takes Ω( | V □ | 3 ) time.
Revised: However, unlike our algorithm, they used an exact solver that takes Ω( | V □ | 3 ) time.

Original: As a result, to obtain near-quadratic execution time, they needed every cell to be divided into at most | V □ | 2 / 3 children, i.e., 1 /ε d ≤ n 2 / 3 or d ≤ log 1 /ε n  .
Revised: As a result, to obtain near-quadratic execution time, they needed every cell to be divided into at most | V □ | 2 / 3 children, i.e., 1 /ε d ≤ n 2 / 3 or d = O (log 1 /ε n ) .

Original: This also forces the height of the tree to be O ( d log 1 /ε n ) leading to an O ( d 2 log 1 /ε n ) -factor approximation.
Revised: This also forces the height of the tree to be O ( d log 1 /ε n ) leading to an O ( d 2 log 1 /ε n ) -factor approximation.

Original: We replace the Ω( n 3 ) time exact solver in their algorithm with a T ( | V □ | , ε ) =
Revised: We replace the Ω( n 3 ) time exact solver in their algorithm with a T ( | V □ | , ε ) =

Original: ˜ O ( | V □ | 2 ) time additive approximation algorithm.
Revised: ˜ O ( | V □ | 2 ) time additive approximation algorithm.

Original: Therefore, each instance (regardless of the number of non-empty children) can be solved in ˜
Revised: Therefore, each instance (regardless of the number of non-empty children) can be solved in ˜

Original: O ( | V □ | 2 ) time.
Revised: O ( | V □ | 2 ) time.

Original: As a result, we are able to improve the approximation factor from O ( d 2 log 1 /ε n ) to O ( d log √ d/ε n ) and also remove restrictions on the dimension.
Revised: As a result, we are able to improve the approximation factor from O ( d 2 log 1 /ε n ) to O ( d log √ d/ε n ) and also remove restrictions on the dimension.

Original: Our algorithm now works for any dimension!
Revised: Our algorithm now works for any dimension!

Original: Technical Challenge:
Revised: Technical Challenge:

Original: By using an additive approximation algorithm to solve each instance, we have an increased error that may be difficult to bound.
Revised: By using an additive approximation algorithm to solve each instance, we have an increased error that may be difficult to bound.

Original: We use the following observation to overcome this challenge.
Revised: We use the following observation to overcome this challenge.

Original: In Section 2.2, we show that for any point set with spread ∆ , an additive approximation algorithm can be used to compute a 2 -relative approximation in T ( n, 1 / ∆) time.
Revised: In Section 2.2, we show that for any point set with spread ∆ , an additive approximation algorithm can be used to compute a 2 -relative approximation in T ( n, 1 / ∆) time.

Original: Since the spread of the point set at each cell □ is  d/ε  ,  we get a 2 -relative approximation by using an additive approximation algorithm in  T ( n, ε/d ) time.
Revised: The algorithm guarantees that the spread of the point set at each cell □ is O ( d/ε ) , and as a result, we get a 2relative approximation by using an additive approximation algorithm in O ( T ( n, ε/d )) time.

Original: Improvements for EBM:
Revised: Improvements for EBM:

Original: For the EBM problem, as mentioned in Theorem 1.2, we obtain an improvement in the approximation ratio as follows: Instead of dividing each cell into a fixed number min { n, (4 √ d/ε ) d } of children, we divide them into min { n, n d/ 2 i } children at each level i ; here, level of any cell in the tree is equal to the length of the path from the root to this cell.
Revised: For the EBM problem, as mentioned in Theorem 1.2, we obtain an improvement in the approximation ratio as follows: Instead of dividing each cell into a fixed number min { n, (4 √ d/ε ) d } of children, we divide them into min { n, n d/ 2 i } children at each level i ; here, level of any cell in the tree is equal to the length of the path from the root to this cell.

Original: By doing so, we reduce the height of the tree to O (log log n ) .
Revised: By doing so, we reduce the height of the tree to O (log log n ) .

Original: To analyse the running time, we show that the number of remaining unmatched points over all level i cells is ˜ O ( n 1 − 12 i ) .
Revised: To analyse the running time, we show that the number of remaining unmatched points over all level i cells is ˜ O ( n 1 − 12 i ) .

Original: Since there are only sub-linearly many points remaining, we can afford a larger spread of O ( d ε n 12 i ) and the resulting execution time of the additive approximation will continue to be O ( T ( n, εd )) per level.
Revised: Since there are only sub-linearly many points remaining, we can afford a larger spread of O ( dε n 12 i ) and the resulting execution time of the additive approximation will continue to be O ( T ( n, εd )) per level.

Original: Limitations: Although our algorithms work in any dimension, we would like to note that the relative approximation factor grows linearly in the dimension.
Revised: Limitations: Although our algorithms work in any dimension, we would like to note that the relative approximation factor grows linearly in the dimension.

Original: Therefore, the improvement achieved by our algorithm degrades as dimension increases.
Revised: Therefore, the improvement achieved by our algorithm degrades as dimension increases.

Original:  P RELIMINARIES
Revised:  P RELIMINARIES

Original: We begin by introducing notations that are used in presenting our algorithm.
Revised: We begin by introducing notations that are used in presenting our algorithm.

Original: For any cell □ , we denote the side-length of □ by ℓ □ and the center of □ by c □ .
Revised: For any cell □ , we denote the side-length of □ by ℓ □ and the center of □ by c □ .

Original: For a parameter ℓ , let G ( □ , ℓ ) denote a grid that partitions □ into smaller cells with side-length ℓ .
Revised: For a parameter ℓ , let G ( □ , ℓ ) denote a grid that partitions □ into smaller cells with side-length ℓ .

Original: Recall that V □ denotes the subset of
Revised: Recall that V □ denotes the subset of

Original: A ∪ B that lies inside □ .
Revised: A ∪ B that lies inside □ .

Original: We say that □ is non-empty if V □ is non-empty; i.e, □ contains at least one point of A ∪ B .
Revised: We say that □ is non-empty if V □ is non-empty; i.e, □ contains at least one point of A ∪ B .

Original: We define the weight of □ to be η ( V □ ) and denote it by η ( □ ) .
Revised: We define the weight of □ to be η ( V □ ) and denote it by η ( □ ) .

Original: For each cell □ , we call it a deficit cell if η ( □ ) < 0 , a surplus cell if η ( □ ) > 0 , and a neutral cell if η ( □ ) = 0 .
Revised: For each cell □ , we call it a deficit cell if η ( □ ) < 0 , a surplus cell if η ( □ ) > 0 , and a neutral cell if η ( □ ) = 0 .

Original: In this section, we provide a simple transformation of the input for achieving an additive approximation of the 1 -Wasserstein distance.
Revised: In this section, we provide a simple transformation of the input for achieving an additive approximation of the 1 -Wasserstein distance.

Original: Furthermore, for point sets with a spread of ∆ , we show how an additive approximation algorithm can be used to obtain a (1 + ε ) -relative approximation of the 1 -Wasserstein problem in T ( n, ε/ ∆) time.
Revised: Furthermore, for point sets with a spread of ∆ , we show how an additive approximation algorithm can be used to obtain a (1 + ε ) -relative approximation of the 1 -Wasserstein problem in T ( n, ε/ ∆) time.

Original: 2. A DDITIVE A PPROXIMATION IN E UCLIDEAN S PACE
Revised: 2. A DDITIVE A PPROXIMATION IN E UCLIDEAN S PACE

Original: In this section, for any ε > 0 , given an additive approximation algorithm that runs in T ( n, ε ) time, we present an algorithm to compute an ε -close transport cost for distributions inside the ddimensional unit hypercube □ ∗ in O (min { T ( n, ε 2 ) , n + T (( 2 √ dε ) d , ε 2 ) } ) time.
Revised: For any ε > 0 , given an additive approximation algorithm that runs in T ( n, ε ) time, we present an algorithm to compute an ε -close transport cost for distributions inside the d -dimensional unit hypercube □ ∗ in O (min { T ( n, ε 2 ) , n + T (( 2 √ dε ) d , ε 2 ) } ) time.

Original: The algorithm executes in two steps.
Revised: The algorithm executes in two steps.

Original: In the first step, the algorithm builds a grid G ( □ ∗ , ε 2 √ d ) on the unit hypercube □ ∗ and constructs a transport plan σ 1 as follows.
Revised: In the first step, the algorithm builds a grid G ( □ ∗ , ε 2 √ d ) on the unit hypercube □ ∗ and constructs a transport plan σ 1 as follows.

Original: For each non-empty neutral cell of the grid, σ 1 arbitrarily transports all supplies to demands within the cell.
Revised: For each non-empty neutral cell of the grid, σ 1 arbitrarily transports all supplies to demands within the cell.

Original: Similarly, for any deficit (resp.
Revised: Similarly, for any deficit (resp.

Original: surplus) cell, σ 1 arbitrarily transports supplies from (resp.
Revised: surplus) cell, σ 1 arbitrarily transports supplies from (resp.

Original: to) all supply (resp.
Revised: to) all supply (resp.

Original: demand) points inside the cell to (resp.
Revised: demand) points inside the cell to (resp.

Original: from) some arbitrary demand (resp.
Revised: from) some arbitrary demand (resp.

Original: supply) points within the cell.
Revised: supply) points within the cell.

Original: In the second step, the algorithm constructs a set of demand points A and supply points B as follows:
Revised: In the second step, the algorithm constructs a set of demand points A and supply points B as follows:

Original: For any deficit cell □ (resp.
Revised: For any deficit cell □ (resp.

Original: surplus cell □ ′ ), the point c □ (resp.
Revised: surplus cell □ ′ ), the point c □ (resp.

Original: c □ ′ ) is added to A (resp.
Revised: c □ ′ ) is added to A (resp.

Original: B ) with a weight of η ( □ ) (resp.
Revised: B ) with a weight of η ( □ ) (resp.

Original: η ( □ ′ ) ).
Revised: η ( □ ′ ) ).

Original: Note that A∪B is a balanced instance for the 1 -Wasserstein problem.
Revised: Note that A∪B is a balanced instance for the 1 -Wasserstein problem.

Original: The algorithm computes an ε 2 -close transport plan σ 2 on the instance
Revised: The algorithm computes an ε 2 -close transport plan σ 2 on the instance

Original: A ∪ B in T ( |A| + |B| , ε/ 2) time (See Figure 1).
Revised: A ∪ B in T ( |A| + |B| , ε/ 2) time (See Figure 1).

Original: The algorithm returns w ( σ 1 ) + w ( σ 2 ) as an ε -close transport cost on A ∪ B .
Revised: The algorithm returns w ( σ 1 ) + w ( σ 2 ) as an ε -close transport cost on A ∪ B .

Original: We provide a discussion on the accuracy of the algorithm in Appendix A.
Revised: We provide a discussion on the accuracy of the algorithm in Appendix A.

Original: The following lemma follows from the fact that |A| + |B| is bounded by min { 2 n, (2 √ d/ε ) d } .
Revised: The following lemma follows from the fact that |A| + |B| is bounded by min { 2 n, (2 √ d/ε ) d } .

Original: Lemma 2.1.
Revised: Lemma 2.1.

Original: There exists an algorithm that, given two point sets A and B in the d -dimensional unit hypercube and a value ε > 0 , computes an ε -close transport cost in O (min { T ( n, ε 2 ) , n +
Revised: There exists an algorithm that, given two point sets A and B in the d -dimensional unit hypercube and a value ε > 0 , computes an ε -close transport cost in O (min { T ( n, ε 2 ) , n +

Original: T (( 2 √ dε ) d , ε 2 ) } ) time.
Revised: T [Equation] time.

Original: Instead of transporting supplies inside cells arbitrarily, our algorithm in Section 3 recursively applies the same algorithm in each cell and obtains a higher accuracy.
Revised: Instead of transporting supplies inside cells arbitrarily, our algorithm in Section 3 recursively applies the same algorithm in each cell and obtains a higher accuracy.

Original: 2. R ELATIVE A PPROXIMATION FOR L OW S PREAD P OINT S ETS
Revised: 2. R ELATIVE A PPROXIMATION FOR L OW S PREAD P OINT S ETS

Original: In this section, we show that an ε -additive approximation algorithm can be used to obtain a (1 + ε ) - relative approximation algorithm for the 1 -Wasserstein problem in T ( n, ε/ ∆) time; here, ∆ is the spread of the points in A ∪ B .
Revised: In this section, we show that an ε -additive approximation algorithm can be used to obtain a (1 + ε ) - relative approximation algorithm for the 1 -Wasserstein problem in T ( n, ε/ ∆) time; here, ∆ is the spread of the points in A ∪ B .

Original: Since relative approximations are scale invariant, without loss of generality, we assume that the input has C max = 1 and C min = 1 / ∆ .
Revised: Since relative approximations are scale invariant, without loss of generality, we assume that the input has C max = 1 and C min = 1 / ∆ .

Original: Suppose − η ( A ) =
Revised: Suppose − η ( A ) =

Original: η ( B ) =
Revised: η ( B ) =

Original: U .
Revised: U .

Original: The minimum distance between any two points ( a, b ) ∈
Revised: The minimum distance between any two points ( a, b ) ∈

Original: A × B is 1 / ∆ .
Revised: A × B is 1 / ∆ .

Original: Therefore, the cost of transporting a supply of U is at least U/ ∆ .
Revised: Therefore, the cost of transporting a supply of U is at least U/ ∆ .

Original: We obtain a (1 + ε ) - relative approximate transport plan by simply executing an additive approximation algorithm with an additive error of U ( ε/ ∆) in time T ( n, ε/ ∆) .
Revised: We obtain a (1 + ε ) - relative approximate transport plan by simply executing an additive approximation algorithm with an additive error of U ( ε/ ∆) in time T ( n, ε/ ∆) .

Original: Lemma 2.2.
Revised: Lemma 2.2.

Original: There exists an algorithm that, given two point sets A and B in the d -dimensional unit hypercube with a spread of ∆ , computes a (1 + ε ) -approximate transport plan in T ( n, ε/ ∆) time.
Revised: There exists an algorithm that, given two point sets A and B in the d -dimensional unit hypercube with a spread of ∆ , computes a (1 + ε ) -approximate transport plan in T ( n, ε/ ∆) time.

Original:  A N O ( d log √ d/ε n ) - APPROXIMATION ALGORITHM FOR 1 -W ASSERSTEIN PROBLEM
Revised:  A N O ( d log √ d/ε n ) - APPROXIMATION ALGORITHM FOR 1 -W ASSERSTEIN PROBLEM

Original: In this section, we present an algorithm satisfying the bounds claimed in Theorem 1.1.
Revised: In this section, we present an algorithm satisfying the bounds claimed in Theorem 1.1.

Original: We begin by defining a hierarchical partitioning and a tree T associated with it.
Revised: We begin by defining a hierarchical partitioning and a tree T associated with it.

Original: Each node in the tree corresponds to a non-empty cell in our hierarchical partition and we do not distinguish between the two.
Revised: Each node in the tree corresponds to a non-empty cell in our hierarchical partition and we do not distinguish between the two.

Original: Our tree partitions each cell of side-length ℓ into ⌈ 4 √ d/ε ⌉ d many cells of side-length at most ( ε/ 4 √ d ) ℓ .
Revised: Our tree partitions each cell of side-length ℓ into ⌈ 4 √ d/ε ⌉ d many cells of side-length at most ( ε/ 4 √ d ) ℓ .

Original: We construct our hierarchical partition in a randomly-shifted fashion as follows.
Revised: We construct our hierarchical partition in a randomly-shifted fashion as follows.

Original: Hierarchical Partitioning: First, we pick a point ξ uniformly at random from the unit hypercube [0 , 1] d and set □ ∗ =
Revised: Hierarchical Partitioning: First, we pick a point ξ uniformly at random from the unit hypercube [0 , 1] d and set □ ∗ =

Original: [ − 1 , 1] d + ξ .
Revised: [ − 1 , 1] d + ξ .

Original: Note that □ ∗ is a hypercube of side-length 2 containing all points in A ∪ B .
Revised: Note that □ ∗ is a hypercube of side-length 2 containing all points in A ∪ B .

Original: We designate □ ∗ as the root of T .
Revised: We designate □ ∗ as the root of T .

Original: Let κ = ⌈ 4 √ d/ε ⌉ .
Revised: Let κ = ⌈ 4 √ d/ε ⌉ .

Original: For any cell □ , if only one point of A ∪ B lies inside □ , we designate □ as a leaf cell in T .
Revised: For any cell □ , if only one point of A ∪ B lies inside □ , we designate □ as a leaf cell in T .

Original: For any non-leaf cell □ , we construct its children by partitioning □ using a grid G □ = G ( □ , ℓ □ /κ ) into ⌈ 4 √ d/
Revised: For any non-leaf cell □ , we construct its children by partitioning □ using a grid G □ = G ( □ , ℓ □ /κ ) into ⌈ 4 √ d/

Original: ε ⌉ d cells and create a child node for each non-empty cell of this grid.
Revised: ε ⌉ d cells and create a child node for each non-empty cell of this grid.

Original: For any non-leaf cell □ of T , we denote the set of children of □ by C [ □ ] .
Revised: For any non-leaf cell □ of T , we denote the set of children of □ by C [ □ ] .

Original: Assuming the spread ∆ = n O (1) , the height of T , h , is O (log √ d/ε n ) .
Revised: Assuming the spread ∆ = n O (1) , the height of T , h , is O (log √ d/ε n ) .

Original: Similar to quadtrees, our hierarchical partitioning can be seen as a sequence of grids ⟨ G 0 , G 1 , . .
Revised: Similar to quadtrees, our hierarchical partitioning can be seen as a sequence of grids ⟨ G 0 , G 1 , . .

Original: , G h ⟩ , where G 0 is the root and each grid G i refines the cells of grid G i − 1 .
Revised: , G h ⟩ , where G 0 is the root and each grid G i refines the cells of grid G i − 1 .

Original: For each grid G i , we denote the cell-side-length of G i by ℓ i .
Revised: For each grid G i , we denote the cell-side-length of G i by ℓ i .

Original: Next, we describe our algorithm.
Revised: Next, we describe our algorithm.

Original: Computing an approximate 1 -Wasserstein distance: In this section, we present our algorithm for computing an approximate cost of an optimal transport plan on A ∪ B .
Revised: Computing an approximate 1 -Wasserstein distance: In this section, we present our algorithm for computing an approximate cost of an optimal transport plan on A ∪ B .

Original: 1 - Creating an instance at each cell: For each cell □ of T , we create an instance I □ of the 1-Wasserstein problem as follows.
Revised: 1 - Creating an instance at each cell: For each cell □ of T , we create an instance I □ of the 1-Wasserstein problem as follows.

Original: If □ is a deficit or surplus cell, we add the point c
Revised: If □ is a deficit or surplus cell, we add the point c

Original: □ with a weight − η ( □ ) to I □ .
Revised: □ with a weight − η ( □ ) to I □ .

Original: Additionally, if □ is a leaf cell, then it contains a single point u of A ∪ B , which we add to I □ .
Revised: Additionally, if □ is a leaf cell, then it contains a single point u of A ∪ B , which we add to I □ .

Original: Otherwise, □ is a non-leaf cell and for any child □ ′ ∈ C [ □ ] , if □ ′ is a deficit or surplus cell, we add c □ ′ with a weight η ( □ ′ ) to I □ , which represents the excess demands or supplies of the points in V □ ′ .
Revised: Otherwise, □ is a non-leaf cell and for any child □ ′ ∈ C [ □ ] , if □ ′ is a deficit or surplus cell, we add c □ ′ with a weight η ( □ ′ ) to I □ , which represents the excess demands or supplies of the points in V □ ′ .

Original: The instance I □ is balanced and has a spread of O ( d/ε ) .
Revised: The instance I □ is balanced and has a spread of O ( d/ε ) .

Original: 2 - Estimating the 1 -Wasserstein distance: In this step, for each cell □ , using the algorithm from
Revised: 2 - Estimating the 1 -Wasserstein distance: In this step, for each cell □ , using the algorithm from

Original: Lemma 2.2, we compute a 2 -approximate transport plan σ □ on I □ .
Revised: Lemma 2.2, we compute a 2 -approximate transport plan σ □ on I □ .

Original: Our algorithm then reports the total cost of the transport plans computed at all cells of T , i.e, w := (cid:80) □ ∈ T w ( σ □ ) , as an approximate 1 -Wasserstein distance.
Revised: Our algorithm then reports the total cost of the transport plans computed at all cells of T , i.e, w := (cid:80) □ ∈ T w ( σ □ ) , as an approximate 1 -Wasserstein distance.

Original: Retrieving an approximate transport plan: We retrieve an approximate transport plan σ on the point set A ∪ B by processing grids ⟨ G h , . . .
Revised: Retrieving an approximate transport plan: We retrieve an approximate transport plan σ on the point set A ∪ B by processing grids ⟨ G h , . . .

Original: , G 0 ⟩ in decreasing order of their level.
Revised: , G 0 ⟩ in decreasing order of their level.

Original: First, for each non-empty cell □ of G h , □ is a leaf cell and V □ contains only one point.
Revised: First, for each non-empty cell □ of G h , □ is a leaf cell and V □ contains only one point.

Original: We map the only point in V □ to c □ .
Revised: We map the only point in V □ to c □ .

Original: For some i < h , assume (inductively) that after processing the non-empty cells of the grid
Revised: For some i < h , assume (inductively) that after processing the non-empty cells of the grid

Original: G i +1 , the following conditions (i)–(iii) hold for the current transport plan σ within any cell □ in G
Revised: G i +1 , the following conditions (i)–(iii) hold for the current transport plan σ within any cell □ in G

Original: i +1 :
Revised: i +1 :

Original: (i) if □ is a neutral cell, then σ transports every supply to some demand point inside □ , (ii) if □ is a deficit (resp.
Revised: (i) if □ is a neutral cell, then σ transports every supply to some demand point inside □ , (ii) if □ is a deficit (resp.

Original: surplus) cell, then σ transports all supplies (resp.
Revised: surplus) cell, then σ transports all supplies (resp.

Original: demands) inside □ to (resp.
Revised: demands) inside □ to (resp.

Original: from) some demand (resp.
Revised: from) some demand (resp.

Original: supply) point within □ , and, (iii) if □ is a deficit (resp.
Revised: supply) point within □ , and, (iii) if □ is a deficit (resp.

Original: surplus) cell, the excess demand (resp.
Revised: surplus) cell, the excess demand (resp.

Original: supply) is mapped to c □ .
Revised: supply) is mapped to c □ .

Original: Given this, we show how to process any non-empty cell □ of G i so that (i)–(iii) holds for □ .
Revised: Given this, we show how to process any non-empty cell □ of G i so that (i)–(iii) holds for □ .

Original: Recollect that σ □ is a transport plan computed by our algorithm on I □ .
Revised: Recollect that σ □ is a transport plan computed by our algorithm on I □ .

Original: By condition (iii), the excess supplies or demands at any child □ ′ of □ is mapped to c □ ′ .
Revised: By condition (iii), the excess supplies or demands at any child □ ′ of □ is mapped to c □ ′ .

Original: Therefore, for any pair of children □ 1 , □ 2 ∈ C [ □ ] , where □ 1 is a surplus cell and □ 2 is a deficit cell, the transport plan σ transports σ □ ( c □ 1 , c □ 2 ) supplies from c □ 1 to c □ 2 .
Revised: Therefore, for any pair of children □ 1 , □ 2 ∈ C [ □ ] , where □ 1 is a surplus cell and □ 2 is a deficit cell, the transport plan σ transports σ □ ( c □ 1 , c □ 2 ) supplies from c □ 1 to c □ 2 .

Original: In addition, for any child □ 1 (resp. □ 2 ) of □ , suppose □ 1 (resp.
Revised: In addition, for any child □ 1 (resp. □ 2 ) of □ , suppose □ 1 (resp.

Original: □ 2 ) is
Revised: □ 2 ) is

Original: a surplus (resp.
Revised: a surplus (resp.

Original: deficit) cell.
Revised: deficit) cell.

Original: If σ □ ( c □ 1 , c □ ) > 0 (resp.
Revised: If σ □ ( c □ 1 , c □ ) > 0 (resp.

Original: σ □ ( c □ 2 , c □ ) > 0 ), then we map the supplies (resp.
Revised: σ □ ( c □ 2 , c □ ) > 0 ), then we map the supplies (resp.

Original: demands) from c □ 1 (resp.
Revised: demands) from c □ 1 (resp.

Original: c □ 2 ) to c □ .
Revised: c □ 2 ) to c □ .

Original: It is easy to confirm that after processing □ , (i)–(iii) holds for □ .
Revised: It is easy to confirm that after processing □ , (i)–(iii) holds for □ .

Original: From triangle inequality, w ( σ ) is upper-bounded by the total cost of the transport plans computed for each cell of T ; i.e, w ( σ ) ≤ (cid:80) □ ∈ T w ( σ □ ) .
Revised: From triangle inequality, w ( σ ) is upper-bounded by the total cost of the transport plans computed for each cell of T ; i.e, w ( σ ) ≤ (cid:80) □ ∈ T w ( σ □ ) .

Original: Efficiency: For any i , let C i denote the set of non-empty cells of T at level i .
Revised: Efficiency: For any i , let C i denote the set of non-empty cells of T at level i .

Original: For each cell □ ∈ C i , let n □ be the number of points in I □ .
Revised: For each cell □ ∈ C i , let n □ be the number of points in I □ .

Original: Since the spread of the points in I □ is O ( d/ε ) , executing the algorithm from Lemma 2.2 on I □ takes O
Revised: Since the spread of the points in I □ is O ( d/ε ) , executing the algorithm from Lemma 2.2 on I □ takes O

Original: ( T ( n □ , ε/d )) time.
Revised: ( T ( n □ , ε/d )) time.

Original: Since I □ contains at most one point for each non-empty child of □ , n □ ≤ min {| V □ | , (4 √ d/ε ) d } .
Revised: Since I □ contains at most one point for each non-empty child of □ , n □ ≤ min {| V □ | , (4 √ d/ε ) d } .

Original: Therefore, (cid:80) □ ∈ C i n □ ≤ (cid:80) □ ∈ C i | V □ | = n .
Revised: Therefore, (cid:80) □ ∈ C i n □ ≤ (cid:80) □ ∈ C i | V □ | = n .

Original: Since T ( n, ε ) =
Revised: Since T ( n, ε ) =

Original: Ω( n ) , the running time of our algorithm on cells at level i is O
Revised: Ω( n ) , the running time of our algorithm on cells at level i is O

Original: ( (cid:80) □ ∈ C i T ( n □ , ε/d ))
Revised: ( (cid:80) □ ∈ C i T ( n □ , ε/d ))

Original: =
Revised: =

Original: O ( T ( n, ε/d )) .
Revised: O ( T ( n, ε/d )) .

Original: Summing over all levels, the running time of our algorithm is O
Revised: Summing over all levels, the running time of our algorithm is O

Original: ( T ( n, ε/d ) log √ d/ε n ) .
Revised: ( T ( n, ε/d ) log √ d/ε n ) .

Original: When the dimension is a small constant, we get an improved running time as follows.
Revised: When the dimension is a small constant, we get an improved running time as follows.

Original: For each level i of T , there are at most n non-empty cells at level i and the instance created at each cell has a size of at most (4 √ d/ε ) d .
Revised: For each level i of T , there are at most n non-empty cells at level i and the instance created at each cell has a size of at most (4 √ d/ε ) d .

Original: Therefore, O ( (cid:80) □ ∈ C i T ( n □ , ε/d ))
Revised: Therefore, O ( (cid:80) □ ∈ C i T ( n □ , ε/d ))

Original: =
Revised: =

Original: O ( nT ((4 √ d/ε ) d , ε/d ))
Revised: O ( nT ((4 √ d/ε ) d , ε/d ))

Original: =
Revised: =

Original: n ( dε ) O ( d ) and the overall running time will be improved to n ( dε ) O ( d ) log √ d/ε n .
Revised: n ( dε ) O ( d ) and the overall running time will be improved to n ( dε ) O ( d ) log √ d/ε n .

Original: In the next section, assuming ε ≤ 1 / 2 , we show that the cost w computed by the algorithm is an O ( d log √ d/ε n ) -approximation of the cost of the optimal transport on A ∪ B .
Revised: Below, assuming ε ≤ 1 / 2 , we show that the cost w computed by the algorithm is an O ( d log √ d/ε n ) - approximation of the cost of the optimal transport on A ∪ B .

Original: Quality of Approximation: In this section, we analyze the approximate 1 -Wasserstein distance computed by our algorithm.
Revised: Quality of Approximation: We analyze the approximate 1 -Wasserstein distance computed by our algorithm as follows.

Original: After scaling the points to have a unit diameter, the algorithm of 
Revised: After scaling the points to have a unit diameter, the algorithm of Lemma 2.

Original: Lemma 2.2 obtains a 2 -approximate transport plan by computing a (1 / ∆) -close transport plan.
Revised: obtains a 2 -approximate transport plan by computing a (1 / ∆) -close transport plan.

Original: When scaled back to original, for the root cell □ ∗ of T , σ □ ∗ is an ( ε/ 4 √ d ) -close transport plan on □ ∗ .
Revised: When scaled back to original, for the root cell □ ∗ of T , σ □ ∗ is an ( ε/ 4 √ d ) -close transport plan on □ ∗ .

Original: The remaining demands and supplies are recursively transported within the children.
Revised: The remaining demands and supplies are recursively transported within the children.

Original: Since the diameter of each child of □ ∗ is ε/ 2 , similar to Section 2.1, we can argue that our algorithm reports an ε -close 1 -Wasserstein distance.
Revised: Since the diameter of each child of □ ∗ is ε/ 2 , similar to Section 2.1, we can argue that our algorithm reports an ε -close 1 -Wasserstein distance.

Original: Next, we show that the reported cost is an O ( d log √ d/ε n ) - approximation of the 1 -Wasserstein distance.
Revised: Next, we show that the reported cost is an O ( d log √ d/ε n ) -approximation of the 1 -Wasserstein distance.

Original: Recall that for each level i , C i denotes the set of non-empty cells of T at level i .
Revised: Recall that for each level i , C i denotes the set of non-empty cells of T at level i .

Original: We show that the expected distortion of mapping all points to the centers of the leaf cells is O ( d log √ d/ε n ) w ( σ ∗ ) , where the expectation is over the choice of the random shift of the hierarchical partitioning.
Revised: We show that the expected distortion of mapping all points to the centers of the leaf cells is O ( d log √ d/ε n ) w ( σ ∗ ) , where the expectation is over the choice of the random shift of the hierarchical partitioning.

Original: Additionally, for each i < h , we show that E [ (cid:80) □ ∈ C i w ( σ □ )]
Revised: Additionally, for each i < h , we show that E [ (cid:80) □ ∈ C i w ( σ □ )]

Original: = O ( d ) w ( σ ∗ ) ; here, σ ∗ is an optimal transport plan on A ∪ B .
Revised: = O ( d ) w ( σ ∗ ) ; here, σ ∗ is an optimal transport plan on A ∪ B .

Original: The result then follows since T has O (log √ d/ε n ) levels.
Revised: The result then follows since T has O (log √ d/ε n ) levels.

Original: For any level i < h , we bound E [ (cid:80) □ ∈ C i w ( σ □ )] in two steps as follows.
Revised: For any level i < h , we bound E [ (cid:80) □ ∈ C i w ( σ □ )] in two steps as follows.

Original: In the first step, we assign a budget to every edge ( a, b ) with σ ∗ ( a, b ) > 0 and show that the total budget assigned to all such edges is (in expectation) at most O ( d ) w ( σ ∗ ) .
Revised: In the first step, we assign a budget to every edge ( a, b ) with σ ∗ ( a, b ) > 0 and show that the total budget assigned to all such edges is (in expectation) at most O ( d ) w ( σ ∗ ) .

Original: In the second step, we redistribute this budget to the cells of level i in a way that the budget received by any cell □ is at least w ( σ □ ) / 2 .
Revised: In the second step, we redistribute this budget to the cells of level i in a way that the budget received by any cell □ is at least w ( σ □ ) / 2 .

Original: Details of these steps are provided in Appendix B. Theorem 1.1 follows from combining the two steps.
Revised: Details of these steps are provided in Appendix B. Theorem 1.1 follows from combining the two steps.

Original:  A N O ( d log log n ) - APPROXIMATION ALGORITHM FOR EBM PROBLEM
Revised:  A N O ( d log log n ) - APPROXIMATION ALGORITHM FOR EBM PROBLEM

Original: Given two sets of samples A and B from distributions µ and ν , respectively, where | A | = | B | = n and each point a ∈ A (resp.
Revised: Given two sets of samples A and B from distributions µ and ν , respectively, where | A | = | B | = n and each point a ∈ A (resp.

Original: b ∈ B ) has a weight η ( a )
Revised: b ∈ B ) has a weight η ( a )

Original: = − 1 /n (resp.
Revised: = − 1 /n (resp.

Original: η ( b ) = 1 /n )
Revised: η ( b ) = 1 /n )

Original: , we present an approximate algorithm for the EBM problem satisfying the bounds claimed in Theo- rem 1.2.
Revised: , we present an approximate algorithm for the EBM problem satisfying the bounds claimed in Theorem 1.2.

Original: For simplicity in presentation, we scale all the η ( · ) values from − 1 /n (resp.
Revised: For simplicity in presentation, we scale all the η ( · ) values from − 1 /n (resp.

Original: 1 /n ) to − 1 (resp. 1 ) and show that our algorithm computes a matching that is within an additive error of n min { ε, ( d log log n )( w ( M ∗ ) /n ) } from the optimal matching cost w ( M ∗ ) .
Revised: 1 /n ) to − 1 (resp. 1 ) and show that our algorithm computes a matching that is within an additive error of n min { ε, ( d log log n )( w ( M ∗ ) /n ) } from the optimal matching cost w ( M ∗ ) .

Original: Input Transformation: We transform input points such that (1) all coordinates are positive integers bounded by n O (1) , (2) an optimal matching on the transformed points is a (1 + ε ) - approximate matching with respect to the original points, and (3) the cost of the optimal matching is O ( d 3 / 2 n log n/ε ) .
Revised: Input Transformation: We transform input points such that (1) all coordinates are positive integers bounded by n O (1) , (2) an optimal matching on the transformed points is a (1 + ε ) - approximate matching with respect to the original points, and (3) the cost of the optimal matching is O ( d 3 / 2 n log n/ε ) .

Original: Similar transformations have been applied in several papers in the literature (Agarwal et al.
Revised: Similar transformations have been applied in several papers in the literature (Agarwal et al.

Original: ; Lahn & Raghvendra (2021)).
Revised: ; Lahn & Raghvendra (2021)).

Original: We describe this transformation in
Revised: We describe this transformation in

Original: Appendix C.1.
Revised: Appendix C.1.

Original: As before, we can match and remove any co-located points a ∈ A and b ∈ B .
Revised: As before, we can match and remove any co-located points a ∈ A and b ∈ B .

Original: Next, assuming T ( n, ε ) =
Revised: Next, assuming T ( n, ε ) =

Original: O ( n k ε poly { d, log n, log 1 ε } ) for some k ≥ 1 , we describe our EBM algorithm.
Revised: O ( n k ε poly( d, log n, log 1 ε )) for some k ≥ 1 , we describe our EBM algorithm.

Original: Our algorithm is easily adaptable to any additive approximate algorithm with a running time of T ( n, ε )
Revised: Our algorithm is easily adaptable to any additive approximate algorithm with a running time of T ( n, ε )

Original: =
Revised: =

Original: O ( n k ε − t poly { d, log n, log 1 ε } ) , where k ≥ 1 and t is a fixed constant.
Revised: O ( n k ε − t poly( d, log n, log 1 ε )) , where k ≥ 1 and t is a fixed constant.

Original: Overview of the algorithm: Similar to Section 3, our EBM algorithm constructs a hierarchical partitioning and the associated tree T , and executes the algorithm from Lemma 2.2 on the instance created for each cell of T .
Revised: Overview of the algorithm: Similar to Section 3, our EBM algorithm constructs a hierarchical partitioning and the associated tree T , and executes the algorithm from Lemma 2.2 on the instance created for each cell of T .

Original: In contrast to Section 3, the tree T constructed by our EBM algorithm has a lower height of O (log log n ) , resulting in an improved approximation factor.
Revised: In contrast to Section 3, the tree T constructed by our EBM algorithm has a lower height of O (log log n ) , resulting in an improved approximation factor.

Original: The hierarchical partitioning of this section differs from the one in Section 3 in two ways.
Revised: The hierarchical partitioning of this section differs from the one in Section 3 in two ways.

Original: First, we partition the root cell into a grid G 1 with cell-side-length of Θ( d 5 / 2 n log n/ε 2 ) as the first level.
Revised: First, we partition the root cell into a grid G 1 with cell-side-length of Θ( d 5 / 2 n log n/ε 2 ) as the first level.

Original: The grid Gmay result in a high branching factor at the root; however, we show that, with probability at least 1 − ε/ √ d , no edges of an optimal matching will cross G 1 .
Revised: The grid Gmay result in a high branching factor at the root; however, we show that, with probability at least 1 − ε/ √ d , no edges of an optimal matching will cross G 1 .

Original: Therefore, with that probability, all cells of G 1 are neutral cells and the problem instance for the root is an empty instance; i.e, the branching factor of the root will not impact the running time of our algorithm.
Revised: Therefore, with that probability, all cells of G 1 are neutral cells and the problem instance for the root is an empty instance; i.e, the branching factor of the root will not impact the running time of our algorithm.

Original: Second, for any cell □ of level i , instead of splitting □ into a fixed number min { n, (4 √ d/ε ) d } of children, we divide □ into min { n, n d/ 2 i } children.
Revised: Second, for any cell □ of level i , instead of splitting □ into a fixed number min { n, (4 √ d/ε ) d } of children, we divide □ into min { n, n d/ 2 i } children.

Original: Although this results in a higher spread of ˜ O ( n 1 / 2 i ) for the problem instance I □ , we show that the expected number of remaining unmatched points over all cells of level i is ˜ O ( n 1 − 1 / 2 i ) .
Revised: Although this results in a higher spread of ˜ O ( n 1 / 2 i ) for the problem instance I □ , we show that the expected number of remaining unmatched points over all cells of level i is ˜ O ( n 1 − 1 / 2 i ) .

Original: Therefore, the total execution time of our algorithm remains T ( n, ε/d ) per level.
Revised: Therefore, the total execution time of our algorithm remains T ( n, ε/d ) per level.

Original: These modifications result in a tree T of height O (log log n ) .
Revised: These modifications result in a tree T of height O (log log n ) .

Original: We describe the details below.
Revised: We describe the details below.

Original: Hierarchical Partitioning: Define δ := 5 d 2 ε − 1 log n .
Revised: Hierarchical Partitioning: Define δ := 5 d 2 ε − 1 log n .

Original: Similar to Section 3, we define a cell □ ∗ as a randomly-shifted hypercube that contains all points of A ∪ B and has a side-length of 2 max { C max , ℓ 1 /ε } , where ℓ 1 = √ dε δn .
Revised: Similar to Section 3, we define a cell □ ∗ as a randomly-shifted hypercube that contains all points of A ∪ B and has a side-length of 2 max { C max , ℓ 1 /ε } , where ℓ 1 = √ dε δn .

Original: We designate □ ∗ as the root of T ( □ ∗ is at level 0 of T ).
Revised: We designate □ ∗ as the root of T ( □ ∗ is at level 0 of T ).

Original: Define a grid G 1 := G ( □ ∗ , ℓ 1 ) .
Revised: Define a grid G 1 := G ( □ ∗ , ℓ 1 ) .

Original: We add each non-empty cell of G 1 to the tree as the children of □ ∗ .
Revised: We add each non-empty cell of G 1 to the tree as the children of □ ∗ .

Original: We construct the hierarchical partitioning in a recursive fashion as follows.
Revised: We construct the hierarchical partitioning in a recursive fashion as follows.

Original: For any non-root cell □ of T , if □ contains only one point of A ∪ B , then we designate □ as a leaf cell.
Revised: For any non-root cell □ of T , if □ contains only one point of A ∪ B , then we designate □ as a leaf cell.

Original: Otherwise, let □ be a cell of level i .
Revised: Otherwise, let □ be a cell of level i .

Original: Define the grid G □ = G ( □ , δn 1 / 2 i )4 and add the non-empty cells of G □ to T as the children of □ .
Revised: Define the grid G □ = G ( □ , δn 1 / 2 i ) and add the non-empty cells of G □ to T as the children of □ .

Revised: For simplicity in presentation, we assume n 1 / 2 i is an integer.

Original: For any cell □ , denote the set of children of □ in T by C [ □ ] .
Revised: For any cell □ , denote the set of children of □ in T by C [ □ ] .

Original: The height of T , denoted by h , is O (log log n ) .
Revised: The height of T , denoted by h , is O (log log n ) .

Original: Similar to Section 3, our hierarchical partitioning is also a sequence of grids ⟨ G 0 , G 1 , . .
Revised: Similar to Section 3, our hierarchical partitioning is also a sequence of grids ⟨ G 0 , G 1 , . .

Original: , G h ⟩ , where G 0 is the root cell □ ∗ , G 1 has a cell-side-length of ℓ 1 = √ dε δn , and for each 2 ≤ i ≤ h , the cell-side-length of G i is ℓ i
Revised: , G h ⟩ , where G 0 is the root cell □ ∗ , G 1 has a cell-side-length of ℓ 1 = √ dε δn , and for each 2 ≤ i ≤ h , the cell-side-length of G i is ℓ i

Original: = δn 1 / 2 i − 1 .
Revised: = δn 1 / 2 i − 1 .

Original: Computing an approximate matching cost: To estimate the matching cost, similar to Section 3, our algorithm creates an instance of the 1 -Wasserstein problem for each cell of the tree T .
Revised: Computing an approximate matching cost: To estimate the matching cost, similar to Section 3, our algorithm creates an instance of the 1 -Wasserstein problem for each cell of the tree T .

Original: Using the algorithm from Lemma 2.2, our algorithm computes a 2 -approximate transport plan for the instance created for each cell and returns the total cost of such transport plans as an approximate matching cost.
Revised: Using the algorithm from Lemma 2.2, our algorithm computes a 2 -approximate transport plan for the instance created for each cell and returns the total cost of such transport plans as an approximate matching cost.

Original: This completes the description of the algorithm.
Revised: This completes the description of the algorithm.

Original: We describe the details of retrieving a matching in Appendix C.2, the quality of approximation in
Revised: We describe the details of retrieving a matching in Appendix C.2, the quality of approximation in

Original: Appendix C.3, and the efficiency of our algorithm in Appendix C.4.
Revised: Appendix C.3, and the efficiency of our algorithm in Appendix C.4.

Original: [Figure]
Revised: [Figure]

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In this section, we conduct experiments to show that our algorithms from Section 3 and Sectionimprove the accuracy of the additive approximation algorithms with an increase in execution time.
Revised: In this section, we conduct experiments to show that our algorithms from Section 3 and Sectionimprove the accuracy of the additive approximation algorithms.

Original: We test an implementation of our algorithm, written in Python, on discrete probability distributions derived from real-world and synthetic data sets.
Revised: We test an implementation of our algorithm, written in Python, on discrete probability distributions derived from real-world and synthetic data sets.

Original: All tests are executed on a computer with a 2. GHz Intel Core i7 processor and 8GB of RAM using a single computation thread.
Revised: All tests are executed on a computer with a 2.50 GHz Intel Core i7 processor and 8GB of RAM using a single computation thread.

Original: Datasets: We test our algorithms on  n samples taken from synthetic (distribution) and real data sets.
Revised: Datasets: We test our algorithms on two sets of n samples taken from synthetic (distribution) and real-world data sets.

Original: In all our experiments, the sample size n varies from 1000 to 20000 . For each data set, we  present our results averaged over 10 executions.To generate the synthetic data, we sample from (i) a uniform distribution inside a unit square (Uniform), (ii) 3 -dimensional Gaussian mixture with 2 mean points centered at (0 . 24 , 0 . 24 , 0 . 24) and (0 . 72 , 0 .
Revised: For each dataset, we use our algorithms to compute the minimum-cost matching between these samples and present our results averaged over 10 executions.

Original: 72 , 0 . 72) inside a unit cube (Bimodal), and (iii) a uniform distribution from inside a 2 -dimensional unit square placed on a random plane in 15 -dimensional space (15-D Uniform).
Revised: To generate the synthetic data, we sample from a uniform distribution from inside a 2 -dimensional unit square placed on a random plane in 15 -dimensional space (15D).

Original: For a real dataset, we use the Adult Census Data (UCI repository) which is a point cloud in R 6 with continuous features for 35 , 000 individuals, divided into two categories by income Dua & Graff (2017).
Revised: For a real-world dataset, we use the Adult Census Data (UCI repository), which is a point cloud in R 6 with continuous features for 35 , 000 individuals, divided into two categories by income (Dua & Graff (2017)).

Original: Implementation Details: We compare the quality of the approximation as well as the execution time of our higher precision algorithms from Section 3 (1-Wasserstein algorithm) and Section(EBM algorithm) to the additive approximation algorithm from Section 2.1 (Geometric-Additive algorithm).
Revised: See Appendix E for the results of our experiments on additional datasets. Results: In our first experiment, we compare our algorithm with existing additive approximation schemes, namely the Sinkhorn method (Cuturi (2013)) (resp.

Revised: LMR algorithm

Revised: (Lahn et al.

Original: Each of these three algorithms use an additive approximation algorithmwith an execution time of T ( n, ε ) as a black-box. We use the  Sinkhorn method for this purpose.
Revised: We use the Sinkhorn (resp. LMR) algorithm as a black-box within our algorithm from Section( 1 -Wasserstein algorithm) and compare its execution time with the standard Sinkhorn (resp.

Original: Results: Figure 2 illustrates the estimated 1 -Wasserstein distance and  the execution times resulting from the application of the algorithms to thefour data sets.
Revised: LMR) implementation. We set the parameters of the Sinkhorn and LMR algorithms in such a way that the error produced by them matches with the error produced by our 1 -Wasserstein algorithm. As shown in Figure 2 (a)–(d), our algorithm runs significantly faster than both the Sinkhorn and the

Original: We summarize our findings.
Revised: LMR algorithms while producing solutions of similar quality. In our second experiment, we also compare the accuracy as well as the computation time of our algorithms ( 1 -Wasserstein algorithm and our EBM algorithm from Section 4) with the additive approximation algorithm from Section 2. (Geometric-Additive algorithm). For this experiment, our algorithms use the Sinkhorn algorithm as a black-box.

Original: First, we observe that our algorithms produce more accurate result than the Geometric-Additive algorithm in all of our experiments (see Figure 2(a), 2(b), 2(c) and 2(d)). This improvement is more significant on the real dataset while the execution time of the algorithms only increased slightly (see Figure 2(h)).
Revised: The results of this experiment are shown in Figure 2 (e)–(h). We observe that our algorithms achieves a better accuracy (see Figure 2 (a) and (c)), especially on real-world data sets. As expected, the execution time of our algorithms increase slightly (see Figure 2 (d)).

Original: Second, we observe that as the sample size increases, the costs returned by our algorithms converge to the optimal cost, whereas the Geometric-Additive approach does not.
Revised: Furthermore, we observe that as the sample size increases, the costs returned by our algorithms converge to the optimal cost, whereas the Geometric-Additive approach does not.

Revised: Finally, we highlight the scalability of our algorithms.

Original: In each case, both samples are drawn froman identical distribution and as a result, the Wasserstein distance between them approaches zero as sample size increases. Since our  algorithm provides a relative approximation, we converge towards 0 whereas the Geometric-Additive does not.
Revised: For an input of 3 million points drawn from a 2 dimensional uniform distribution on the unit square, our 1 -Wasserstein algorithm runs inseconds and computes an approximate transport cost of 0 . 0093 . Furthermore, for an input of 1 .million points for the 15D dataset, our 1 -Wasserstein algorithm computes an approximate cost of 0 .

Original: See Appendix E for the results of our additional experiments.
Revised: 0304 in 608 seconds.

Original: A M ISSING DETAILS OF S ECTION 2. 
Revised: A M ISSING DETAILS OF S ECTION 2.

Original: In this section, we analyze the additive error of the 1 -Wasserstein distance computed in Section 2.1.
Revised: In this section, we analyze the additive error of the 1 -Wasserstein distance computed in Section 2.1.

Original: First, we define some notations that are used in the analysis.
Revised: First, we define some notations that are used in the analysis.

Original: For a transport plan σ , the residual graph is a graph G ( A, B ) on the point set A ∪ B such that for any pair of points (
Revised: For a transport plan σ , the residual graph is a graph G ( A, B ) on the point set A ∪ B such that for any pair of points (

Original: a, b ) ∈
Revised: a, b ) ∈

Original: A × B , (1) if σ ( a, b ) > 0 , there is a backward edge from a to b of capacity σ ( a, b ) and (2) if σ ( a, b ) < min {− η ( a ) , η ( b ) } , then there is a forward edge from b to a with a capacity min {− η ( a ) , η ( b ) } − σ ( a, b ) .
Revised: A × B , (1) if σ ( a, b ) > 0 , there is a backward edge from a to b of capacity σ ( a, b ) and (2) if σ ( a, b ) < min {− η ( a ) , η ( b ) } , then there is a forward edge from b to a with a capacity min {− η ( a ) , η ( b ) } − σ ( a, b ) .

Original: An alternating path is any simple path P in G ( A, B ) ; i.e, a path P where the edges alternates between forward edges and backward edges.
Revised: An alternating path is any simple path P in G ( A, B ) ; i.e, a path P where the edges alternates between forward edges and backward edges.

Original: Any demand point a ∈ A (resp.
Revised: Any demand point a ∈ A (resp.

Original: supply point b ∈ B ) is called a free point with respect to σ if the total supplies transported into a (resp.
Revised: supply point b ∈ B ) is called a free point with respect to σ if the total supplies transported into a (resp.

Original: from b ) in σ is less than − η ( a ) (resp.
Revised: from b ) in σ is less than − η ( a ) (resp.

Original: η ( b ) ).
Revised: η ( b ) ).

Original: An augmenting path P with respect to σ is simply an alternating path from a free supply point to a free demand point.
Revised: An augmenting path P with respect to σ is simply an alternating path from a free supply point to a free demand point.

Original: Let β ( P ) denote the amount by which P increases the total supplies transported by σ .
Revised: Let β ( P ) denote the amount by which P increases the total supplies transported by σ .

Original: Recall that the algorithm of Section 2.1 computes a transport plan in two steps.
Revised: Recall that the algorithm of Section 2.1 computes a transport plan in two steps.

Original: In the first step, it computes a transport plan σ 1 by arbitrarily transporting supplies to demands within each non-empty cell of the grid.
Revised: In the first step, it computes a transport plan σ 1 by arbitrarily transporting supplies to demands within each non-empty cell of the grid.

Original: Suppose U ′ supplies are transported in this step.
Revised: Suppose U ′ supplies are transported in this step.

Original: In the second step, for each surplus (resp.
Revised: In the second step, for each surplus (resp.

Original: deficit) cell □ , the algorithm moves the excess supplies (resp.
Revised: deficit) cell □ , the algorithm moves the excess supplies (resp.

Original: demands) of the points inside □ to the center point c □ and creates the input instance A∪B .
Revised: demands) of the points inside □ to the center point c □ and creates the input instance A∪B .

Original: Then, it computes an ε/ 2 -close transport plan σ 2 on A ∪ B , which transports U − U ′ supplies.
Revised: Then, it computes an ε/ 2 -close transport plan σ 2 on A ∪ B , which transports U − U ′ supplies.

Original: The algorithm reports w ( σ 1 ) + w ( σ 2 ) as an approximate 1 -Wasserstein distance.
Revised: The algorithm reports w ( σ 1 ) + w ( σ 2 ) as an approximate 1 -Wasserstein distance.

Original: Since the diameter of each cell of the grid is ε/ 2 , each edge carrying a positive supply in σ 1 has a length of at most ε/ 2 ; therefore, w ( σ 1 ) ≤ εU ′ / 2 .
Revised: Since the diameter of each cell of the grid is ε/ 2 , each edge carrying a positive supply in σ 1 has a length of at most ε/ 2 ; therefore, w ( σ 1 ) ≤ εU ′ / 2 .

Original: Next, we bound the cost of σ 2 .
Revised: Next, we bound the cost of σ 2 .

Original: Let σ ∗ be any optimal transport plan on A ∪ B .
Revised: Let σ ∗ be any optimal transport plan on A ∪ B .

Original: Let P denote the set of augmenting paths in the symmetric difference σ ∗ ⊕ σ 1 with respect to σ 1 .
Revised: Let P denote the set of augmenting paths in the symmetric difference σ ∗ ⊕ σ 1 with respect to σ 1 .

Original: For any P ∈ P , suppose P is an augmenting path with a supply point b P ∈ B and a demand point a P ∈ A as its endpoints.
Revised: For any P ∈ P , suppose P is an augmenting path with a supply point b P ∈ B and a demand point a P ∈ A as its endpoints.

Original: Note that a P (resp.
Revised: Note that a P (resp.

Original: b P ) lies inside a deficit (resp.
Revised: b P ) lies inside a deficit (resp.

Original: surplus) cell of the grid, since a P (resp.
Revised: surplus) cell of the grid, since a P (resp.

Original: b P ) is a free point with respect to σ 1 .
Revised: b P ) is a free point with respect to σ 1 .

Original: Consider a transport plan σ ∗ 2 constructed as follows.
Revised: Consider a transport plan σ ∗ 2 constructed as follows.

Original: For each augmenting path P ∈ P , let □ a P (resp.
Revised: For each augmenting path P ∈ P , let □ a P (resp.

Original: □ b P ) denote the cell of the grid containing a P (resp.
Revised: □ b P ) denote the cell of the grid containing a P (resp.

Original: b P ).
Revised: b P ).

Original: The transport plan σ ∗ 2 transports β ( P ) supplies from c □ bP to c □ aP (see Figure A(a)).
Revised: The transport plan σ ∗ 2 transports β ( P ) supplies from c □ bP to c □ aP (see Figure A(a)).

Original: Since the augmenting paths in P transport all excess supplies from the surplus cells to the deficit cells, σ ∗ 2 is a valid transport plan for A ∪ B .
Revised: Since the augmenting paths in P transport all excess supplies from the surplus cells to the deficit cells, σ ∗ 2 is a valid transport plan for A ∪ B .

Original: Furthermore, since σ 2 is an ε/ 2 -close transport plan, w ( σ 2 ) ≤ w ( σ ∗ 2 )+ ε 2 ( U − U ′ ) .
Revised: Furthermore, since σ 2 is an ε/ 2 -close transport plan, w ( σ 2 ) ≤ w ( σ ∗ 2 )+ ε 2 ( U − U ′ ) .

Original: Next, we bound w ( σ ∗ 2 ) .
Revised: Next, we bound w ( σ ∗ 2 ) .

Original: Since the diameter of each cell is ε/ 2 ,
Revised: Since the diameter of each cell is ε/ 2 ,

Original: [Equation]
Revised: [Equation]

Original: The total supplies transported by σ ∗ 2 is (cid:80) P ∈P β ( P ) =
Revised: The total supplies transported by σ ∗ 2 is (cid:80) P ∈P β ( P ) =

Original: U − U ′ .
Revised: U − U ′ .

Original: Furthermore, for each augmenting path P , by the triangle inequality, ∥ a P − b P ∥ ≤ (cid:80) ( u,v ) ∈ P ∥ u − v ∥ .
Revised: Furthermore, for each augmenting path P , by the triangle inequality, ∥ a P − b P ∥ ≤ (cid:80) ( u,v ) ∈ P ∥ u − v ∥ .

Original: Therefore,
Revised: Therefore,

Original: [Equation]
Revised: [Equation]

Original: Since P is the set of augmenting paths in σ ∗ ⊕ σ 1 , the total cost of edges of the paths in P is at most w ( σ ∗ ) + w ( σ 1 ) .
Revised: Since P is the set of augmenting paths in σ ∗ ⊕ σ 1 , the total cost of edges of the paths in P is at most w ( σ ∗ ) + w ( σ 1 ) .

Original: Therefore,
Revised: Therefore,

Original: [Equation]
Revised: [Equation]

Original: Combining with w ( σ 1 ) ≤ ε 2 U
Revised: Combining with w ( σ 1 ) ≤ ε 2 U

Original: and w ( σ 2 ) ≤
Revised: and w ( σ 2 ) ≤

Original: ε 2 ( U − U ′ )
Revised: ε 2 ( U − U ′ )

Original: + w ( σ ∗ 2 ) , w ( σ
Revised: + w ( σ ∗ 2 ) , w ( σ

Original: [Equation]
Revised: [Equation]

Original: ( σ
Revised: ( σ

Original: [Equation]
Revised: [Equation]

Original: w ( σ
Revised: w ( σ

Original: [Equation]
Revised: [Equation]

Original: + ε ( U − U ′ )
Revised: + ε ( U − U ′ )

Original: ≤ w ( σ ∗ ) + εU.
Revised: ≤ w ( σ ∗ ) + εU.

Original: Thus, the reported cost is an ε -close 1 -Wasserstein distance.
Revised: Thus, the reported cost is an ε -close 1 -Wasserstein distance.

Original: [Figure]
Revised: [Figure]

Original: B M ISSING DETAILS OF S ECTION
Revised: B M ISSING DETAILS OF S ECTION

Original: In this section, we provide the details of the discussion on the quality of approximation in Section 3 and show that the cost computed by our 1 -Wasserstein algorithm is an O ( d log √ d/ε n ) - approximation of the optimal transport cost on the point set A ∪ B .
Revised: In this section, we provide the details of the discussion on the quality of approximation in Section 3 and show that the cost computed by our 1 -Wasserstein algorithm is an O ( d log √ d/ε n ) - approximation of the optimal transport cost on the point set A ∪ B .

Original: For any level i of the tree
Revised: For any level i of the tree

Original: T , recall that C i denotes the set of all cells at level i , the grid G i defines level i of T , and ℓ i is the cell-side-length of G i .
Revised: T , recall that C i denotes the set of all cells at level i , the grid G i defines level i of T , and ℓ i is the cell-side-length of G i .

Original: In the following, first in Lemma B.1, we show that the total cost of the transport plans computed at all cells at level h is O ( d log √ d/ε n ) w ( σ ∗ ) .
Revised: In the following, first in Lemma B.1, we show that the total cost of the transport plans computed at all cells at level h is O ( d log √ d/ε n ) w ( σ ∗ ) .

Original: Lemma B.1.
Revised: Lemma B.1.

Original: E [
Revised: E [

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: For any non-empty cell □ ∈ C h , σ □ moves the supplies or demands of the only point in V □ to c □ .
Revised: For any non-empty cell □ ∈ C h , σ □ moves the supplies or demands of the only point in V □ to c □ .

Original: Since the diameter of the cells at level h is √ dℓ h and by the linearity of expectation,
Revised: Since the diameter of the cells at level h is √ dℓ h and by the linearity of expectation,

Original: [Equation]
Revised: [Equation]

Original: Next, we bound E [ ℓ h ] .
Revised: Next, we bound E [ ℓ h ] .

Original: For any level i , ℓ i = 2( ε 4 √ d ) i .
Revised: For any level i , ℓ i = 2( ε 4 √ d ) i .

Original: Let C min denote the minimum distance between any pair of points in A ∪ B .
Revised: Let C min denote the minimum distance between any pair of points in A ∪ B .

Original: Suppose j is the lowest integer with 2 √ d ( ε 4 √ d ) j < C min ; i.e, the diameter of any cell with side-length 2( ε 4 √ d ) j is less than C min and no two points of A ∪ B can lie inside the same cell of a grid with cell-side-length 2( ε 4 √ d ) j .
Revised: Suppose j is the lowest integer with 2 √ d ( ε 4 √ d ) j < C min ; i.e, the diameter of any cell with side-length 2( ε 4 √ d ) j is less than C min and no two points of A ∪ B can lie inside the same cell of a grid with cell-side-length 2( ε 4 √ d ) j .

Original: Therefore, h ≤ j .
Revised: Therefore, h ≤ j .

Original: Since ∆( A ∪ B ) = n O (1) , we have j = ⌈ log 4 √ d ε 2 √ d C min ⌉ =
Revised: Since ∆( A ∪ B ) = n O (1) , we have j = ⌈ log 4 √ d ε 2 √ d C min ⌉ =

Original: O (log √ d/ε n ) .
Revised: O (log √ d/ε n ) .

Original: Let ( u, v ) be the closest pair of points in A ∪ B .
Revised: Let ( u, v ) be the closest pair of points in A ∪ B .

Original: Then, for any i , the probability Pr( h = i ) is at most the probability that the edge ( u, v ) crosses the grid G i , which is at most
Revised: Then, for any i , the probability Pr( h = i ) is at most the probability that the edge ( u, v ) crosses the grid G i , which is at most

Original: [Equation]
Revised: [Equation]

Original: Thus,
Revised: Thus,

Original: [Equation]
Revised: [Equation]

Original: Since w ( σ ∗ ) ≥ UC min ,
Revised: Since w ( σ ∗ ) ≥ UC min ,

Original: [Equation]
Revised: [Equation]

Original: Next, we describe the two steps of our analysis to show that for each level i < h , the expected cost of the transport plans computed at all cells of level i is O ( d ) w ( σ ∗ ) .
Revised: Next, we describe the two steps of our analysis to show that for each level i < h , the expected cost of the transport plans computed at all cells of level i is O ( d ) w ( σ ∗ ) .

Original: Assigning Budgets: For a level i < h , consider the grids G
Revised: Assigning Budgets: For a level i < h , consider the grids G

Original: i
Revised: i

Original: and G i +1 (this is defined since i < h ).
Revised: and G i +1 (this is defined since i < h ).

Original: For any edge ( a, b ) ∈
Revised: For any edge ( a, b ) ∈

Original: A × B with σ ∗ ( a, b ) > 0 , we define its budget ϕ
Revised: A × B with σ ∗ ( a, b ) > 0 , we define its budget ϕ

Original: i ( a, b ) as follows:
Revised: i ( a, b ) as follows:

Original: • Case 1: both a and b are inside the same cell of G
Revised: • Case 1: both a and b are inside the same cell of G

Original: i +1 :
Revised: i +1 :

Original: We set ϕ
Revised: We set ϕ

Original: i ( a, b ) = 0 .
Revised: i ( a, b ) = 0 .

Original: • Case 2: both a and b are inside the same cell of G i
Revised: • Case 2: both a and b are inside the same cell of G i

Original: but in different cells □ a and □ b of G i +1 :
Revised: but in different cells □ a and □ b of G i +1 :

Original: We set ϕ
Revised: We set ϕ

Original: i ( a, b ) = ( √ dℓ i +1 + ∥ c
Revised: i ( a, b ) = ( √ dℓ i +1 + ∥ c

Original: □ a − c □ b ∥ ) σ ∗ ( a, b ) .
Revised: □ a − c □ b ∥ ) σ ∗ ( a, b ) .

Original: Intuitively, this is the cost of moving from b to a via c □ b and c □ a . • Case 3: a and b lie inside different cells □ a and □ b of G i : We set ϕ
Revised: Intuitively, this is the cost of moving from b to a via c □ b and c □ a . • Case 3: a and b lie inside different cells □ a and □ b of G i : We set ϕ

Original: i ( a, b ) = ( √ dℓ i ) σ ∗ ( a, b ) .
Revised: i ( a, b ) = ( √ dℓ i ) σ ∗ ( a, b ) .

Original: Intuitively, this is the cost of moving a to c
Revised: Intuitively, this is the cost of moving a to c

Original: □ a and b to c □ b .
Revised: □ a and b to c □ b .

Original: Figure A(b) shows an example of each of the above three cases.
Revised: Figure A(b) shows an example of each of the above three cases.

Original: The following lemma relates the expected budget on any edge to its Euclidean cost.
Revised: The following lemma relates the expected budget on any edge to its Euclidean cost.

Original: Lemma B.2.
Revised: Lemma B.2.

Original: For any edge ( a, b ) ∈
Revised: For any edge ( a, b ) ∈

Original: A × B , E
Revised: A × B , E

Original: [ ϕ i ( a, b )]
Revised: [ ϕ i ( a, b )]

Original: = O ( d ) ∥ a − b ∥ σ ∗ ( a, b ) .
Revised: = O ( d ) ∥ a − b ∥ σ ∗ ( a, b ) .

Original: Proof.
Revised: Proof.

Original: The probability of a and b lying inside the same cell of G i but on different cells of G i +1 is no more than the probability of ( a, b ) crossing G i +1 .
Revised: The probability of a and b lying inside the same cell of G i but on different cells of G i +1 is no more than the probability of ( a, b ) crossing G i +1 .

Original: Therefore,
Revised: Therefore,

Original: [Equation]
Revised: [Equation]

Original: By triangle inequality, ∥ c □ a − c □ b ∥ ≤ √ dℓ i +1 + ∥ a − b ∥ .
Revised: By triangle inequality, ∥ c □ a − c □ b ∥ ≤ √ dℓ i +1 + ∥ a − b ∥ .

Original: In addition, for any j ≤ h , the probability that the edge ( a, b ) crosses the grid
Revised: In addition, for any j ≤ h , the probability that the edge ( a, b ) crosses the grid

Original: G j is Pr(( a, b ) crosses G j ) ≤ min { 1 , √ d ∥ a − b ∥ ℓ j } .
Revised: G j is Pr(( a, b ) crosses G j ) ≤ min { 1 , √ d ∥ a − b ∥ ℓ j } .

Original: Thus,
Revised: Thus,

Original: E [ ϕ i ( a, b )] ≤ Pr(( a, b ) crosses
Revised: E [ ϕ i ( a, b )] ≤ Pr(( a, b ) crosses

Original: [Equation]
Revised: [Equation]

Original: Using the linearity of expectation, the following is a straightforward corollary of Lemma B.2.
Revised: Using the linearity of expectation, the following is a straightforward corollary of Lemma B.2.

Original: Corollary B.3.
Revised: Corollary B.3.

Original: E [ (cid:80) ( a,b ) ∈
Revised: E [ (cid:80) ( a,b ) ∈

Original: A × B ϕ i ( a, b )]
Revised: A × B ϕ i ( a, b )]

Original: = O ( d ) w ( σ ∗ ) .
Revised: = O ( d ) w ( σ ∗ ) .

Original: Redistribution of Budgets to cells:
Revised: Redistribution of Budgets to cells:

Original: In this section, we distribute the total budget on all edges of σ ∗ to non-empty cells of G i and show that the budget assigned to any cell □ ∈ G i is at least w ( σ □ ) / 2 .
Revised: In this section, we distribute the total budget on all edges of σ ∗ to non-empty cells of G i and show that the budget assigned to any cell □ ∈ G i is at least w ( σ □ ) / 2 .

Original: For any cell □ at level i of T , we define a budget ϕ
Revised: For any cell □ at level i of T , we define a budget ϕ

Original: □ as follows.
Revised: □ as follows.

Original: For any edge ( a, b ) ∈
Revised: For any edge ( a, b ) ∈

Original: A × B with σ ∗ ( a, b ) > 0 , if
Revised: A × B with σ ∗ ( a, b ) > 0 , if

Original: • both a and b lies inside □ : We assign the entire budget of ( a, b ) , i.e, ϕ i ( a, b ) , to ϕ □ .
Revised: • both a and b lies inside □ : We assign the entire budget of ( a, b ) , i.e, ϕ i ( a, b ) , to ϕ □ .

Original: • only a or b is inside □ : We assign half the budget of ( a, b ) , i.e, ϕ i ( a, b ) / 2 , to ϕ □ .
Revised: • only a or b is inside □ : We assign half the budget of ( a, b ) , i.e, ϕ i ( a, b ) / 2 , to ϕ □ .

Original: It is easy to observe that the sum of the budget of all cells at level i of T is equal to the sum of the budget of all edges carrying a positive flow in σ ∗ .
Revised: It is easy to observe that the sum of the budget of all cells at level i of T is equal to the sum of the budget of all edges carrying a positive flow in σ ∗ .

Original: For any cell □ , the following lemma relates the cost of σ □ to the budget assigned to □ .
Revised: For any cell □ , the following lemma relates the cost of σ □ to the budget assigned to □ .

Original: Lemma B.4.
Revised: Lemma B.4.

Original: For any cell □ of T , w ( σ □ ) ≤ 2 ϕ □ .
Revised: For any cell □ of T , w ( σ □ ) ≤ 2 ϕ □ .

Original: Proof.
Revised: Proof.

Original: To prove the lemma, we show that there exists a transport plan σ ′ on the instance I □ that has a cost no more than ϕ □ .
Revised: To prove the lemma, we show that there exists a transport plan σ ′ on the instance I □ that has a cost no more than ϕ □ .

Original: Assuming this and considering that σ □ is a 2 -approximate transport plan on I □ , we get w ( σ □ ) ≤ 2 w ( σ ′ ) ≤ 2 ϕ □ , as desired.
Revised: Assuming this and considering that σ □ is a 2 -approximate transport plan on I □ , we get w ( σ □ ) ≤ 2 w ( σ ′ ) ≤ 2 ϕ □ , as desired.

Original: Let □ be a cell at level i of T .
Revised: Let □ be a cell at level i of T .

Original: Recall that
Revised: Recall that

Original: V □ = ( A ∪ B ) ∩ □ .
Revised: V □ = ( A ∪ B ) ∩ □ .

Original: For any point u ∈ V □ , let □ u be the child of □ that contains u .
Revised: For any point u ∈ V □ , let □ u be the child of □ that contains u .

Original: For any edge ( u, v ) with σ ∗ ( u, v ) > 0 , consider the following cases:
Revised: For any edge ( u, v ) with σ ∗ ( u, v ) > 0 , consider the following cases:

Original: • If u, v ∈ V □ and □ u ̸ = □ v , then σ ′ transports σ ∗ ( u, v ) supplies from c □ u to c □ v .
Revised: • If u, v ∈ V □ and □ u ̸ = □ v , then σ ′ transports σ ∗ ( u, v ) supplies from c □ u to c □ v .

Original: Note that the edge ( u, v ) contributes to ϕ □ by σ ∗ ( u, v )( √ dℓ i +

Revised: Note that the edge ( u, v ) contributes to ϕ □ by σ ∗ ( u, v )( √ dℓ i +

Original: + ∥ c □ u − c □ v ∥ ) , which is greater than the cost of transporting σ ∗ ( u, v ) supplies from c □ u to c □ v .
Revised: + ∥ c □ u − c □ v ∥ ) , which is greater than the cost of transporting σ ∗ ( u, v ) supplies from c □ u to c □ v .

Original: • If u ∈ V □ and v / ∈ V □ , then if u is a supply point, then σ ′ transports σ ∗ ( u, v ) supplies from c □ u to c □ .
Revised: • If u ∈ V □ and v / ∈ V □ , then if u is a supply point, then σ ′ transports σ ∗ ( u, v ) supplies from c □ u to c □ .

Original: Otherwise, u is a demand point and σ ′ transports σ ∗ ( u, v ) supplies from c □ to c □ u .
Revised: Otherwise, u is a demand point and σ ′ transports σ ∗ ( u, v ) supplies from c □ to c □ u .

Original: Note that ( u, v ) contributes to ϕ □ by σ ∗ ( u, v ) √ dℓ i 2 , which is at least the cost of transporting σ ∗ ( u, v ) supplies between c □ u and c □ .
Revised: Note that ( u, v ) contributes to ϕ □ by σ ∗ ( u, v ) √ dℓ i 2 , which is at least the cost of transporting σ ∗ ( u, v ) supplies between c □ u and c □ .

Original: • If u, v ∈ V □ and □ u = □ v or if u, v / ∈ V □ , then σ ′ do not transport any supplies to/from the points u and v .
Revised: • If u, v ∈ V □ and □ u = □ v or if u, v / ∈ V □ , then σ ′ do not transport any supplies to/from the points u and v .

Original: By the discussion above, the cost of σ ′ is no more than ϕ □ .
Revised: By the discussion above, the cost of σ ′ is no more than ϕ □ .

Original: However, σ ′ might not be a feasible transport plan for the instance I □ .
Revised: However, σ ′ might not be a feasible transport plan for the instance I □ .

Original: In that case, we can improve σ ′ as follows.
Revised: In that case, we can improve σ ′ as follows.

Original: If there exists two edges ( a, b ′ ) , ( a ′ , b ) ∈ A × B with positive flow in σ ∗ such that a, b ∈ V □ and a ′ , b ′ / ∈ V □ , then σ ′ transports supplies from c □ to c
Revised: If there exists two edges ( a, b ′ ) , ( a ′ , b ) ∈ A × B with positive flow in σ ∗ such that a, b ∈ V □ and a ′ , b ′ / ∈ V □ , then σ ′ transports supplies from c □ to c

Original: □ a and from c □ b to c □ , which can be replaced with a direct flow from c □ b to c
Revised: □ a and from c □ b to c □ , which can be replaced with a direct flow from c □ b to c

Original: □ a without increasing the cost of σ ′ .
Revised: □ a without increasing the cost of σ ′ .

Original: Similarly, if there exists any pair of points c u and c v where σ ′ transports flow both from c u to c v and from c v to c u , then cancelling the two flows with each other will not increase the cost of σ ′ .
Revised: Similarly, if there exists any pair of points c u and c v where σ ′ transports flow both from c u to c v and from c v to c u , then cancelling the two flows with each other will not increase the cost of σ ′ .

Original: The obtained transport plan is a feasible solution for the instance I □ with a cost w ( σ ′ ) ≤ ϕ □ .
Revised: The obtained transport plan is a feasible solution for the instance I □ with a cost w ( σ ′ ) ≤ ϕ □ .

Original: Combining Lemma B.1, Corollary B.3, and Lemma B.4, we get the following.
Revised: Combining Lemma B.1, Corollary B.3, and Lemma B.4, we get the following.

Original: [Equation]
Revised: [Equation]

Original: n ) w ( σ ∗ ) .
Revised: n ) w ( σ ∗ ) .

Original: Corollary B.5.
Revised: Corollary B.5.

Original: E [ (cid:80) □ ∈ T w ( σ □ )]
Revised: E [ (cid:80) □ ∈ T w ( σ □ )]

Original: = O
Revised: = O

Original: ( d log √ d/ε n ) w ( σ ∗ ) .
Revised: ( d log √ d/ε n ) w ( σ ∗ ) .

Original: C M ISSING DETAILS OF S ECTIONC. I NPUT T RANSFORMATION
Revised: C M ISSING DETAILS OF S ECTIONC. I NPUT T RANSFORMATION

Original: Let A ′ ∪ B ′
Revised: Let A ′ ∪ B ′

Original: be the input point set.
Revised: be the input point set.

Original: Similar to Agarwal et al.
Revised: Similar to Agarwal et al.

Original: (2022b)
Revised: (2022b)

Original: , we transform A ′ ∪ B ′ into another point set A ∪ B such that
Revised: , we transform A ′ ∪ B ′ into another point set A ∪ B such that

Original: (T1)
Revised: (T1)

Original: The coordinates of the points in A ∪ B are positive integers bounded by n O (1) , (T2)
Revised: The coordinates of the points in A ∪ B are positive integers bounded by n O (1) , (T2)

Original: Any optimal matching with respect to A ∪ B is a (1 + ε ) approximation for A ′ ∪ B ′ , and, (T3)
Revised: Any optimal matching with respect to A ∪ B is a (1 + ε ) approximation for A ′ ∪ B ′ , and, (T3)

Original: The cost of the optimal matching of A and B is at least 5 √ dn/ε and at most 5 d 3 / 2 n log n/ε .
Revised: The cost of the optimal matching of A and B is at least 5 √ dn/ε and at most 5 d 3 / 2 n log n/ε .

Original: The details of this transformation are as follows.
Revised: The details of this transformation are as follows.

Original: Suppose the hierarchical greedy paradigm described in Section 1, when applied to the input points A ′ ∪ B ′ , returns a value θ which is, in expectation, an O ( d log n ) -approximation of the cost of the optimal matching on A ′ ∪ B ′ .
Revised: Suppose the hierarchical greedy paradigm described in Section 1, when applied to the input points A ′ ∪ B ′ , returns a value θ which is, in expectation, an O ( d log n ) -approximation of the cost of the optimal matching on A ′ ∪ B ′ .

Original: Using θ , we can transform any point p ′
Revised: Using θ , we can transform any point p ′

Original: = ( p x 1 , . .
Revised: = ( p x 1 , . .

Original: , p x d ) ∈
Revised: , p x d ) ∈

Original: A ′ ∪ B ′ into another point p =
Revised: A ′ ∪ B ′ into another point p =

Original: ( ⌈ 5 d 3 / 2 n log n εθ p x 1 ⌉ , . .
Revised: ( ⌈ 5 d 3 / 2 n log n εθ p x 1 ⌉ , . .

Original: , ⌈ 5 d 3 / 2 n log n εθ p x d ⌉ ) to obtain a set of points A ∪ B .
Revised: , ⌈ 5 d 3 / 2 n log n εθ p x d ⌉ ) to obtain a set of points A ∪ B .

Original: If any pair of points ( a, b ) ∈ A × B map to the same location, we match the two and remove them from A ∪ B .
Revised: If any pair of points ( a, b ) ∈ A × B map to the same location, we match the two and remove them from A ∪ B .

Original: The resulting point set satisfies (T1)–(T3).
Revised: The resulting point set satisfies (T1)–(T3).

Original: C. R ETRIEVING AN APPROXIMATE BIPARTITE MATCHING
Revised: C. R ETRIEVING AN APPROXIMATE BIPARTITE MATCHING

Original: In this section, we show how to retrieve a matching M on the point set A ∪ B using an identical approach as described in Section 3.
Revised: In this section, we show how to retrieve a matching M on the point set A ∪ B using an identical approach as described in Section 3.

Original: We process the grids ⟨ G h , . . .
Revised: We process the grids ⟨ G h , . . .

Original: , G 1 ⟩ in the decreasing order of their level.
Revised: , G 1 ⟩ in the decreasing order of their level.

Original: For any cell □ of G h , we map the unique point in V □ to the center point c □ .
Revised: For any cell □ of G h , we map the unique point in V □ to the center point c □ .

Original: Inductively, assume that for a level i < h , after processing all non-empty cells of G i +1 , conditions (i)–(iii) defined in Section 3 hold for each cell of that grid.
Revised: Inductively, assume that for a level i < h , after processing all non-empty cells of G i +1 , conditions (i)–(iii) defined in Section 3 hold for each cell of that grid.

Original: For each non-empty cell □ of G i , we show how to process □ so that conditions (i)–(iii) hold for □ as well.
Revised: For each non-empty cell □ of G i , we show how to process □ so that conditions (i)–(iii) hold for □ as well.

Original: For any two children □ 1 , □ 2 ∈ C [ □ ] , we match σ □ ( c □ 1 , c □ 2 ) many unmatched points that are mapped to c □ 1 to the unmatched points that are mapped to c □ 2 .
Revised: For any two children □ 1 , □ 2 ∈ C [ □ ] , we match σ □ ( c □ 1 , c □ 2 ) many unmatched points that are mapped to c □ 1 to the unmatched points that are mapped to c □ 2 .

Original: Additionally, for any child □ 1 ∈ C [ □ ] with σ □ ( c □ 1 , c □ ) > 0 , we map σ □ ( c □ 1 , c □ ) unmatched points from c □ 1 to c □ .
Revised: Additionally, for any child □ 1 ∈ C [ □ ] with σ □ ( c □ 1 , c □ ) > 0 , we map σ □ ( c □ 1 , c □ ) unmatched points from c □ 1 to c □ .

Original: C. Q UALITY OF A PPROXIMATION
Revised: C. Q UALITY OF A PPROXIMATION

Original: In this section, we show that the cost returned by the algorithm is within an additive error of min { ε, ( d log log n ) w ( M ∗ ) } from the optimal matching cost.
Revised: In this section, we show that the cost returned by the algorithm is within an additive error of min { ε, ( d log log n ) w ( M ∗ ) } from the optimal matching cost.

Original: Consider any cell □ of G 1 .
Revised: Consider any cell □ of G 1 .

Original: Our algorithm first computes some matching M □ 1 by matching the points within each child of □ .
Revised: Our algorithm first computes some matching M □ 1 by matching the points within each child of □ .

Original: Then, it moves the unmatched points to the centers of the children of □ and compute a matching M □ 2 on this instance.
Revised: Then, it moves the unmatched points to the centers of the children of □ and compute a matching M □ 2 on this instance.

Original: Let w □ be the cost of the matching computed inside □ after transforming the points back to the original ones.
Revised: Let w □ be the cost of the matching computed inside □ after transforming the points back to the original ones.

Original: To show that the algorithm reports a ε -close matching cost, we show that for each non-empty cell □ of G 1 , w ( M □ 1 ) + w ( M □ 2 ) is within an additive error of | V □ | ℓ 1 ε from the optimal matching cost on V □ .
Revised: To show that the algorithm reports a ε -close matching cost, we show that for each non-empty cell □ of G 1 , w ( M □ 1 ) + w ( M □ 2 ) is within an additive error of | V □ | ℓ 1 ε from the optimal matching cost on V □ .

Original: Therefore, when transformed back to the original point sets in the unit hypercube, the additive error would be at most | V □ | ε , as desired.
Revised: Therefore, when transformed back to the original point sets in the unit hypercube, the additive error would be at most | V □ | ε , as desired.

Original: We use an identical discussion as Section A. Let m □ 1 be the size of the matching M □ 1 .
Revised: We use an identical discussion as Section A. Let m □ 1 be the size of the matching M □ 1 .

Original: Since the diameter of each child of □ is √ dℓ 2 , w ( M □ 1 ) ≤ m □ 1 √ dℓ 2 .
Revised: Since the diameter of each child of □ is √ dℓ 2 , w ( M □ 1 ) ≤ m □ 1 √ dℓ 2 .

Original: Furthermore, since the spread of the points in the instance created in the second step, as described above, is  √ dℓ 1 /ℓ 2 , the matching M □ 2 is obtained by computing a 1 √ dℓ 1 /ℓ 2 -close transport plan on points that are scaled by a factor of at most 1 √ d , which adds an additive error of ( | V □ | − m □ 1 ) ℓ 1 ℓ 1 /ℓ 2 .
Revised: Furthermore, since the spread of the points in the instance created in the second step, as described above, is at most √ dℓ 1 /ℓ 2 , the matching M □ 2 is obtained by computing a 1 √ dℓ 1 /ℓ 2 -close transport plan on points that are scaled by a factor of at most 1 √ dℓ 1 , which adds an additive error of ( | V □ | − m □ 1 ) ℓ 1 ℓ 1 /ℓ 2 .

Original: Finally, the cost of moving the unmatched points inside the children of □ to their centers is at most ( | V □ | − m □ 1 ) √ dℓ 2 .
Revised: Finally, the cost of moving the unmatched points inside the children of □ to their centers is at most ( | V □ | − m □ 1 ) √ dℓ 2 .

Original: Since ℓ 1 = √ dε δn and ℓ 2 = δ √ n , and considering the discussion in Section A, the additive error of our algorithm would be at most
Revised: Since ℓ 1 = √ dε δn and ℓ 2 = δ √ n , and considering the discussion in Section A, the additive error of our algorithm would be at most

Original: [Equation]
Revised: [Equation]

Original: Therefore, it suffices to show that the matching M is an O ( d log log n ) -approximate matching.
Revised: Therefore, it suffices to show that the matching M is an O ( d log log n ) -approximate matching.

Original: To do so, using an argument identical to Section 3, we can show that the total cost of the transport plans computed at all cells of level i (in expectation) is at most O ( d ) w ( M ∗ ) .
Revised: To do so, using an argument identical to Section 3, we can show that the total cost of the transport plans computed at all cells of level i (in expectation) is at most O ( d ) w ( M ∗ ) .

Original: Lemma C.1.
Revised: Lemma C.1.

Original: E [ (cid:80) □ ∈ C i w ( σ □ )] ≤ O ( d ) w ( M ∗ ) .
Revised: E [ (cid:80) □ ∈ C i w ( σ □ )] ≤ O ( d ) w ( M ∗ ) .

Original: Summing over all levels of T , we get the following corollary.
Revised: Summing over all levels of T , we get the following corollary.

Original: Corollary C.2.
Revised: Corollary C.2.

Original: E [ w ( M )] ≤ (cid:80) h − 1 i =1 E [ (cid:80) □ ∈ C i w ( σ □ )] ≤ O ( d log log n ) w ( M ∗ ) .
Revised: [Equation]

Original: C. E FFICIENCY OF OUR A LGORITHM
Revised: C. E FFICIENCY OF OUR A LGORITHM

Original: To analyze the running time of our algorithm, we first show that, with probability at least 1 − ε √ d , no edges of an optimal matching will cross G 1 and consequently, each child of □ ∗ contains an equal number of points of A and B .
Revised: To analyze the running time of our algorithm, we first show that, with probability at least 1 − ε √ d , no edges of an optimal matching will cross G 1 and consequently, each child of □ ∗ contains an equal number of points of A and B .

Original: In other words, all children of □ ∗ are neutral cells and the problem instance I □ ∗ is an empty instance.
Revised: In other words, all children of □ ∗ are neutral cells and the problem instance I □ ∗ is an empty instance.

Original: Lemma C.3.
Revised: Lemma C.3.

Original: Let M ∗ be an optimal matching on the point set
Revised: Let M ∗ be an optimal matching on the point set

Original: A ∪ B .
Revised: A ∪ B .

Original: Then, with probability at least 1 − ε/ √ d , no edge of M ∗ crosses G 1 .
Revised: Then, with probability at least 1 − ε/ √ d , no edge of M ∗ crosses G 1 .

Original: Proof.
Revised: Proof.

Original: Recall that ℓ 1 = 5 d 5 / 2 n log n/ε 2 .
Revised: Recall that ℓ 1 = 5 d 5 / 2 n log n/ε 2 .

Original: For any pair of points ( a, b ) ∈
Revised: For any pair of points ( a, b ) ∈

Original: A × B , the probability that the edge ( a, b ) crosses the grid G 1 is upper-bounded as follows.
Revised: A × B , the probability that the edge ( a, b ) crosses the grid G 1 is upper-bounded as follows.

Original: [Equation]
Revised: [Equation]

Original: Let X ( a,b ) be an indicator random variable where X ( a,b ) = 

Revised: Let X ( a,b ) be an indicator random variable where X ( a,b ) =

Original: if ( a, b ) crosses G 1 and X ( a,b ) =otherwise.
Revised: if ( a, b ) crosses G 1 and X ( a,b ) =otherwise.

Original: Clearly, E [ X ( a,b ) ] =
Revised: Clearly, E [ X ( a,b ) ] =

Original: Pr(( a, b ) crosses G 1 ) .
Revised: Pr(( a, b ) crosses G 1 ) .

Original: Define X
Revised: Define X

Original: =
Revised: =

Original: (cid:80) ( a,b ) ∈
Revised: (cid:80) ( a,b ) ∈

Original: M ∗ X ( a,b ) to be the number of edges of M ∗ crossing the grid G 1 .
Revised: M ∗ X ( a,b ) to be the number of edges of M ∗ crossing the grid G 1 .

Original: By linearity of expectation and Equation 1,
Revised: By linearity of expectation and Equation 1,

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where the last inequality follows from property (T3) in the input transformation.
Revised: where the last inequality follows from property (T3) in the input transformation.

Original: Therefore, with probability at least 1 − ε/ √ d , X = 0 and no edge of M ∗ crosses the grid G 1 .
Revised: Therefore, with probability at least 1 − ε/ √ d , X = 0 and no edge of M ∗ crosses the grid G 1 .

Original: Therefore, by constructing O (log √ d/ε n ) randomly-shifted hierarchical partitions, with high probability, in at least one partition, all children of the root are neutral cells.
Revised: Therefore, by constructing O (log √ d/ε n ) randomly-shifted hierarchical partitions, with high probability, in at least one partition, all children of the root are neutral cells.

Original: Assuming such partition, we show that for each 0 < i ≤ h , the algorithm requires O ( T ( n, ε/d )) time to process all cells at level i .
Revised: Assuming such partition, we show that for each 0 < i ≤ h , the algorithm requires O ( T ( n, ε/d )) time to process all cells at level i .

Original: Summing over all levels, the total running time of our algorithm is O
Revised: Summing over all levels, the total running time of our algorithm is O

Original: ( T ( n, ε/d ) log log n ) .
Revised: ( T ( n, ε/d ) log log n ) .

Original: Recall that C i denotes the set of cells of T at level i .
Revised: Recall that C i denotes the set of cells of T at level i .

Original: For any cell □ , recall that n □ denotes the number of points in I □ .
Revised: For any cell □ , recall that n □ denotes the number of points in I □ .

Original: Define n i = (cid:80) □ ∈ C i n □ .
Revised: Define n i = (cid:80) □ ∈ C i n □ .

Original: For any cell □ ∈ C i , the spread of the points in I □ is O ( dε n 1 / 2 i ) .
Revised: For any cell □ ∈ C i , the spread of the points in I □ is O ( dε n 1 / 2 i ) .

Original: Therefore, since T ( n, ε ) =
Revised: Therefore, since T ( n, ε ) =

Original: ˜ O ( n k /ε ) with k ≥ 1 , the execution time of our algorithm over all cells of level i is (cid:80) □ ∈ C i T ( n □ ,
Revised: ˜ O ( n k /ε ) with k ≥ 1 , the execution time of our algorithm over all cells of level i is (cid:80) □ ∈ C i T ( n □ ,

Original: [Equation]
Revised: [Equation]

Original: dn 1 / 2 i ) ≤ T ( n i
Revised: dn 1 / 2 i ) ≤ T ( n i

Original: [Equation]
Revised: [Equation]

Original: dn 1 / 2 i ) .
Revised: dn 1 / 2 i ) .

Original: Additionally, since n i ≤ n , we have E [ n ki ] ≤ n k − 1 E
Revised: Additionally, since n i ≤ n , we have E [ n ki ] ≤ n k − 1 E

Original: [ n i ] = (cid:16) E [ n i ] n (cid:17) n k .
Revised: [ n i ] = (cid:16) E [ n i ] n (cid:17) n k .

Original: Therefore, (cid:88) □ ∈ C
Revised: Therefore, (cid:88) □ ∈ C

Original: i
Revised: i

Original: [Equation]
Revised: [Equation]

Original: Next, we bound E [ n i ] .
Revised: Next, we bound E [ n i ] .

Original: For any cell □ and any child □ ′ ∈ C [ □ ] , the weight of c □ ′ in I □ is the minimum number of matching edges connecting a point inside □ ′ to a point out of it in any maximum matching.
Revised: For any cell □ and any child □ ′ ∈ C [ □ ] , the weight of c □ ′ in I □ is the minimum number of matching edges connecting a point inside □ ′ to a point out of it in any maximum matching.

Original: Summing over all cells of level i , n i is upper-bounded by the number of edge of M ∗ crossing the grid G
Revised: Summing over all cells of level i , n i is upper-bounded by the number of edge of M ∗ crossing the grid G

Original: i +1 .
Revised: i +1 .

Original: The following lemma bounds this number as a function of w ( M ∗ ) and ℓ i +1 .
Revised: The following lemma bounds this number as a function of w ( M ∗ ) and ℓ i +1 .

Original: Lemma C.4.
Revised: Lemma C.4.

Original: For any 0 < j < h , the expected number of matching edges in M ∗ crossing G j is at most √ dw ( M ∗ ) /ℓ
Revised: For any 0 < j < h , the expected number of matching edges in M ∗ crossing G j is at most √ dw ( M ∗ ) /ℓ

Original: j .
Revised: j .

Original: Proof.
Revised: Proof.

Original: For any edge ( a, b ) ∈ M ∗ , the probability that the edge ( a, b ) crosses the grid
Revised: For any edge ( a, b ) ∈ M ∗ , the probability that the edge ( a, b ) crosses the grid

Original: G j is Pr(( a, b ) crosses G j ) ≤ √ d ∥ a − b ∥ ℓ j .
Revised: G j is Pr(( a, b ) crosses G j ) ≤ √ d ∥ a − b ∥ ℓ j .

Original: Let X j ( a, b ) be an indicator random variable such that
Revised: Let X j ( a, b ) be an indicator random variable such that

Original: X j ( a, b ) =
Revised: X j ( a, b ) =

Original: if ( a, b ) crosses G j and X j ( a, b ) = 0 otherwise.
Revised: if ( a, b ) crosses G j and X j ( a, b ) = 0 otherwise.

Original: Thus, E [ X j ( a, b )] ≤
Revised: Thus, E [ X j ( a, b )] ≤

Original: [Equation]
Revised: [Equation]

Original: Define X j to be a random variable indicating the number of edges of M ∗ crossing G j ; i.e,
Revised: Define X j to be a random variable indicating the number of edges of M ∗ crossing G j ; i.e,

Original: X j = (cid:80) ( a,b ) ∈
Revised: X j = (cid:80) ( a,b ) ∈

Original: M ∗ X j ( a, b ) .
Revised: M ∗ X j ( a, b ) .

Original: Using the linearity of expectation, the expected value of X j is
Revised: Using the linearity of expectation, the expected value of X j is

Original: [Equation]
Revised: [Equation]

Original: By invoking Lemma C.4 with j = i + 1 , we get E [ n i ] ≤ √ dw ( M ∗ ) /ℓ
Revised: By invoking Lemma C.4 with j = i + 1 , we get E [ n i ] ≤ √ dw ( M ∗ ) /ℓ

Original: i +1 .
Revised: i +1 .

Original: By definition, ℓ i +

Revised: By definition, ℓ i +

Original: =
Revised: =

Original: δn 1 / 2 i and from property (3) of the input transformation, w ( M ∗ ) ≤ 5 d 3 / 2 n log n/ε .
Revised: δn 1 / 2 i and from property (3) of the input transformation, w ( M ∗ ) ≤ 5 d 3 / 2 n log n/ε .

Original: Plugging into
Revised: Plugging into

Original: Equation 2, the time taken to process all cells of level i is
Revised: Equation 2, the time taken to process all cells of level i is

Original: [Equation]
Revised: [Equation]

Original: as desired.
Revised: as desired.

Original: D A N I MPROVED R ELATIVE A PPROXIMATION A LGORITHM
Revised: D A N I MPROVED R ELATIVE A PPROXIMATION A LGORITHM

Original: In Lemma 2.2, we show that any ε -additive approximation algorithm for the 1 -Wasserstein problem with a running time of T ( n, ε ) can be used to obtain a (1 + ε ) -relative approximation algorithm in
Revised: In Lemma 2.2, we show that any ε -additive approximation algorithm for the 1 -Wasserstein problem with a running time of T ( n, ε ) can be used to obtain a (1 + ε ) -relative approximation algorithm in

Original: T ( n, ε/ ∆) time; here, ∆ is the spread of the input points.
Revised: T ( n, ε/ ∆) time; here, ∆ is the spread of the input points.

Original: Both of our algorithms in Section 3 and
Revised: Both of our algorithms in Section 3 and

Original: Section 4 use this lemma to obtain a 2 -approximate transport plan for the instance created for each cell.
Revised: Section 4 use this lemma to obtain a 2 -approximate transport plan for the instance created for each cell.

Original: Plugging the existing additive approximation algorithms, such as the algorithm by Lahn et al.
Revised: Plugging the existing additive approximation algorithms, such as the algorithm by Lahn et al.

Original: (2019), in Lemma 2.2 results in a quadratic running time for our algorithms for 1 -Wasserstein and
Revised: (2019), in Lemma 2.2 results in a quadratic running time for our algorithms for 1 -Wasserstein and

Original: EBM problems.
Revised: EBM problems.

Original: In this section, using the ideas mentioned in (Agarwal & Sharathkumar (2014);
Revised: In this section, using the ideas mentioned in (Agarwal & Sharathkumar (2014);

Original: Lahn & Raghvendra (2019)), we show that one can use an approximate dynamic nearest neighbor data structure (ANN) to improve the running time of our algorithms.
Revised: Lahn & Raghvendra (2019)), we show that one can use an approximate dynamic nearest neighbor data structure (ANN) to improve the running time of our algorithms.

Original: For demand points A and supply points B , let w ∗ denote the cost of the optimal transport plan on
Revised: For demand points A and supply points B , let w ∗ denote the cost of the optimal transport plan on

Original: A ∪ B .
Revised: A ∪ B .

Original: Let ( α, ε ) -approximate transport plan on A ∪ B be a transport plan σ satisfying w ( σ ) ≤ αw ∗ + ε .
Revised: Let ( α, ε ) -approximate transport plan on A ∪ B be a transport plan σ satisfying w ( σ ) ≤ αw ∗ + ε .

Original: Using an identical discussion as in Section 2.2, when points have a unit diameter, by setting ε = 1 / ∆ , the additive error of the transport plan will be at most w ∗ , and as a result, any ( α, 1 / ∆) - approximate transport plan is an ( α + 2) -relative approximate transport plan.
Revised: Using an identical discussion as in Section 2.2, when points have a unit diameter, by setting ε = 1 / ∆ , the additive error of the transport plan will be at most w ∗ , and as a result, any ( α, 1 / ∆) - approximate transport plan is an ( α + 2) -relative approximate transport plan.

Original: In this section, we modify the algorithm by Lahn et al.
Revised: In this section, we modify the algorithm by Lahn et al.

Original: (we refer to this algorithm by the LMR-Algorithm) to obtain an ( α, ε ) -approximate transport plan in ˜ O
Revised: (we refer to this algorithm by the LMR-Algorithm) to obtain an ( α, ε ) -approximate transport plan in ˜ O

Original: ( n Φ( n, α ) /ε ) time; here, ˜ O hides factors of poly log n  .
Revised: ( n Φ( n, α ) /ε ) time; here, ˜ O hides factors of poly(log n ) .

Original: Overview of the LMR-Algorithm: For input points A ∪ B of size n and diameter C , the LMRAlgorithm computes an ε -close transport plan on A ∪ B as follows.
Revised: Overview of the LMR-Algorithm: For input points A ∪ B of size n and diameter C , the LMRAlgorithm computes an ε -close transport plan on A ∪ B as follows.

Original: Initially, the distances are scaled by 4 /ε and rounded down so that the distance between any two points is an integer bounded by
Revised: Initially, the distances are scaled by 4 /ε and rounded down so that the distance between any two points is an integer bounded by

Original: O ( C/ε ) .
Revised: O ( C/ε ) .

Original: The LMR-Algorithm maintains a transport plan σ : A × B → R ≥ 0 and a set of integer dual weights y :
Revised: The LMR-Algorithm maintains a transport plan σ : A × B → R ≥ 0 and a set of integer dual weights y :

Original: A ∪ B → Z ≥ 0 for the points satisfying the following feasibility conditions.
Revised: A ∪ B → Z ≥ 0 for the points satisfying the following feasibility conditions.

Original: [Equation]
Revised: [Equation]

Original: The LMR-Algorithm runs in phases, where in each phase, similar to the algorithm by Gabow & Tarjan (1989), it executes a Hungarian search procedure followed by an execution of the DFS procedure to find a maximal set of vertex-disjoint admissible augmenting paths.
Revised: The LMR-Algorithm runs in phases, where in each phase, similar to the algorithm by Gabow & Tarjan (1989), it executes a Hungarian search procedure followed by an execution of the DFS procedure to find a maximal set of vertex-disjoint admissible augmenting paths.

Original: The algorithm then augments the transport plan σ using the set of computed augmenting paths.
Revised: The algorithm then augments the transport plan σ using the set of computed augmenting paths.

Original: The algorithm guarantees to increase the dual weight of each free point of B at each phase by at least 1 .
Revised: The algorithm guarantees to increase the dual weight of each free point of B at each phase by at least 1 .

Original: Additionally, each free point of A will have a zero dual weight at each phase.
Revised: Additionally, each free point of A will have a zero dual weight at each phase.

Original: Therefore, after 4 Cε + 2 phases, no point of
Revised: Therefore, after 4 Cε + 2 phases, no point of

Original: B can be a free point, because otherwise, if there exists a free point b ′ ∈ B and a free point a ′ ∈ A , y ( b ′ )
Revised: B can be a free point, because otherwise, if there exists a free point b ′ ∈ B and a free point a ′ ∈ A , y ( b ′ )

Original: − y ( a ′ ) >
Revised: − y ( a ′ ) >

Original: d ( a ′ , b ′ )
Revised: d ( a ′ , b ′ )

Original: + 1 , which violates the feasibility conditions.
Revised: + 1 , which violates the feasibility conditions.

Original: Therefore, after 4 Cε +phases, the LMR-Algorithm computes a complete ε -close transport plan (see Lemma 2.3 in (Lahn et al.
Revised: Therefore, after 4 Cε +phases, the LMR-Algorithm computes a complete ε -close transport plan (see Lemma 2.3 in (Lahn et al.

Original: Implementation of the LMR-Algorithm using the Partial DFS: As discussed by Lahn &
Revised: Implementation of the LMR-Algorithm using the Partial DFS: As discussed by Lahn &

Original: Raghvendra (2019), each phase of the Gabow-Tarjan’s algorithm can be implemented using an execution of the partial DFS procedure on the admissible graph.
Revised: Raghvendra (2019), each phase of the Gabow-Tarjan’s algorithm can be implemented using an execution of the partial DFS procedure on the admissible graph.

Original: In this implementation, in each phase, the algorithm iteratively initiates a partial DFS procedure from each free point b of B and maintains the search path Q = ⟨ b = u 0 , . . .
Revised: In this implementation, in each phase, the algorithm iteratively initiates a partial DFS procedure from each free point b of B and maintains the search path Q = ⟨ b = u 0 , . . .

Original: , u k ⟩ .
Revised: , u k ⟩ .

Original: To process the point u k , if u k is a free point of
Revised: To process the point u k , if u k is a free point of

Original: A , the algorithm has found an admissible augmenting path Q .
Revised: A , the algorithm has found an admissible augmenting path Q .

Original: In this case, it stops the partial DFS, augments the transport plan along Q as described in Section 2.1 in (Lahn et al.
Revised: In this case, it stops the partial DFS, augments the transport plan along Q as described in Section 2.1 in (Lahn et al.

Original: and initiates the next partial DFS.
Revised: and initiates the next partial DFS.

Original: Otherwise, if there is an admissible outgoing edge ( u k , v ) from u k , if v has not been processed yet, the algorithm adds v to the end of Q as u k +1 and starts processing v .
Revised: Otherwise, if there is an admissible outgoing edge ( u k , v ) from u k , if v has not been processed yet, the algorithm adds v to the end of Q as u k +1 and starts processing v .

Original: Finally, if there are no admissible outgoing edges from u k , the algorithm sets y ( u k ) ← y ( u k ) + 1 , marks u k as processed, remove u k from Q , and continue the search from u k − 1 .
Revised: Finally, if there are no admissible outgoing edges from u k , the algorithm sets y ( u k ) ← y ( u k ) + 1 , marks u k as processed, remove u k from Q , and continue the search from u k − 1 .

Original: Implementation of each phase using Approximate Nearest Neighbor data structure: Next, we discuss how to use an α -approximate dynamic nearest neighbor data structure ( α -ANN) to implement the partial DFS procedures more efficiently while introducing a factor of α in the approximation factor.
Revised: Implementation of each phase using Approximate Nearest Neighbor data structure: Next, we discuss how to use an α -approximate dynamic nearest neighbor data structure ( α -ANN) to implement the partial DFS procedures more efficiently while introducing a factor of α in the approximation factor.

Original: Note that the dual weight of each point is an integer between 0 and O ( C/ε ) ; i.e, there are only O ( C/ε ) unique dual weights.
Revised: Note that the dual weight of each point is an integer between 0 and O ( C/ε ) ; i.e, there are only O ( C/ε ) unique dual weights.

Original: Similar to Agarwal & Sharathkumar (2014), we define a set of α -feasibility conditions as follows.
Revised: Similar to Agarwal & Sharathkumar (2014), we define a set of α -feasibility conditions as follows.

Original: [Equation]
Revised: [Equation]

Original: Any complete α -feasible transport plan is an α -approximate transport plan.
Revised: Any complete α -feasible transport plan is an α -approximate transport plan.

Original: Next, we describe the modified implementation of the partial DFS.
Revised: Next, we describe the modified implementation of the partial DFS.

Original: We construct, for any y ′ ∈ [0 , ⌊ 4 Cε + 1 ⌋ ] , an α -ANN for the subset of points of A with dual weight y ′ .
Revised: We construct, for any y ′ ∈ [0 , ⌊ 4 Cε + 1 ⌋ ] , an α -ANN for the subset of points of A with dual weight y ′ .

Original: Suppose the partial DFS procedure has maintained a path Q = ⟨ u 0 , . .
Revised: Suppose the partial DFS procedure has maintained a path Q = ⟨ u 0 , . .

Original: , u k ⟩ and is processing u k .
Revised: , u k ⟩ and is processing u k .

Original: If u k is a free point of A , then we have found an augmenting path Q .
Revised: If u k is a free point of A , then we have found an augmenting path Q .

Original: We augment the transport plan along Q and add every point of A in Q to the αANN.
Revised: We augment the transport plan along Q and add every point of A in Q to the αANN.

Original: Otherwise, if u k ∈ A is not a free point, then we simply check all the neighbors of u k to find an admissible outgoing edge.
Revised: Otherwise, if u k ∈ A is not a free point, then we simply check all the neighbors of u k to find an admissible outgoing edge.

Original: Otherwise, u k ∈ B .
Revised: Otherwise, u k ∈ B .

Original: For any y ′ ∈ [0 , ⌊ 4 Cε + 1 ⌋ ] , we query the α -ANN corresponding to the points of A with dual weight y ′ to find an approximate nearest neighbor a of u k .
Revised: For any y ′ ∈ [0 , ⌊ 4 Cε + 1 ⌋ ] , we query the α -ANN corresponding to the points of A with dual weight y ′ to find an approximate nearest neighbor a of u k .

Original: If y ( u k ) − y ′
Revised: If y ( u k ) − y ′

Original: α ≤ d ( a, u k ) ≤
Revised: α ≤ d ( a, u k ) ≤

Original: y ( u k ) − y ′
Revised: y ( u k ) − y ′

Original: (successful query), we consider ( a, u k ) as an admissible edge and add a as u k +1 to the search path Q .
Revised: (successful query), we consider ( a, u k ) as an admissible edge and add a as u k +1 to the search path Q .

Original: We remove a from the α -ANN and continue the search.
Revised: We remove a from the α -ANN and continue the search.

Original: Otherwise, the returned point a has distance d ( a, u k ) >
Revised: Otherwise, the returned point a has distance d ( a, u k ) >

Original: y ( u k ) − y ′
Revised: y ( u k ) − y ′

Original: (unsuccessful query).
Revised: (unsuccessful query).

Original: If all O ( C/ε ) queries are unsuccessful, we set y ( u k ) ← y ( u k ) + 1 , mark u k as processed, and remove it from Q .
Revised: If all O ( C/ε ) queries are unsuccessful, we set y ( u k ) ← y ( u k ) + 1 , mark u k as processed, and remove it from Q .

Original: Next, we give a discussion on the running time of this algorithm.
Revised: Next, we give a discussion on the running time of this algorithm.

Original: While processing any point b ∈ B , for any successful query returning a point a , two cases might happen: (1) the algorithm removes the neighbor point a from Q without finding any augmenting paths, or (2) the algorithm finds an augmenting path.
Revised: While processing any point b ∈ B , for any successful query returning a point a , two cases might happen: (1) the algorithm removes the neighbor point a from Q without finding any augmenting paths, or (2) the algorithm finds an augmenting path.

Original: The first case happens once for each point of A in each phase and requires O ( nC/ε ) queries in total.
Revised: The first case happens once for each point of A in each phase and requires O ( nC/ε ) queries in total.

Original: The second case requires at most one query for each edge of each augmenting path, and by Lemma 2.4 in (Lahn et al.
Revised: The second case requires at most one query for each edge of each augmenting path, and by Lemma 2.4 in (Lahn et al.

Original: (2019)), requires O ( nC 2 /ε 2 ) queries in total.
Revised: (2019)), requires O ( nC 2 /ε 2 ) queries in total.

Original: Furthermore, in each phase, the search from b might result in at most O ( C/ε ) unsuccessful queries and O ( nC 2 /ε 2 ) queries in total.
Revised: Furthermore, in each phase, the search from b might result in at most O ( C/ε ) unsuccessful queries and O ( nC 2 /ε 2 ) queries in total.

Original: Processing all points of A requires searching for admissible edges among the edges with a positive flow, which by Lemma 2.4 in (Lahn et al.
Revised: Processing all points of A requires searching for admissible edges among the edges with a positive flow, which by Lemma 2.4 in (Lahn et al.

Original: (2019)) is at most O ( nC 2 /ε 2 ) over all phases.
Revised: (2019)) is at most O ( nC 2 /ε 2 ) over all phases.

Original: Finally, in each iteration, each point undergoes a dual-weight update at most once and there are O ( nC/ε ) updates in total.
Revised: Finally, in each iteration, each point undergoes a dual-weight update at most once and there are O ( nC/ε ) updates in total.

Original: Therefore, if Φ( α, n ) denotes the query/update time of an α -ANN on n points, this algorithm computes an ( α, ε ) -approximate transport plan in O ( nC 2 Φ( α,n ) ε) time.
Revised: Therefore, if Φ( α, n ) denotes the query/update time of an α -ANN on n points, this algorithm computes an ( α, ε ) -approximate transport plan in O ( nC 2 Φ( α,n ) ε) time.

Original: Extensions of our algorithms: In our algorithms, as in Section 2.2, we assume C = 1 .
Revised: Extensions of our algorithms: In our algorithms, as in Section 2.2, we assume C = 1 .

Original: Plugging ε = 1 / ∆ , we get the following lemma.
Revised: Plugging ε = 1 / ∆ , we get the following lemma.

Original: Lemma D.1.
Revised: Lemma D.1.

Original: There exists an algorithm that, given two point sets A and B in the d -dimensional unit hypercube with a spread of ∆ , computes an O ( α ) -approximate transport plan in O ( n ∆ 2 Φ( n, α )) time.
Revised: There exists an algorithm that, given two point sets A and B in the d -dimensional unit hypercube with a spread of ∆ , computes an O ( α ) -approximate transport plan in O ( n ∆ 2 Φ( n, α )) time.

Original: First, we extend our 1 -Wasserstein algorithm from Section 3 using the α -ANN data structure.
Revised: First, we extend our 1 -Wasserstein algorithm from Section 3 using the α -ANN data structure.

Original: Recall that for each cell □ , our algorithm creates instances I □ with a spread ∆ ≤ d/ε .
Revised: Recall that for each cell □ , our algorithm creates instances I □ with a spread ∆ ≤ d/ε .

Original: Recall that n □ denotes the number of points in the instance I □ .
Revised: Recall that n □ denotes the number of points in the instance I □ .

Original: Using Lemma D.1, we compute an O ( α ) -approximate transport cost on I □ in O ( d 2 n □ ε − 2 Φ( n, α )) time.
Revised: Using Lemma D.1, we compute an O ( α ) -approximate transport cost on I □ in O ( d 2 n □ ε − 2 Φ( n, α )) time.

Original: For any level of the hierarchical partitioning, the total size of instances created at all cells of that level is at most n .
Revised: For any level of the hierarchical partitioning, the total size of instances created at all cells of that level is at most n .

Original: Therefore, summing over all cells of the tree, we get the following result.
Revised: Therefore, summing over all cells of the tree, we get the following result.

Original: Theorem D.2.
Revised: Theorem D.2.

Original: There exists a randomized algorithm that, given two discrete distributions µ and ν in the d -dimensional unit hypercube with a spread of ∆ = n O (1) and a parameter ε > 0 , computes a O ( dα log √ d/ε n ) -approximate transport plan in O ( d 2 n Φ( n, α ) ε − 2 log √ d/ε n ) time.
Revised: There exists a randomized algorithm that, given two discrete distributions µ and ν in the d -dimensional unit hypercube with a spread of ∆ = n O (1) and a parameter ε > 0 , computes a O ( dα log √ d/ε n ) -approximate transport plan in O ( d 2 n Φ( n, α ) ε − 2 log √ d/ε n ) time.

Original: Next, we discuss the extension of our EBM algorithm.
Revised: Next, we discuss the extension of our EBM algorithm.

Original: To do so, first, we modify our hierarchical partitioning to obtain T ′ , as follows.
Revised: To do so, first, we modify our hierarchical partitioning to obtain T ′ , as follows.

Original: Define δ ′ :
Revised: Define δ ′ :

Original: = 10 d 2 ε − 1 log n .
Revised: = 10 d 2 ε − 1 log n .

Original: Similar to Section 4, we define the root cell of T ′ as a randomly-shifted cell □ ∗ that contains all points of A ∪ B and has a side-length of 2 max { C max , ℓ 1 /ε } ; here, ℓ 1 = δ ′ n .
Revised: Similar to Section 4, we define the root cell of T ′ as a randomly-shifted cell □ ∗ that contains all points of A ∪ B and has a side-length of 2 max { C max , ℓ 1 /ε } ; here, ℓ 1 = δ ′ n .

Original: For any cell □ of T ′ , if □ contains at most n ε/ 2 points of
Revised: For any cell □ of T ′ , if □ contains at most n ε/ 2 points of

Original: A ∪ B , then we designate □ as a leaf cell.
Revised: A ∪ B , then we designate □ as a leaf cell.

Original: Otherwise, let □ be a cell of level i .
Revised: Otherwise, let □ be a cell of level i .

Original: Define the grid
Revised: Define the grid

Original: G □ = G ( □ , δ ′ n (2 / 3) i ) and add the non-empty cells of G □ to T ′ as the children of □ .
Revised: G □ = G ( □ , δ ′ n (2 / 3) i ) and add the non-empty cells of G □ to T ′ as the children of □ .

Original: The height of
Revised: The height of

Original: T ′ is h
Revised: T ′ is h

Original: = O (log dε ) .
Revised: = O (log dε ) .

Original: Using a similar proof as in Lemma C.3, we can show that with probability at least 1 / 2 , no cell of level 1 is a surplus or deficit cell.
Revised: Using a similar proof as in Lemma C.3, we can show that with probability at least 1 / 2 , no cell of level 1 is a surplus or deficit cell.

Original: For any non-root cell □ of level i of T ′ , we construct an instance I □ identical to the one in Section 4.
Revised: For any non-root cell □ of level i of T ′ , we construct an instance I □ identical to the one in Section 4.

Original: The spread of the points in I □ is O ( √ d ℓ i ℓ i +1 )
Revised: The spread of the points in I □ is O ( √ d ℓ i ℓ i +1 )

Original: =
Revised: =

Original: O ( √ dn 13 .
Revised: O ( √ dn 13 .

Original: ( 23 ) i ) .
Revised: ( 23 ) i ) .

Original: Additionally, by invoking
Revised: Additionally, by invoking

Original: Lemma C.4 on level i cells, we have E [ n i ]
Revised: Lemma C.4 on level i cells, we have E [ n i ]

Original: =
Revised: =

Original: O ( √ dw ∗ ℓ i +1 )
Revised: O ( √ dw ∗ ℓ i +1 )

Original: =
Revised: =

Original: O ( n 1 − ( 23 ) i +1 ) .
Revised: O ( n 1 − ( 23 ) i +1 ) .

Original: Therefore, plugging
Revised: Therefore, plugging

Original: Lemma D.1 as the approximate solver of the instances, we get the following theorem.
Revised: Lemma D.1 as the approximate solver of the instances, we get the following theorem.

Original: Theorem D.3.
Revised: Theorem D.3.

Original: There exists an algorithm that, given two sets of samples A and B each from distributions µ and ν , where | A | = | B | = n , and a parameter ε > 0 , computes, with high probability, an
Revised: There exists an algorithm that, given two sets of samples A and B each from distributions µ and ν , where | A | = | B | = n , and a parameter ε > 0 , computes, with high probability, an

Original: O ( dα log dε ) -approximate matching in O ( dn Φ( n, α ) log dε + n 1+ ε ) time.
Revised: O ( dα log dε ) -approximate matching in O ( dn Φ( n, α ) log dε + n 1+ ε ) time.

Original: E A DDITIONAL E XPERIMENTS
Revised: E A DDITIONAL E XPERIMENTS

Original: In this section, we show the results of our additional experiments.
Revised: In this section, we show the results of our additional experiments.

Revised: In addition to the two datasets (15D and Real) introduced in Section 5, we use three more datasets in our experiments: (i) a uniform distribution inside a unit square (Uniform), (ii) 3 -dimensional Gaussian mixture with 2 mean points centered at (0 . 24 , 0 .

Revised: 24 , 0 . 24) and (0 . 72 , 0 .

Revised: 72 , 0 . 72) inside a unit cube (Bimodal), and (iii) a uniform distribution from inside a 2 -dimensional unit square placed on a random plane in 6 -dimensional space (6D).

Original: E. C OMPARISON WITH S INKHORN ALGORITHM
Revised: E. C OMPARISON WITH S INKHORN ALGORITHM

Original: To compare our algorithm with the Sinkhorn algorithm, we used four distributions: the uniform distribution in a 2 -dimensional unit square (2D), the adult census data in 6 dimensions (real), the uniform distribution on a 2 -dimensional unit square placed on a 6 -dimensional space (6D), and the uniform distribution on a 2 -dimensional unit square placed on a 15 -dimensional space (6D).
Revised: In this experiment [Figure] we want to determine [Figure]

Original: In this experiment, we wanted to determine, for any distribution and any fixed sample set drawn from that distribution, how long it takes for the Sinkhorn algorithm to compute a transport plan with a comparable cost to ours. 
Revised: for any distribution and any fixed sample set drawn from that distribution, how long it takes for the Sinkhorn algorithm to compute a transport plan with a comparable cost to ours. Using a binary search [Figure] we identify

Original: Using a binary search, we identify, for each sample set, the value of the regularization parameter η in the Sinkhorn algorithm that produces a cost that is nearly identical to the cost computed by our algorithm.
Revised: [Figure] for each sample set [Figure] the value of the regularization parameter η in the Sinkhorn algorithm that produces a cost that is nearly identical to the cost computed by our algorithm.

Original: Figure 4 depicts the results of this experiment.
Revised: Figure 4 depicts the results of this experiment.

Original: [Figure]
Revised: [Figure]

Original: parameter compute E. C OMPARISON WITH THE G EOMETRIC -A DDITIVE ALGORITHM
Revised: E. C OMPARISON WITH THE LMR ALGORITHM

Original: In this experiment, we compared the performance of our Wasserstein algorithm to that of Geometric Additive algorithm from Section 2.1 on the 2 -dimensional uniform distribution.
Revised: In this experiment

Original: For any set of samples S of size n drawn from the distribution, we searched for the smallest set of samples S ′ of size n ′ necessary for the Geometric-Additive algorithm such that the approximate Wasserstein distance of S ′ computed by the Geometric-Additive algorithm is equal to the cost computed by our Wasserstein algorithm on S . The outcomes are illustrated in Figure 5. E. C OMPARISON WITH OTHER ADDITIVE APPROXIMATION ALGORITHM
Revised: [Figure]

Original: In this experiment, we use the  algorithmby Lahn et al. (2019) (which we refer to as the LMRAlgorithm) to solve the instances that our algorithm generates at each cell.
Revised: we use the LMR algorithm as the blackbox solver in our 1 -Wasserstein algorithm.

Original: We compare our result with the result of applying the LMR-Algorithm on the entire point-set.
Revised: We compare our result with the result of applying the LMR algorithm on the entire pointset.

Revised: The

Original: The LMR-Algorithm takes an additive approximation parameter, ε , as its input parameter that affect its running time and output quality.
Revised: LMR algorithm takes an additive approximation parameter, ε , as its input parameter that affect its running time and output quality.

Original: For each dataset, we choose an additive approximation parameter for the LMRAlgorithm such that the cost returned by that algorithm is nearly equal to the cost computed by our 1-Wasserstein algorithm.
Revised: For each dataset, we choose an additive approximation parameter for the LMR algorithm such that the cost returned by that algorithm is nearly equal to the cost computed by our 1 -Wasserstein algorithm.

Original: Figure 6 shows the cost and running time plots of the executions of our algorithm and that of the LMR-Algorithm forall the four data sets we use in our experiments, i.e. Uniform, Bimodal, 15D-Uniform and the Real dataset.
Revised: Figure 5 shows the cost and running time plots of the executions of our algorithm and that of the LMR algorithm for the four data sets we use in our experiments, i.e. Uniform, Bimodal, 15D-Uniform and the Real dataset.

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: We can see in Figure 6 that while computing an almost same cost, the running time of our algorithm grows drastically slower than the LMR algorithm in all the cases.
Revised: We can see in Figure 5 that while computing an almost same cost, the running time of our algorithm grows drastically slower than the LMR algorithm in all the cases.

Revised: E. C OMPARISON WITH THE G EOMETRIC -A DDITIVE ALGORITHM

Revised: In this experiment we compared the performance of our 1 -Wasserstein and EBM algorithms to the

Revised: Geometric Additive algorithm from Section 2.1.

Revised: The results are illustrated in Figure 6.