Dynamic Maintenance of Half-Space Depth for Points and Contours

Half-space depth (also called Tukey depth or location depth) is one of the most commonly studied data depth measures because it possesses many desirable properties for data depth functions. The data depth contours bound regions of increasing depth. For the sample case, there are two competing definitions of contours: the rank-based contours and the cover-based contours. In this paper, we present three dynamic algorithms for maintaining the half-space depth of points and contours: The first maintains the half-space depth of a single point in a data set in $O(\log n)$ time per update (insertion/deletion) and overall linear space. By maintaining such a data structure for each data point, we present an algorithm for dynamically maintaining the rank-based contours in $O(n\cdot\log n)$ time per update and overall quadratic space. The third dynamic algorithm maintains the cover-based contours in $O(n\cdot \log^2 n)$ time per update and overall quadratic space. We also augment our first algorithm to maintain the local cover-based contours at data points while maintaining the same complexities. A corollary of this discussion is a strong structural result of independent interest describing the behavior of dynamic cover-based contours near data points.

💡 Research Summary

The paper addresses the problem of maintaining half‑space (Tukey) depth and its associated contour families in the plane under insertions and deletions of data points. Two contour definitions are considered: cover‑based contours, which are the boundaries of regions where the depth of any point in ℝ² is at least a given threshold, and rank‑based contours, which are convex hulls of the most central fraction of the data points. The authors present three dynamic algorithms with provable worst‑case guarantees.

The first algorithm maintains the half‑space depth of a single query point p in O(log n) time per update while using linear space. The data structure is based on a circular ordering of the data points around p; each direction corresponds to a half‑plane whose boundary passes through p and another data point. By storing the count of points in each half‑plane in a balanced binary search tree, a point insertion or deletion updates O(log n) counters, and the minimum count (the depth) can be retrieved in constant time from an auxiliary field. This structure is essentially the van Kreveld et al. planar subdivision tree, augmented for dynamic updates.

By constructing such a structure for every data point, the depth of all points can be kept up-to‑date. Using the depths, the rank‑based contours are obtained by sorting points by depth and recomputing the convex hull of the top α · n points. The hull can be updated in O(n log n) time per insertion/deletion, yielding an overall O(n log n) update time for the entire family of rank‑based contours, at the cost of O(n²) space (each point stores its own depth structure).

The third algorithm deals with cover‑based contours. The authors observe that in two dimensions each edge of a cover‑based contour lies on a line segment joining two data points, and the whole family of contours corresponds to the k‑levels of the arrangement of all such lines. They adapt the static algorithm of Edelsbrunner and Welzl (which builds the levels by a sweep) into a fully dynamic setting. The arrangement is represented by a level tree where each node stores the set of edges belonging to a particular level. An insertion or deletion of a point affects only O(n) lines, and each affected line updates O(log n) nodes in the level tree, leading to an O(n log² n) worst‑case update time. The space usage remains quadratic, O(n²), because the total number of possible edges is Θ(n²).

A notable side result is a structural theorem about local cover‑based contours near a data point. The theorem shows that after a single insertion or deletion, the set of edges incident to a given point can change only within a bounded region, implying that the contour geometry does not fluctuate arbitrarily. This property underlies the efficiency of the dynamic level‑tree maintenance.

Overall, the paper delivers the first dynamic algorithms for half‑space depth contours in the plane with provable sub‑quadratic update times, improving upon the static O(n²) baseline. The three algorithms together provide a toolkit: O(log n) updates for a single depth query, O(n log n) updates for all rank‑based contours, and O(n log² n) updates for the full set of cover‑based contours. These results open the door to real‑time statistical depth visualizations and to applications where data streams require continuous monitoring of centrality and outlier structure.