Computing Maximal Layers Of Points in $E^{f(n)}$

In this paper we present a randomized algorithm for computing the collection of maximal layers for a point set in $E^{k}$ ($k = f(n)$). The input to our algorithm is a point set $P = {p_1,…,p_n}$ with $p_i \in E^{k}$. The proposed algorithm achieves a runtime of $O\left(kn^{2 - {1 \over \log{k}} + \log_k{\left(1 + {2 \over {k+1}}\right)}}\log{n}\right)$ when $P$ is a random order and a runtime of $O(k^2 n^{3/2 + (\log_{k}{(k-1)})/2}\log{n})$ for an arbitrary $P$. Both bounds hold in expectation. Additionally, the run time is bounded by $O(kn^2)$ in the worst case. This is the first non-trivial algorithm whose run-time remains polynomial whenever $f(n)$ is bounded by some polynomial in $n$ while remaining sub-quadratic in $n$ for constant $k$. The algorithm is implemented using a new data-structure for storing and answering dominance queries over the set of incomparable points.

💡 Research Summary

The paper addresses the problem of computing all maximal layers (also known as Pareto fronts or skyline layers) of a set P of n points in a k‑dimensional Euclidean space, where the dimension k is allowed to grow as a function f(n). A maximal layer M₁ consists of points that are not dominated by any other point (using the component‑wise ≥ relation); subsequent layers are defined recursively after removing the points of the previous layers. While the problem is well‑studied for fixed low dimensions (k ≤ 3) with Θ(n log n) algorithms, existing upper bounds for higher dimensions become quasi‑polynomial (e.g., O(n (log n)^{k‑1})) and deteriorate quickly when k grows beyond a logarithmic factor of n.

The authors propose a randomized algorithm that remains polynomial‑time for any k that is bounded by a polynomial in n, and becomes sub‑quadratic in n when k is constant. The algorithm consists of two main data structures:

1. Layer Index Tree (B) – a self‑balancing binary search tree whose in‑order nodes correspond to the maximal layers M₁,…,M_h (h = number of non‑empty layers). Points are processed in the order of a linear extension T of the partial order (obtained by sorting points according to their maximum coordinate). For each point p, a search in B determines the highest layer whose points dominate p; if none exists, a new right‑most node is created, representing a new layer.

2. Half‑Space Tree (HST) – a novel k‑dimensional tree used to store the points belonging to a single layer. Each node stores a point and has up to k children, each child representing a half‑space defined by a coordinate direction. The orthant function O(p,q) (a k‑bit vector) tells in which orthant q lies relative to p. The HST exploits the fact that if two points are incomparable, their orthant vectors differ from the all‑zero and all‑one vectors, meaning that at most k‑1 children can be relevant for a new insertion. The “Above(L,p)” query traverses the HST, following only those children whose half‑space direction is compatible with p, and stops when a dominating point is found or a leaf is reached. The “Insert(L,p)” operation inserts p into a leaf reached via a uniformly random choice among compatible children.

The algorithm proceeds point by point: for each point p, it performs a binary‑search‑tree lookup (cost O(log h) node visits) and at each visited node calls Above(L,p) on the associated HST. The cost of Above(L,p) depends on the width w of the partial order (size of the largest set of mutually incomparable points) because each HST contains at most w points. The authors denote this cost by t_a(w) and the cost of Insert by t_i(w), showing that t_i(w)=O(t_a(w)). By analyzing the random structure of HSTs, they bound t_a(w) ≈ O(k·w^{1‑1/ log k}) in expectation.

Two runtime regimes are derived:

• Random order input – When the point set is a random order (i.e., points are drawn uniformly from