Flowtree Algorithm Overview

Updated 26 January 2026

Flowtree algorithm is a set of methods using hierarchical tree metrics to approximate Wasserstein-1 distances and accelerate nearest neighbor search in optimal transport.
It employs random hierarchical partitioning (e.g., quadtrees and kd-trees) to embed Euclidean distances into tree metrics, ensuring logarithmic distortion bounds with high probability.
Variants of Flowtree extend to linear-time multiterminal flows and optimal classification tree learning, achieving significant computational speed-ups and robust approximation guarantees.

The Flowtree algorithm refers to several advanced methods in computational optimal transport, network flow, and combinatorial optimization that exploit hierarchical tree structures for significant gains in scalability and theoretical guarantees. This entry synthesizes the main branches of Flowtree research: (i) scalable nearest neighbor search via tree-based Wasserstein distance approximation (Backurs et al., 2019, Teshigawara et al., 19 Jan 2026), (ii) linear-time multiterminal tree flows (Xiao et al., 2016), and (iii) max-flow-based optimal classification tree learning (Aghaei et al., 2020). Instances across these domains all leverage tree metrics and recursive partitioning, but embody distinct algorithmic motifs and mathematical structures.

1. Optimal Transport Foundations and Wasserstein-1 Distance

The Wasserstein-1 (Earth Mover’s) distance quantifies the minimal cost required to “move” mass from one probability distribution $\mu$ to another $\nu$ over a finite metric space $(X, d_X)$ :

$W_1(\mu,\nu) = \min_{\tau \geq 0} \sum_{x,y \in X} \tau(x,y)d_X(x,y) \quad \text{s.t.} \quad \sum_y \tau(x,y) = \mu(x),\ \sum_x \tau(x,y) = \nu(y)$

This LP formulation, fundamental to optimal transport, is computationally intensive for large datasets or high-dimensional domains, as the feasible region scales superlinearly with support size.

Flowtree algorithms address the bottleneck by embedding the ground metric into randomized tree metrics, vastly accelerating approximate computations of $W_1$ with provable accuracy bounds (Backurs et al., 2019).

2. Random Hierarchical Partitioning and Tree-Based Embedding

Flowtree leverages quadtree (or generalized $2^d$ -ary) partitioning of Euclidean domains. Points $X \subset [0, \Phi]^d$ are recursively partitioned into hypercubes via random shifts until each cell contains a single point, forming a tree $T$ with $O(\log(d\Phi))$ height. Each edge connecting tree levels $\ell+1 \to \ell$ is assigned weight $2^\ell$ . The resulting tree metric $t(x, y)$ reflects the sum of edge weights along the unique path connecting $x$ and $y$ .

These embeddings guarantee low distortion:

$\mathbb{E}[t(x,y)] \leq O(\log(d\Phi))\,d_X(x,y), \quad t(x,y) \geq \frac{d_X(x,y)}{O(\log n \log(d\Phi))}$

The randomized nature ensures that, with high probability, contraction or expansion factors remain within logarithmic bounds for relevant pairs (Backurs et al., 2019). In high-dimensional regimes, standard quadtrees can become too shallow ( $O((\log N)/d)$ height), impairing partition granularity, a limitation addressed by kd-tree variants (Teshigawara et al., 19 Jan 2026).

3. Flowtree Algorithm for Nearest Neighbor Search in Optimal Transport

Flowtree for Wasserstein-1 nearest neighbor search operates in two distinct stages following tree embed preprocessing:

A. Tree-Optimal Transport Extraction

Given two sparse distributions $\mu, \nu$ (support size $s$ ), compute a greedy bottom-up matching of mass in tree $T$ . Each node collects unmatched mass from its children and matches as much as possible locally. The process guarantees that each mass pair is matched exactly once, maintaining sparsity.

Complexity: $O(s\log(d\Phi))$ for tree height $h$ .

B. Cost Evaluation in the Original Metric

For all pairs $(x, y)$ with positive flow, evaluate the actual metric cost:

$\widetilde{W}_1(\mu, \nu) = \sum_{x, y} f(x, y)\|x-y\|_2$

Complexity: $O(sd)$ , as calculation only involves $\ell_2$ distances between matched pairs.

Overall Query Time: $O(s(d + \log(d\Phi)))$ .

Pseudocode (abridged):

PREPROCESS(X):
    Randomly shift and build quadtree T over X.
    Store for each node the list of descendant leaves.

QUERY(mu, nu):
    f ← zero flow on T’s leaves
    For each node v in T, bottom-up:
        collect unmatched μ-mass and ν-mass from children
        greedily match as much as possible at v
        pass remainders to parent
    cost ← 0
    For each (x,y) with f(x,y)>0:
        cost += f(x,y) * d_X(x,y)
    return cost

4. Theoretical Guarantees, Limitations, and Extensions

Approximation: With probability $\geq 0.99$ over tree randomization, Flowtree returns an

$O(\log s \cdot \log(d\Phi))$

-approximate nearest neighbor for $W_1$ , independent of database size $n$ . In the uniform weight case, the bound tightens to $O(\log^2 s)$ (Backurs et al., 2019, Teshigawara et al., 19 Jan 2026).

Empirics: Evaluations on text (20 Newsgroups, Amazon reviews) and image (MNIST) domains show Flowtree per-query times in the $10^2$ ms range versus $10^3$ ms for quadratic exact solvers. In multi-stage pipelines (pruning $\to$ Flowtree $\to$ refinement), overall speed-ups up to $7.4\times$ at $90\%$ recall are reported.

Extensions: Substituting quadtrees with random partition trees (random projections, kd-trees) in kd-Flowtree enables deeper trees and maintains approximation guarantees in high dimensions; averaging over multiple trees mitigates variance (Teshigawara et al., 19 Jan 2026). For nonuniform weights, weighted-pigeonhole arguments preserve the $O(\log^2 s)$ guarantee.

5. Flowtree Algorithm in Integral Multiterminal Flows in Trees

The Flowtree label also denotes a linear-time solution ( $O(n)$ ) for optimizing multiterminal flows in undirected trees with integer capacities (Xiao et al., 2016). Under the min-cut/max-flow paradigm, the algorithm computes maximum multiflows between all unordered terminal pairs, matching min-cut values via dynamic programming over “blocking flow intervals.” For each edge $e$ , intervals $\Psi(e) = \langle a(e), b(e) \rangle$ enumerate achievable flows, recursively merged via

$\Psi(e_1) \otimes \Psi(e_2) = \{x_1 + x_2 - 2y\ |\ x_i \in \Psi(e_i),\ 0 \leq y \leq \min(x_1, x_2)\}$

with capping at capacities $c(e)$ .

After the bottom-up computation of intervals, a top-down pass instantiates concrete flow values, yielding a global optimal multiflow and corresponding minimum cut-system by reachability analysis in the residual graph.

6. Flowtree for Optimal Binary Classification Trees via Max-Flow Formulation

In the context of optimal classification trees, Flowtree refers to a strong mixed-integer programming (MIP) approach that encodes the routing of each data point through a decision tree as a flow network (Aghaei et al., 2020). Decision variables specify tree splits and labels, with flow variables $z^i_{uv}$ tracking classification paths for each datapoint $i$ . Constraints ensure proper branching and label assignment using flow conservation and branch-specific conditions; notably, no big- $M$ is used, yielding a substantially tighter LP relaxation.

The algorithm facilitates Benders’ decomposition, leveraging max-flow/min-cut duality. Each datapoint’s subproblem is a max-flow over the fixed tree structure, decomposing the main problem and enabling facet-defining cut generation in $O(d)$ time per cut. This results in significant computational improvements:

Method	Solve Speedup	Accuracy (max improvement)
LP-based Flowtree	$10$– $30\times$	Up to $+13.8\%$
Benders decomposition	Additional $2$– $3\times$	13/16 cases improved

This formalism dominates previous approaches, solves large instances efficiently, and achieves high statistical generalization under regularization (Aghaei et al., 2020).

7. Practical Considerations and Contemporary Developments

Randomization: Guarantees and performance hold with high probability over tree construction; ensemble approaches by averaging results from independently generated trees further stabilize results.
Dimensionality: In very high dimensions, quadtree-based Flowtree suffers from shallow tree depth, motivating adaptive methods as in kd-Flowtree.
Partition Strategies: Tree type choice (quadtree, kd-tree, projection tree) critically impacts performance, especially with fine-scale data.
Algorithmic Duality: Flowtree’s recursive and flow-based composition admits connections to duality, DP, and cut-system reconstruction across domains, showing versatility and breadth.

Flowtree algorithms represent a convergence of tree metric embeddings, optimal transport, structured network flow, and combinatorial optimization—yielding scalable, provably accurate solutions for high-dimensional search, multiterminal flows, and optimal tree induction. This intersection is a continuing focus of efficient algorithms for large-scale structured learning tasks.