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: A BSTRACT
Revised: A BSTRACT

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

Original: There are several algorithms that estimate W ( µ, ν ) within an additive error 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
Revised: We propose an algorithm that runs in

Original: O ( 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 ( µ, ν ) } .
Revised: O ( 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 the support of µ and ν 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 O ( T ( n, ε/d ) log log n ) time.
Revised: For the special case where every point in the support of µ and ν 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 O ( T ( n, ε/d ) log log n ) time.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Given two discrete probability distributions µ and ν whose support A and B , respectively, lie inside the d -dimensional unit hypercube [0 , 1] d with max {| A | , | B |} = n , the 1 -Wasserstein distance
Revised: Given two discrete probability distributions µ and ν whose support A and B , respectively, lie inside the d -dimensional unit hypercube [0 , 1] d with max {| A | , | B |} = n , the 1 -Wasserstein distance

Original: W ( µ, ν ) (also called the Earth Mover’s distance) between them is the minimum cost required to transport mass from ν to µ under the Euclidean metric.
Revised: W ( µ, ν ) (also called the Earth Mover’s distance) between them is the minimum cost required to transport mass from ν to µ under the Euclidean metric.

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: Computing the 1 -Wasserstein distance between µ and ν can be modeled as a linear program and solved in O ( n 3 log n ) time (Edmonds & Karp (1972);
Revised: Computing the 1 -Wasserstein distance between µ and ν can be modeled as a linear program and solved in O ( n 3 log n ) time (Edmonds & Karp (1972);

Original: Orlin (1988)), which is computationally expensive.
Revised: Orlin (1988)), which is computationally expensive.

Original: There has been substantial effort on designing ε -additive-approximation algorithms that estimate W ( µ, ν ) within an additive error of ε in n 2 poly( d, log n, 1 /ε ) time (Cuturi (2013); Lin et al.
Revised: There has been substantial effort on designing ε -additive-approximation algorithms that estimate W ( µ, ν ) within an additive error of ε in n 2 poly( d, log n, 1 /ε ) time (Cuturi (2013); Lin et al.

Original: ; Lahn et al.
Revised: ; Lahn et al.

Original: When W ( µ, ν ) is significantly smaller than ε , 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, for α > 0 , one can compute an α -relative approximation of the 1 -Wasserstein distance, which is a cost w that satisfies W ( µ, ν ) ≤ w ≤ α W ( µ, ν ) .
Revised: To get a higher accuracy in this case, for α > 0 , one can compute an α -relative approximation of the 1 -Wasserstein distance, which is a cost w that satisfies W ( µ, ν ) ≤ w ≤ α W ( µ, ν ) .

Original: There has been considerable effort on designing 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 on designing 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 slow in practice and difficult to implement, making them impractical (Agarwal & Sharathkumar (2014b);
Revised: Furthermore, they rely on fairly involved data structures that have good asymptotic execution times but are slow in practice and difficult to implement, 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 is a classical greedy algorithm, based on a d -dimensional quadtree, that returns an O ( d log n ) -relative approximation of the 1 -Wasserstein distance in O ( nd ) time.
Revised: The only exception to this is a classical greedy algorithm, based on a d -dimensional quadtree, that returns an O ( d log n ) -relative approximation of the 1 -Wasserstein distance in O ( nd ) time.

Original: It has been used in various machine-learning and computervision applications (Gupta et al.
Revised: It has been used in various machine-learning and computervision 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

Original: Matching, Agarwal & Varadarajan (2004) and Indyk (2007) generalized the algorithm in the hierarchical framework to achieve a relative approximation ratio of O
Revised: Matching, Agarwal & Varadarajan (2004) and Indyk (2007) generalized the algorithm in the hierarchical framework to achieve a relative approximation ratio of O

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

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

Original: In this paper, we design an algorithm that combines any additive approximation algorithm with the hierarchical quad-tree based framework.
Revised: In this paper, we design an algorithm that combines any additive approximation algorithm with the hierarchical quad-tree based framework.

Original: As a result, our algorithm achieves better guarantees for both additive and relative approximations.
Revised: As a result, our algorithm achieves 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: We are given two discrete distributions µ
Revised: We are given two discrete distributions µ

Original: and ν .
Revised: and ν .

Original: Let A and B be the points in the support of µ and ν , respectively.
Revised: Let A and B be the points in the support of µ 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 at the minimum cost.
Revised: In this problem, our goal is to transport all supplies from supply points to demand points at the 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 supplies transported along the edge.
Revised: G ( A, B ) indicating the quantity of supplies 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 colocated points.
Revised: In our presentation, we always consider A and B to be the point sets obtained after replacing all the colocated points.

Original: Observe that, after removing the co-located points, the total supply U =
Revised: Observe that, after removing the co-located points, the total supply U =

Original: η ( B ) may be less than 1 .
Revised: η ( B ) may be less than 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 computationally expensive or even impossible to compute
Revised: In such cases, it might be computationally expensive or even impossible to compute

Original: W ( µ, ν ) .
Revised: 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 Euclidean Bipartite Matching (EBM) problem.
Revised: This special case where every point has the same demand and supply is called the Euclidean Bipartite Matching (EBM) problem.

Original: A matching M is a set of vertex-disjoint edges in G ( A, B ) and has a cost 1 /n (cid:80) ( a,b ) ∈ M ∥ a − b ∥ .
Revised: A matching M is a set of vertex-disjoint edges in G ( A, B ) and has a cost 1 /n (cid:80) ( a,b ) ∈ M ∥ a − b ∥ .

Original: For the EBM problem, the optimal transport plan is simply a minimum-cost matching of cardinality n .
Revised: For 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 Monte-Carlo (1 + ε ) -relative approximation al- gorithms 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 Monte-Carlo (1 + ε ) -relative approximation al- gorithms 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 makes it unsuitable for higher dimensions.
Revised: Nonetheless, the exponential dependence on d makes it unsuitable for higher dimensions.

Original: For higher dimensions, a quad-tree based greedy algorithm provides an expected 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.

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

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

Original: Agarwal & Varadarajan (2004) combined a different hierarchical partition with an exact solver to get an expected 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: ; Chen et al.
Revised: ; Chen et al.

Original: There are also approximation algorithms that run in ˜ O
Revised: There are also 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 (2014b); 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 ˜
Revised: For input points within the unit hypercube, such an algorithm produces an ε -close transport plan in ˜

Original: O ( n 2 d/ε 2 ) time 2 (Lin et al.
Revised: O ( n 2 d/ε 2 ) time 2 (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 highly parallelizable.
Revised: Some of the additive approximation methods, including the Sinkhorn method, are 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 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 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: Given two discrete distributions µ and ν whose support lie in the d -dimensional unit hypercube and have spread n O (1) , and a parameter ε > 0 , a transport plan with an expected additive error of min { ε, ( d log √ d/ε n ) W ( µ, ν ) } can be computed in O ( T ( n, ε/d ) log √ d/ε n ) time; here, W ( µ, ν ) is the 1 -Wasserstein distance between µ and ν .
Revised: Given two discrete distributions µ and ν whose support lie in the d -dimensional unit hypercube and have spread n O (1) , and a parameter ε > 0 , a transport plan with an expected additive error of min { ε, ( d log √ d/ε n ) W ( µ, ν ) } can be computed in 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: Given two sets of n points A and B in the d -dimensional unit hypercube and a parameter ε > 0 , a matching whose expected cost is within an additive error of min { ε, ( d log log n ) w ∗ } of the optimal matching cost w ∗ can be computed in O ( T ( n, ε/d ) log log n ) time with high probability.
Revised: Given two sets of n points A and B in the d -dimensional unit hypercube and a parameter ε > 0 , a matching whose expected cost is within an additive error of min { ε, ( d log log n ) w ∗ } of the optimal matching cost w ∗ can be computed in O ( T ( n, ε/d ) log log n ) time with high probability.

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) runs in O (1 /ε ) phases, where each phase executes one iteration of Gabow-Tarjan’s algorithm.
Revised: (2019) runs in O (1 /ε ) phases, where each phase executes one iteration of Gabow-Tarjan’s algorithm.

Original: As shown by Agarwal & Sharathkumar (2014b), 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 1.2, we obtain the following relative-approximation algorithms.
Revised: Combining with the algorithms from Theorem 1.1 and 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 3 .

Original: Theorem 1.3.
Revised: Theorem 1.3.

Original: Let µ and ν be two discrete distributions whose support lie in the d -dimensional unit hypercube and have polynomial spread, and ε > 0 be a parameter.
Revised: Let µ and ν be two discrete distributions whose support lie in the d -dimensional unit hypercube and have polynomial spread, and ε > 0 be a parameter.

Original: An O ( d/ε 3 / 2 ) -approximate transport plan under Euclidean metric can be computed in O ( d 2 n 1+ ε /ε ) time.
Revised: An O ( d/ε 3 / 2 ) -approximate transport plan under Euclidean metric can be computed in O ( d 2 n 1+ ε /ε ) time.

Original: Theorem 1.4.
Revised: Theorem 1.4.

Original: Given two sets of n points A and B in the d -dimensional unit hypercube and a parameter ε > 0 , an O ( d √ ε log dε ) -approximate matching can be computed in O ( dn 1+ ε log dε ) time with high probability.
Revised: Given two sets of n points A and B in the d -dimensional unit hypercube and a parameter ε > 0 , an O ( d √ ε log dε ) -approximate matching can be computed in O ( dn 1+ ε log dε ) time with high probability.

Original: In contrast to our results, Agarwal & Varadarajan (2004) compute an O ( d 2 log 1 ε )
Revised: In contrast to our results, Agarwal & Varadarajan (2004) compute an O ( d 2 log 1 ε )

Original: -approximate matching in the same time.
Revised: -approximate matching in the same time.

Original: Therefore, our algorithm computes a more accurate matching for d > 1 √ ε .
Revised: Therefore, our algorithm computes a more accurate matching for 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 (2014b)).
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 computing transport plans under any ℓ p -metric in a straight forward way 3 .
Revised: We also note that all of our algorithms extend to computing transport plans under any ℓ p -metric in a straight forward way 4 .

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

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 □ = ( A ∪ B ) ∩ □ .
Revised: For any cell □ , let V □ = ( A ∪ B ) ∩ □ .

Original: Unlike a quadtree based greedy algorithm, which splits each cell □ into 2 d cells, we split it into min {| V □ | , (4 √ d/ε ) d } cells.
Revised: Unlike a quadtree based greedy algorithm, which splits 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
Revised: Let

Original: A □ (resp.
Revised: 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 B □ in T ( | V □ | , ε/d ) time.
Revised: Using an additive-approximation algorithm, we compute an ( ε/d ) -close transport cost between A □ and B □ in 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 perspective of relative-approximation algorithms, Agarwal & Varadarajan (2004) as well as Indyk (2007) have utilized a similar hierarchical framework to design approximation algorithms.
Revised: From the perspective of relative-approximation algorithms, Agarwal & Varadarajan (2004) as well as Indyk (2007) have utilized a similar hierarchical framework to design approximation algorithms.

Original: However, unlike our algorithm, they used an exact solver at each cell that takes Ω (cid:0) |A
Revised: However, unlike our algorithm, they used an exact solver at each cell that takes Ω (cid:0) |A

Original: □ ∪ B □ | 3 (cid:1) time.
Revised: □ ∪ B □ | 3 (cid:1) time.

Original: As a result, to obtain near-quadratic execution time, they divided every cell into O (cid:0) | V □ | 2 / 3 (cid:1) children, i.e., 1 /ε d ≤ n 2 / 3 or d = O (log 1 /ε n ) .
Revised: As a result, to obtain near-quadratic execution time, they divided every cell into O (cid:0) | V □ | 2 / 3 (cid:1) 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
Revised: This also forces the height of the tree to be

Original: O ( d log 1 /ε n ) , leading to an O ( d 2 log 1 /ε n ) -factor approximation.
Revised: 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: Using an additive-approximation algorithm at each cell increases the error that may be difficult to bound.
Revised: Technical Challenge: Using an additive-approximation algorithm at each cell increases the 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
Revised: In

Original: 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: 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: The algorithm guarantees that the spread of the point set at each cell □ is O ( d/ε ) , and as a result, we get a 2 -relative approximation by using an additive-approximation algorithm in O ( 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 2 -relative 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, we obtain an improvement in the approximation ratio, as stated in Theorem 1.2, as follows: Instead of dividing each cell into a fixed number  min { n, (4 √ d/ε ) d } of children, we divide it 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, we obtain an improvement in the approximation ratio, as stated in Theorem 1.2, as follows: Instead of dividing each cell into a fixed number a higher complexity min { n, (4 √ d/ε ) d } of children, we divide it 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 analyze 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 analyze 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: Open Question:
Revised: Open Question:

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

Original: Recently, Chen et al.
Revised: Recently, Chen et al.

Original: (2022) removed the dependence on the dimension d from the approximation factor of quad-tree greedy algorithm by using a data dependent weight assignment.
Revised: (2022) removed the dependence on the dimension d from the approximation factor of quad-tree greedy algorithm by using a data dependent weight assignment.

Original: It is an open question if their approach can be adapted in our framework leading to a similar improvement in the approximation factor of our algorithms.
Revised: It is an open question if their approach can be adapted in our framework leading to a similar improvement in the approximation factor of our algorithms.

Original:  P RELIMINARIES
Revised:  P RELIMINARIES

Original: We begin by introducing a few notations.
Revised: We begin by introducing a few notations.

Original: For a cell □ , we denote its side-length by ℓ □ and its center by c □ .
Revised: For a cell □ , we denote its side-length by ℓ □ and its center by c □ .

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

Original: Recall that V □ denotes the subset of A ∪ B that lies inside □ .
Revised: Recall that V □ denotes the subset of A ∪ B that lies inside □ .

Original: We say that □ is non-empty if V □ is non-empty.
Revised: We say that □ is non-empty if V □ is non-empty.

Original: Recall that η ( V □ ) =
Revised: Recall that η ( V □ ) =

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

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: We call a cell □ a deficit cell if η ( □ ) < 0 , a surplus cell if η ( □ ) > 0 , and a neutral cell if η ( □ ) = 0 .
Revised: We call a cell □ 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, we show how an additive-approximation algorithm for the 1 -Wasserstein problem can be used to obtain a (1 + ε ) -relative-approximation algorithm that runs in T ( n, ε/ ∆) time, where ∆ is the spread of input points.
Revised: Furthermore, we show how an additive-approximation algorithm for the 1 -Wasserstein problem can be used to obtain a (1 + ε ) -relative-approximation algorithm that runs in T ( n, ε/ ∆) time, where ∆ is the spread of input points.

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

Original: 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.
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 works in two steps.
Revised: The algorithm works in two steps.

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

Original: For each non-empty neutral cell of G , σ 1 arbitrarily transports all supplies to demands within the cell.
Revised: For each non-empty neutral cell of G , σ 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 a set of supply points B as follows:
Revised: In the second step, the algorithm constructs a set of demand points A and a set of 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 1Wasserstein problem.
Revised: Note that A ∪ B is a balanced instance for the 1Wasserstein problem.

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

Original: T ( |A| + |B| , ε/ 2) time (See Figure 1).
Revised: 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: Given two point sets A and B in the d -dimensional unit hypercube and a parameter ε > 0 , an ε -close transport cost can be computed in O (min { T ( n, ε 2 ) , n + T (( 2 √ dε ) d , ε 2 ) } ) time.
Revised: Given two point sets A and B in the d -dimensional unit hypercube and a parameter ε > 0 , an ε -close transport cost can be computed in O (min { T ( n, ε 2 ) , n + T (( 2 √ dε ) d , ε 2 ) } ) 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 that runs 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 that runs 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: Given two point sets A and B in the d -dimensional unit hypercube with a spread of ∆ , a (1 + ε ) -approximate transport plan can be computed in T ( n, ε/ ∆) time.
Revised: Given two point sets A and B in the d -dimensional unit hypercube with a spread of ∆ , a (1 + ε ) -approximate transport plan can be computed 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 our algorithm that satisfies the bounds presented in Theorem 1.1.
Revised: In this section, we present our algorithm that satisfies the bounds presented in Theorem 1.1.

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

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

Original: We partition each cell of side-length ℓ into ⌈ 4 √ d/ε ⌉ d cells of side-length at most ( ε/ 4 √ d ) ℓ .
Revised: We partition each cell of side-length ℓ into ⌈ 4 √ d/ε ⌉ d 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/ε ⌉ d cells and create a child node for each non-empty cell of this grid.
Revised: For any non-leaf cell □ , we construct its children by partitioning □ , using a grid G □ = G ( □ , ℓ □ /κ ) , into ⌈ 4 √ d/ε ⌉ d cells and create a child node for each non-empty cell of this grid.

Original: We denote the set of children of a non-leaf cell □ by C [ □ ] .
Revised: We denote the set of children of a non-leaf cell □ by C [ □ ] .

Original: Assuming the spread of A ∪ B is n O (1) , the height of T , denoted by h , is O (log √ d/ε n ) .
Revised: Assuming the spread of A ∪ B is n O (1) , the height of T , denoted by 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 a balanced instance I □ of the 1 -Wasserstein problem as follows.
Revised: 1 - Creating an instance at each cell: For each cell □ of T , we create a balanced instance I □ of the 1 -Wasserstein problem as follows.

Original: If □ is a leaf cell, then it contains a single point u of
Revised: If □ is a leaf cell, then it contains a single point u of

Original: A ∪ B , which we add to I □ .
Revised: A ∪ B , which we add to I □ .

Original: In addition, we add the center point c
Revised: In addition, we add the center point c

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

Original: Otherwise, □ is a non-leaf cell.
Revised: Otherwise, □ is a non-leaf cell.

Original: For any child □ ′ ∈ C [ □ ] , if □ ′ is a deficit or surplus cell, we add c □ ′ with a weight η ( □ ′ ) to I □ .
Revised: For any child □ ′ ∈ C [ □ ] , if □ ′ is a deficit or surplus cell, we add c □ ′ with a weight η ( □ ′ ) to I □ .

Original: The weight η ( □ ′ ) represents the excess demands or supplies of the points in V □ ′ .
Revised: The weight η ( □ ′ ) represents the excess demands or supplies of the points in V □ ′ .

Original: Furthermore, we add the center point c
Revised: Furthermore, we add the center point c

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

Original: The instance
Revised: The instance

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

Original: 2 - Estimating the 1 -Wasserstein distance: In this step, for the root cell □ ∗ , we compute an ε/d -close transport plan σ □ ∗ on I □ ∗ .
Revised: 2 - Estimating the 1 -Wasserstein distance: In this step, for the root cell □ ∗ , we compute an ε/d -close transport plan σ □ ∗ on I □ ∗ .

Original: Furthermore, for each cell □ at any level i > 0 , using the algorithm from Lemma 2.2, we compute a 2 -approximate transport plan σ □ on I □ .
Revised: Furthermore, for each cell □ at any level i > 0 , using the algorithm from 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 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 (the same bound holds for the root cell as well).
Revised: ( T ( n □ , ε/d )) time (the same bound holds for the root cell as well).

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: Quality of Approximation: In this part, we analyze the approximate 1 -Wasserstein distance computed by our algorithm.
Revised: Quality of Approximation: In this part, we analyze the approximate 1 -Wasserstein distance computed by our algorithm.

Original: First, we show that the reported cost is ε -close.
Revised: First, we show that the reported cost is ε -close.

Original: For the root cell □ ∗ , our algorithm computes an ε/d -close transport plan σ □ ∗ .
Revised: For the root cell □ ∗ , our algorithm computes an ε/d -close transport plan σ □ ∗ .

Original: The remaining demands and supplies are recursively transported within the children of □ ∗ , where each child has diameter ε/ 2 .
Revised: The remaining demands and supplies are recursively transported within the children of □ ∗ , where each child has diameter ε/ 2 .

Original: Therefore, similar to Section 2.1, we can argue that our algorithm reports an ε -close 1 -Wasserstein distance.
Revised: Therefore, 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: For each level i < h , we show that the expected cost of the transport plans computed for all cells of level i is E (cid:2)(cid:80) □ ∈ C i w ( σ □ ) (cid:3)
Revised: For each level i < h , we show that the expected cost of the transport plans computed for all cells of level i is E (cid:2)(cid:80) □ ∈ C i w ( σ □ ) (cid:3)

Original: =
Revised: =

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

Original: Here, σ ∗ is an optimal transport plan on A ∪ B ,
Revised: Here, σ ∗ is an optimal transport plan on A ∪ B ,

Original: C i denotes the set of non-empty cells of T at level i , and the expectation is over the choice of the random shift of the hierarchical partitioning.
Revised: C i denotes the set of non-empty cells of T at level i , and the expectation is over the choice of the random shift of the hierarchical partitioning.

Original: We bound E (cid:2)(cid:80) □ ∈ C i w ( σ □ ) (cid:3) in two steps as follows.
Revised: We bound E (cid:2)(cid:80) □ ∈ C i w ( σ □ ) (cid:3) 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)
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)

Original: O ( d ) w ( σ ∗ ) .
Revised: 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: Summing over all O (log √ d/ε n ) levels of T , the expected value of the total cost computed at all levels i < h is O
Revised: Summing over all O (log √ d/ε n ) levels of T , the expected value of the total cost computed at all levels i < h is O

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

Original: Additionally, we show that the expected cost of mapping all points to the centers of the cells of level h is O ( d log √ d/ε n ) w ( σ∗ ) . Details of each step is provided in Appendix B. Theorem 1.1 follows from combining the two bounds.
Revised: Additionally, we show that the expected cost of mapping all points to the centers of the cells of level h is O ( d log √ d/ε n ) w ( σ

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: Suppose A and B are two sets of n points inside the d -dimensional unit hypercube, where each point a ∈ A (resp.
Revised: Suppose A and B are two sets of n points inside the d -dimensional unit hypercube, where 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: In this section, we present an approximation algorithm for the EBM problem satisfying the bounds claimed in Theorem 1.2.
Revised: In this section, we present an approximation algorithm for the EBM problem satisfying the bounds claimed in Theorem 1.2.

Original: Note that by invoking Lemma 2.1 on A ∪ B , one can compute an ε -close transport cost on A ∪ B .
Revised: Note that by invoking Lemma 2.1 on A ∪ B , one can compute an ε -close transport cost on A ∪ B .

Original: To boost the accuracy of the algorithm of Lemma 2.1, in this section, we present an O ( d log log n ) - approximation algorithm for the EBM problem.
Revised: To boost the accuracy of the algorithm of Lemma 2.1, in this section, we present an O ( d log log n ) - approximation algorithm for the EBM problem.

Original: To satisfy the bounds claimed in Theorem 1.2, one can then report the minimum of the costs computed by the two algorithms.
Revised: To satisfy the bounds claimed in Theorem 1.2, one can then report the minimum of the costs computed by the two algorithms.

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 use any additive-approximation algorithm with a running time of T ( n, ε )
Revised: Our algorithm is easily adaptable to use any additive-approximation 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 height 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 height 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 ) at 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 ) at the first level.

Original: The grid G 1 may 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 G 1 may 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 } cells.
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 } cells.

Original: Although this results in a 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 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 ) 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 □ .

Original: For simplicity in presentation, we assume n 1 / 2 i is an integer.
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.
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.50 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 two sets of n samples taken from synthetic (distribution) and real-world data sets.
Revised: Datasets: We test our algorithms on two sets of n samples taken from synthetic (distribution) and real-world data sets.

Original: For each dataset, we use our algorithms to compute the minimum-cost matching between these samples and present our results averaged over 10 executions.
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: To generate the synthetic data, we sample from a uniform distribution inside a 2 -dimensional unit square placed on a random plane in 15 -dimensional space (15D).
Revised: To generate the synthetic data, we sample from a uniform distribution inside a 2 -dimensional unit square placed on a random plane in 15 -dimensional space (15D).

Original: For a real-world dataset, we use the Adult Census
Revised: For a real-world dataset, we use the Adult Census

Original: 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: 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: See Appendix E for the results of our experiments on additional datasets.
Revised: See Appendix E for the results of our experiments on additional datasets.

Original: Results:
Revised: Results:

Original: In our first experiment, we compare our algorithm with existing additive approximation schemes, namely the Sinkhorn method (Cuturi (2013))
Revised: In our first experiment, we compare our algorithm with existing additive approximation schemes, namely the Sinkhorn method (Cuturi (2013))

Original: (resp.
Revised: (resp.

Original: LMR algorithm
Revised: LMR algorithm

Original: (Lahn et al.
Revised: (Lahn et al.

Original: We use the Sinkhorn (resp.
Revised: We use the Sinkhorn (resp.

Original: LMR) algorithm as a black-box within our algorithm from Section( 1 -Wasserstein algorithm)
Revised: LMR) algorithm as a black-box within our algorithm from Section( 1 -Wasserstein algorithm)

Original: and compare its execution time with the standard Sinkhorn (resp.
Revised: and compare its execution time with the standard Sinkhorn (resp.

Original: LMR) implementation.
Revised: LMR) implementation.

Original: 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.
Revised: 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.

Original: As shown in Figure 2 (a)–(d), our algorithm runs significantly faster than both the Sinkhorn and the
Revised: As shown in Figure 2 (a)–(d), our algorithm runs significantly faster than both the Sinkhorn and the

Original: LMR algorithms while producing solutions of similar quality.
Revised: LMR algorithms while producing solutions of similar quality.

Original: 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.
Revised: 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.

Original: (Geometric-Additive algorithm).
Revised: (Geometric-Additive algorithm).

Original: For this experiment, our algorithms use the Sinkhorn algorithm as a black-box.
Revised: For this experiment, our algorithms use the Sinkhorn algorithm as a black-box.

Original: The results of this experiment are shown in Figure 2 (e)–(h).
Revised: The results of this experiment are shown in Figure 2 (e)–(h).

Original: We observe that our algorithms achieves a better accuracy (see Figure 2 (a) and (c)), especially on real-world data sets.
Revised: We observe that our algorithms achieves a better accuracy (see Figure 2 (a) and (c)), especially on real-world data sets.

Original: As expected, the execution time of our algorithms increase slightly (see Figure 2 (d)).
Revised: As expected, the execution time of our algorithms increase slightly (see Figure 2 (d)).

Original: Furthermore, we observe that as the sample size increases, the costs returned by our algorithms converge to the optimal cost, whereas the Geometric-Additive Approximation based 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 Approximation based approach does not.

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

Original: 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 .
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 .

Original: Furthermore, for an input of 1 .million points for the 15D dataset, our 1 -Wasserstein algorithm computes an approximate cost of 0 .
Revised: Furthermore, for an input of 1 .million points for the 15D dataset, our 1 -Wasserstein algorithm computes an approximate cost of 0 .

Original: 0304 in 608 seconds.
Revised: 0304 in 608 seconds.

Original: A CKNOWLEDGEMENT
Revised: A CKNOWLEDGEMENT

Original: We would like to acknowledge, Advanced Research Computing (ARC) at Virginia Tech, which provided us with the computational resources used to run the experiments.Research presented in this paper was funded by NSF CCF-1909171 and NSF CCF-2223871. We would like to thank the anonymous reviewers for their useful feedback. A M ISSING DETAILS OF S ECTION 2.
Revised: We would like to acknowledge, Advanced Research Computing (ARC) at Virginia Tech, which provided us with the computational resources used to run the experiments.

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

Original: 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.

Original: Suppose U 1 supplies are transported in this step.

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

Original: 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 .

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

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

Original: We define some notations that are used in the analysis.

Original: For any point set A ∪ B and any transport plan σ on A ∪ B , a 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.

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

Original: η ( b ) ).

Original: The transport plan σ is a partial transport plan if there exists free points in A ∪ B with respect to σ ; otherwise, σ is a complete transport plan .

Original: For any partial transport plan σ , let A σF (resp.

Original: B σF ) denote the set of free points of A (resp.

Original: B ) with respect to σ .

Original: For any free demand point a ∈ A σF (resp.

Original: free supply point b ∈ B σ F ), let η σ ( a ) (resp.

Original: η σ ( b ) ) denote the excess weight of a (resp.

Original: b ); i.e, the amount of demands of a (resp.

Original: supplies of b ) that is not transported by σ .

Original: More precisely, define η

Original: [Equation]

Original: Suppose σ ∗ denote an optimal transport plan on A ∪ B .

Original: In this section, we show that the reported cost is ε -close to the optimal transport cost; i.e, we show that w ( σ 1 ) + w ( σ 2 ) ≤ w ( σ ∗ ) + εU .

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

Original: Thus, it remains to bound the cost of σ 2 by w ( σ ∗ )

Original: + εU − εU 1 / 2 .

Original: We bound w ( σ 2 ) as follows.

Original: • First, in Lemma A.1, we show that there exists a transport plan σ F on the set of free points A σ 1 F ∪ B σ 1 F such that σ F transports all the excess weights η σ 1 ( · ) on the points in A σ 1 F ∪ B σ 1 F and has a cost of at most w ( σ ∗ ) + w ( σ 1 ) .

Original: Second, we transform σ F into a transport plan σ ∗ 2 on the instance A ∪ B and show, in Lemma A.2, that the cost of σ ∗ 2 is at most w ( σ F ) +

Original: ε 2 ( U − U 1 ) .

Original: • Finally, using the fact that σ 2 is an ε 2 -close transport plan on A ∪ B , we bound the cost of σ 2 by w ( σ ∗ 2 ) + ε 2 ( U − U 1 ) .

Original: Combining all the above mentioned bounds, we get

Original: [Equation]

Original: As mentioned earlier, w ( σ 1 ) ≤ ε 2 U 1 .

Original: Therefore,

Original: [Equation]

Original: , as desired.

Original: It remains to show the details of the steps of our analysis.

Original: In the following, first, we define some notations that are used in describing the steps of bounding w ( σ 2 ) .

Original: Then, we describe the details of each step of our analysis.

Original: Notations and definitions: Define σ ′ :

Original: = σ ∗ − σ 1 to be a function that assigns σ ′ ( a, b ) =

Original: σ ∗ ( a, b ) − σ 1 ( a, b ) to any pair of points ( a, b ) ∈

Original: A × B .

Original: The function σ ′ has the following properties:

Original: (1) (cid:80) b ′ ∈ B σ ′ ( a, b ′ ) =

Original: | η σ 1 ( a ) | for any a ∈ A σ 1 F and (cid:80) b ′ ∈ B σ ′ ( a, b ′ )

Original: [-= 
-]
Revised: [-= 
-]

Original: for any a ∈ A \ A σ 1 F , (2) (cid:80) a ′ ∈

Original: A σ ′ ( a ′ , b ) =

Original: η σ 1 ( b ) for any b ∈ B σ 1 F and (cid:80) a ′ ∈

Original: A σ ′ ( a ′ , b ) = 0 for any b ∈ B \ B σ 1 F .

Original: Consider a directed graph G on the point set A ∪ B formed as follows.

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

Original: A × B , if σ ′ ( a, b ) > 0 , then G contains an edge from b to a with a capacity σ ′ ( a, b ) , which we refer to by a forward edge .

Original: On the other hand, if σ ′ ( a, b ) < 0 , then G contains an edge from a to b with a capacity | σ ′ ( a, b ) | , which we refer to by a backward edge .

Original: For any demand point a ∈ A , we define the capacity of a , denoted by c ( a ) , to be c ( a ) =

Original: (cid:80) b ′ ∈ B σ ′ ( a, b ′ ) .

Original: Similarly, for any supply point b ∈ B , we define the capacity c ( b ) of b to be c ( b )

Original: =

Original: (cid:80) a ′ ∈

Original: A σ ′ ( a ′ , b ) .

Original: An augmenting path P with respect to σ 1 is any simple directed path in G from a free supply point b P ∈ B σ 1 F to a free demand point a P ∈

Original: A σ 1 F .

Original: Note that the edges of any augmenting path alternates between forward edges and backward edges.

Original: We define the capacity of P , denoted by β ( P ) , as

Original: [Equation]

Original: One can augment the transport plan σ 1 along the augmenting path P by setting σ 1 ( a, b ) ← σ 1 ( a, b ) + β ( P ) for any forward edge ( b, a ) ∈ P and σ 1 ( a, b ) ← σ 1 ( a, b ) − β ( P ) for any backward edge ( a, b ) ∈ P .

Original: As a result of the augmentation, the excess weights of the endpoints a P and b P reduce by β ( P ) .

Original: Equivalently, one can update the function σ ′ using P by setting σ ′ ( a, b ) ← σ ′ ( a, b ) − β ( P ) for any forward edge ( b, a ) ∈ P and σ ′ ( a, b ) ← σ ′ ( a, b ) + β ( P ) for any backward edge ( a, b ) ∈ P .

Original: Similar to augmenting paths, one can define an alternating cycle as a directed cycle C on the graph

Original: G .

Original: For any cycle C , we define the capacity of the cycle as β ( C ) =

Original: min ( a,b ) ∈ C {| σ ′ ( a, b ) |} .

Original: One can cancel by setting σ 1 ( a, b ) ← σ 1 ( a, b ) + β ( C ) for any forward edge ( b, a ) ∈ C and σ 1 ( a, b ) ← σ 1 ( a, b ) − β ( C ) for any backward edge ( a, b ) ∈ C .

Original: Equivalently, one can update σ ′ by setting σ ′ ( a, b ) ← σ ′ ( a, b ) − β ( C ) for any forward edge ( b, a ) ∈ C and σ ′ ( a, b ) ← σ ′ ( a, b )+ β ( C ) for any backward edge ( a, b ) ∈ C .

Original: Cancelling a cycle does not affect the capacity of the points; however, it reduces the capacity on the edges of the cycle.

Original: Computing the transport plan σ F : Recall that σ 1 is a partial transport plan and σ ∗ is an optimal transport plan on A ∪ B .

Original: In this part, we show that one can obtain a transport plan σ F on the point sets A σ 1 F ∪ B σ 1 F such that

Original: (i) σ F transports all excess weights η σ 1 ( · ) on the points in A σ 1 F ∪ B σ 1 F , and (ii) w ( σ F ) ≤ w ( σ ∗ ) + w ( σ 1 ) .

Original: Consider the transport σ F on A σ 1 F ∪ B σ 1 F constructed iteratively as follows.

Original: In each iteration, we find an augmenting path P from a free supply point b ∈ B σ 1 F to a free demand point a ∈ A σ 1 F in

Original: G .

Original: We update the function σ ′ using P and assign a transportation of β ( P ) supplies from b to a to the transport plan σ F .

Original: After enough iterations, there will be no remaining free points (the capacity of all points in A ∪ B will be 0 ) and the transport plan σ F would be a complete transport plan on

Original: A σ 1 F ∪ B σ 1 F with the weight function η σ 1 ( · ) .

Original: Figure 3(a) shows an example of σ F .

Original: To find an augmenting path, one can execute a DFS procedure from a free supply point b ∈ B σ 1 F on the graph G to find any free demand point a ∈ A σ 1 F .

Original: During the execution of the DFS procedure, if we find an alternating cycle (which happens when the DFS finds an edge to an already visited point), we can update σ ′ along the cycle right away, remove the points on the cycle from the search tree, and continue our search.

Original: For any point u ∈ A ∪ B visited by the DFS procedure, if u is not a free point (i.e, c ( u ) = 0 ), then the DFS has visited u using a directed edge to u .

Original: Since c ( u ) = 0 , there also exists an outgoing edge incident on u in G ; thus, the search cannot stop at a point that is not free.

Original: In other words, the DFS procedure, possibly after updating σ ′ along a set of cycles, finds an augmenting path.

Original: Analyzing the cost of σ F : Next, we show that the cost of σ F is bounded by w ( σ ∗ )

Original: + w ( σ 1 ) .

Original: For any augmenting path P from b P ∈ B σ 1 F to a P ∈

Original: A σ 1 F , by the triangle inequality, ∥ b P − a P ∥ ≤ (cid:80) ( u,v )

Original: ∈ P ∥

Original: u − v ∥ .

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

Original: A × B , let P ab denote the set of all augmenting paths containing the edge ( a, b ) .

Original: [Equation]

Original: [Figure]

Original: For any forward edge ( b, a ) in G , during the process of finding augmenting paths and updating σ ′ , we have iteratively decreased the value of σ ′ ( b, a ) while guaranteeing (by Equation 2) that σ ′ ( b, a ) ≥ 0 .

Original: Thus, (cid:80) P ∈ P ba β ( P ) ≤ σ ′ ( b, a ) =

Original: σ ∗ ( b, a ) − σ 1 ( b, a ) ≤ σ ∗ ( b, a ) .

Original: Similarly, for any backward edge ( a, b ) in G , we iteratively increase the value of σ ′ ( a, b ) while guaranteeing that σ ′ ( a, b ) ≤ 0 .

Original: As a result, (cid:80) P ∈ P ab β ( P ) ≤ − σ ′ ( a, b ) ≤ σ 1 ( a, b ) .

Original: Therefore, w ( σ F ) ≤ (cid:88) ( a,b ) ∈

Original: A × B (cid:88)

Original: P ∈P ab β ( P ) ∥ a − b ∥ = (cid:88) ( a,b ) ∈

Original: A × B : σ ′ ( a,b ) >

Original: ∥ a − b ∥ (cid:88)

Original: P ∈P ab β ( P ) + (cid:88) ( a,b ) ∈

Original: A × B : σ ′ ( a,b ) <

Original: ∥ a − b ∥ (cid:88)

Original: P ∈P ab β ( P ) ≤ (cid:88) ( a,b ) ∈

Original: A × B : σ ′ ( a,b ) >

Original: ∥ a − b ∥ σ ∗ ( a, b ) + (cid:88) ( a,b ) ∈

Original: A × B : σ ′ ( a,b ) <

Original: ∥ a − b ∥ σ 1 ( a, b ) ≤ w ( σ ∗ ) + w ( σ 1 ) .

Original: Lemma A.1.

Original: There exists a complete transport plan σ F on A σF ∪ B σF with the weight function η σ ( · ) such that w ( σ F ) ≤ w ( σ ∗ ) + w ( σ 1 ) .

Original: Computing the transport plan σ ∗ 2 : Using the transport plan σ F obtained in the previous step, in this step, we construct a transport plan σ ∗ 2 on A ∪ B as follows.

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

Original: A σ 1 F × B σ 1 F with σ F ( a, b ) > 0 , let □ a and □ b denote the cells of the grid containing a and b , respectively.

Original: Note that □ a (resp.

Original: □ b ) is a deficit (resp.

Original: surplus) cell, since □ a (resp.

Original: □ b ) contains a free demand point (resp.

Original: supply point) with respect to σ 1 .

Original: We assign a transportation of σ F ( a, b ) from c □ b to c

Original: □ a to the transport plan σ ∗ 2 .

Original: Note that σ ∗ 2 is a complete transport plan for A ∪ B .

Original: Figure 3(b) shows an example of σ ∗ 2 .

Original: This completes the construction of σ ∗ 2 .

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

Original: Since the diameter of each cell is ε/ 2 , by the triangle inequality,

Original: [Equation]

Original: Lemma A.2.

Original: Given a complete transport plan σ F on the set of free points A σ 1 F ∪ B σ 1 F with the weight function η F ( · ) , there exists a transport plan σ ∗ 2 on A ∪ B such that w ( σ ∗ 2 ) ≤ w ( σ F ) + ε 2 ( U − U 1 ) .

Original: This completes the description of the steps of our analysis.

Original: 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 .

Original: For any level i of the tree 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, 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

Original: i

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

Original: For any edge ( a, b ) ∈

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

Original: i ( a, b ) as follows:

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

Original: i +1 :

Original: We set ϕ

Original: i ( a, b ) = 0 .

Original: • 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 :

Original: We set ϕ

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

Original: □ 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 ϕ

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

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

Original: □ a and b to c □ b .

Original: Figure 4 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.

Original: Lemma B.1.

Original: For any edge ( a, b ) ∈

Original: A × B , E

Original: [ ϕ i ( a

Original: [Equation]

Original: [Equation]

Original: ∥ σ ∗

Original: [Equation]

Original: Proof.

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

Original: Furthermore, the probability that a and b lie inside different cells of G i is equal to the probability of ( a, b ) crossing the grid

Original: G i .

Original: Therefore,

Original: [Equation]

Original: By the triangle inequality,

Original: [Equation]

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

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

Original: Thus,

Original: [Equation]

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

Original: Corollary B

Original: [Equation]

Original: [Equation]

Original: 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 .

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

Original: □ as follows.

Original: For any edge ( a, b ) ∈

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

Original: • both a and b lie inside □ : We assign the entire budget of ( a, b ) (i.e, ϕ i ( a, b ) ) to ϕ □ . • only a or b is inside □ : We assign half the budget of ( a, b ) (i.e, ϕ i ( a, b ) / 2 ) to ϕ □ .
Revised: Research presented in this paper was funded by NSF grants CCF-1909171, CCF-2223871, IIS-1814493, CCF-2007556, and CCF-2223870.

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

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

Original: Lemma B.3.

Original: For any cell □ at a level i < h of T , w ( σ □ ) ≤ 2 ϕ □ .

Original: 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 ϕ □ .

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

Original: Recall that V □ =

Original: ( A ∪ B ) ∩ □ .

Original: 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:

Original: • 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 .

Original: • 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 .

Original: Note that ( u, v ) contributes to ϕ □ by σ ∗ ( u, v ) √ dℓ i 2 , which is greater than 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 .

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

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

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

Original: For any points a, b ∈ V □ and a ′ , b ′ / ∈ V □ such that σ ∗ ( a, b ′ ) , σ ∗ ( a ′ , b ) > 0 , the transport plan σ ′ transports supplies from c □ to c

Original: □ a and from c □ b to c □ , which we replace with a direct transportation from c □ b to c

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

Original: Similarly, for any pair of cell centers c u and c v in I □ , where σ ′ transports supplies both from c u to c v and from c v to c u , we replace them with a direct transportation of supplies from one to the other without increasing the cost of σ ′ .

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

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

Original: [Equation]

Original: Next, we show that the expected distortion cause by moving the points to the centers of the cells of G h is also bounded by O ( d log √ d/ε n ) w ( σ ∗ ) .

Original: 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 ,

Original: [Equation]

Original: Thus, it remains to bound the expected value of ℓ h .

Original: Lemma B.4.

Original: E [ ℓ h ] =

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

Original: Proof.

Original: For any level i , recall that ℓ i = 2( ε 4 √ d ) i . We bound the probability that h =
Revised: We would like to thank the anonymous reviewers for their useful feedback

Original: i as follows.

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

Original: Then, the probability that h

Original: = i is no more than the probability that u and v lie inside different cells of G i

Original: (i.e, the edge ( u, v ) crosses the grid G i ), which is at most

Original: [Equation]

Original: Define

Original: [Equation]

Original: =

Original: [Equation]

Original: d C min ⌉ , where C min denotes the distance of the closest pair of points in

Original: A ∪ B .

Original: Note that h ≤ h max , since the diameter of any cell with side-length ℓ h max = 2( ε 4 √ d ) h max 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 ℓ h max .

Original: Since the spread of A ∪ B is n O (1) , h max =

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

Original: Thus,

Original: [Equation]

Original: Plugging the expected value of ℓ h from Lemma B.4 into Equation 4,

Original: [Equation]

Original: where the last equality holds true since w ( σ ∗ ) ≥ UC min .

Original: The following is a straight-forward corollary from the combination of Equation 3 and Equation 5.

Original: Corollary B.5.

Original: E (cid:2)(cid:80) □ ∈ T w ( σ □ ) (cid:3) =

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

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

Original: Let A ′ ∪ B ′

Original: be the input point set.

Original: Similar to Agarwal et al.

Original: (2022b)

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

Original: (T1)

Original: 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)

Original: The cost of the optimal matching of A and B is at least 5 √ dn/ε and at most 5 d

Original: / 2 n log n/ε .

Original: The details of this transformation are as follows.

Original: Recall that the hierarchical greedy algorithm described in Section 1 computes, in expectation, an O ( d log n ) -approximation of the cost of the optimal matching.

Original: Suppose θ is the minimum value returned by O (log n ) independent executions of the hierarchical greedy algorithm on A ′ ∪ B ′ .

Original: Note that θ is an O ( d log n ) -approximation of the optimal matching cost with a high probability.

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

Original: = ( p x 1 , . .

Original: , p x d ) ∈

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

Original: ( ⌈ 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 .

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 .

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

Original: 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.

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

Original: , 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 □ .

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.

Original: 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 .

Original: 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

Original: In this section, we show that the cost returned by the algorithm is an O ( d log log n ) -approximate matching cost.

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 ∗ ) .

Original: Lemma C.1.

Original: E (cid:2)(cid:80) □ ∈ C i w ( σ □ ) (cid:3) ≤ O ( d ) w ( M ∗ ) .

Original: Summing over all O (log log n ) levels of T , we get the following corollary.

Original: Corollary

Original: [Equation]

Original: Furthermore, using an argument identical to Section 3, we can show that the expected cost of moving the points to the centers of the cells of the grid G h is O ( d log log n ) w ( M ∗ ) .

Original: Lemma C.3.

Original: E (cid:2)(cid:80) □

Original: [Equation]

Original: Thus, the computed cost would be an O ( d log log n ) -approximation of the optimal matching cost, in expectation.

Original: C. E FFICIENCY OF OUR A LGORITHM

Original: In this section, we analyze the efficiency of our EBM algorithm and show that the running time of our algorithm is O ( T ( n, ε/d ) log log n ) .

Original: To do so, first, in Lemma C.4, we show that for each non-zero level 0 < i ≤ h , the algorithm requires O ( T ( n, ε/d )) time to process all cells at level i .

Original: Summing over all levels 0 < i ≤ h , the total running time of our algorithm on all non-root cells is

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

Original: Second, in Lemma C.7, we show that, with probability at least 1 − ε √ d , no edges of an optimal matching will cross G 1 .

Original: In this case, all children of the root cell □ ∗ are neutral cells and the problem instance I □ ∗ is an empty instance.

Original: By constructing O (log √ d/ε n ) randomlyshifted hierarchical partitions, with a high probability, in at least one partition, all children of the root are neutral cells.

Original: Thus, with a high probability, we obtain a randomly shifted partition where no computation is needed for the root cell and the total running time of our algorithm would be

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

Original: We describe the details of each step in the following.

Original: Lemma C.4.

Original: For any level 0 < i ≤ h , our EBM algorithm processes all cells of level i in at most

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

Original: Proof.

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

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

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

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

Original: ˜ O ( n k /ε ) with k ≥ 1 , the execution time of our algorithm over all cells of level i is

Original: [Equation]

Original: Additionally, since n i ≤ n , we have E (cid:2) n ki (cid:3) ≤ n k − 1 E [ n i ] = (cid:16) E [ n i ] n (cid:17) n k .

Original: Therefore,

Original: [Equation]

Original: In Corollary C.6 below, we show that E [ n i ] ≤ n 1 − 12 i .

Original: Plugging into Equation 6, the time taken to process all cells of level i is

Original: [Equation]

Original: as desired.

Original: Next, we bound the expected value of 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 perfect 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

Original: i +1 .

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

Original: Lemma C.5.

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

Original: j .

Original: Proof.

Original: 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 .

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

Original: X j ( a, b ) =

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

Original: Thus, E [ X j ( a, b )] ≤ √ d ∥ a − b ∥ ℓ j .

Original: 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 ) ∈

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

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

Original: [Equation]

Original: By invoking Lemma C.5 on level i + 1 , as discussed above, E [ n i ] ≤ √ dw ( M ∗ ) /ℓ

Original: i +1 .

Original: [-By definition, ℓ i +
-]
Revised: [-By definition, ℓ i +
-]

Original: =

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

Original: Therefore,

Original: [Equation]

Original: Thus, we get the following corollary.

Original: Corollary C.6.

Original: For any 0 < j ≤ h , E [ n i ] ≤ n 1 − 12 i .

Original: Finally, we show that with probability at least 1 − ε/ √ d , no edges of an optimal matching M ∗ cross the grid G 1 .

Original: Lemma C.7.

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

Original: A ∪ B .

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

Original: Proof.

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

Original: 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.

Original: [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.

Original: Clearly, E (cid:2) X ( a,b ) (cid:3) =

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

Original: Define X

Original: =

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

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

Original: By the linearity of expectation and Equation 7,

Original: E [ X ]

Original: [Equation]

Original: (cid:88)

Original: [Equation]

Original: 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 .

Original: D A F ASTER R ELATIVE A PPROXIMATION A LGORITHM VIA A PPROXIMATE N EAREST N EIGHBOR

Original: Both of our algorithms in Section 3 and Section 4 build a hierarchical structure and create an instance of the optimal transport at each cell of this hierarchical structure.

Original: Our algorithms then use an additive approximation algorithm for each such instance to obtain a 2 -approximate transport plan (Lemma 2.2).

Original: In this section, we show that, instead of boosting the additive approximation, if we are only interested in achieving a relative approximation, it suffices if we find a certain bi-criteria approximate transport plan (defined below).

Original: In Euclidean setting, this bi-criteria approximate transport plan can be found significantly faster than additive approximate transport plans and therefore, we obtain faster execution times for our relative approximation algorithms (Theorems 1.3 and 1.4).

Original: Given µ (with support A ) and ν (with support B ), let w ∗ denote the cost of the optimal transport plan from µ to ν .

Original: [-For parameter ε > 
-]
Revised: [-For parameter ε > 
-]

Original: and α > 1 , 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 also an ( α + 2) -relative approximate transport plan.

Original: In the following, we show that ( α, ε ) -approximate transport plans can be computed efficiently in O (cid:16) nC 2 Φ( α,n ) ε(cid:17) time.

Original: We get the algorithms of Theorem 1.3 and 1.4 by simply replacing additive approximation algorithms used within the algorithms of Theorem 1.1 and

Original: Theorem 1.2, with a ( α, ε ) -approximation algorithm.

Original: In this section, we will adapt the additive approximation algorithm of Lahn et al.

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

Original: The execution time of this adaptation is ˜ O ( n Φ( n, α ) /ε 2 ) time which is significantly faster than the execution time of O ( n 2 /ε + n/ε 2 ) achieved by the LMR-algorithm; 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.

Original: 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/ε ) .

Original: Furthermore, all demands and supplies are scaled and rounded so that the total supplies and demands are integers and O ( n/ε ) .

Original: The LMR-algorithm then iteratively executes phases of the

Original: Gabow and Tarjan’s matching algorithm to match the demands to supplies.

Original: Within each phase, the dual weights of the free supply nodes increase by at least 1 .

Original: Using the fact that the largest edge cost is C/ε , the authors show that the algorithm transports all supplies in O ( C/ε ) phases.

Original: The algorithm then rescales the supplies and costs and maps the solution computed by this algorithm to an ε -close transport plan.

Original: As shown by Lahn & Raghvendra (2019), one can execute each phase of Gabow and Tarjan’s algorithm by simply implementing a partial-DFS procedure and adjusting the dual weights during the procedure.

Original: Such a partial-DFS based implementation raises the dual weight of each free supply node increases by exactly 1 .

Original: Using the arugments in Lahn et al.

Original: (2019), it follows that the algorithm transports all the supplies in O ( C/ε ) phases.

Original: In order to speed up a phase of Gabow and Tarjan’s algorithm, Agarwal and Sharathkumar Agarwal & Sharathkumar (2014a) relaxed the feasibility conditions to the following.

Original: [Equation]

Original: They showed how one can maintain these relaxed feasibility conditions and implement a partialDFS in O ( n Φ( n, ε )) time.

Original: Similar to this, we can relax the feasibility conditions for the LMR algorithm and then execute the phases of the LMR algorithm using an approximate nearest neighbor data structure.

Original: Consequently, we find an ( α, ε ) -approximate transport plan in O ( nC 2 Φ( n, ε ) /ε 2 ) time leading to Theorems 1.3 and 1.

Original: E A DDITIONAL E XPERIMENTS

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

Original: 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 .

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

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 6 -dimensional space (6D).

Original: E. C OMPARISON WITH S INKHORN ALGORITHM

Original: In this experiment, we want 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.

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

Original: Figure 5 depicts the results of this experiment.

Original: E. C OMPARISON WITH THE LMR ALGORITHM

Original: In this experiment, 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 pointset.

Original: In this experiment, we compared the execution time of our 1 -Wasserstein algorithm with the LMR algorithm when the two algorithms produce comparable costs.

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

Original: We can see in Figure 6 that while computing similar costs, the running time of our algorithm grows drastically slower than the LMR algorithm in all the cases.

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

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

Original: Geometric Additive algorithm from Section 2.1.

Original: The results are illustrated in Figure 7.

Original: [Figure]

Original: [Figure]

Original: [Figure]