Subquadratic Encodings for Point Configurations

For most algorithms dealing with sets of points in the plane, the only relevant information carried by the input is the combinatorial configuration of the points: the orientation of each triple of points in the set (clockwise, counterclockwise, or collinear). This information is called the order type of the point set. In the dual, realizable order types and abstract order types are combinatorial analogues of line arrangements and pseudoline arrangements. Too often in the literature we analyze algorithms in the real-RAM model for simplicity, putting aside the fact that computers as we know them cannot handle arbitrary real numbers without some sort of encoding. Encoding an order type by the integer coordinates of some realizing point set is known to yield doubly exponential coordinates in some cases. Other known encodings can achieve quadratic space or fast orientation queries, but not both. In this contribution, we give a compact encoding for abstract order types that allows efficient query of the orientation of any triple: the encoding uses O(n^2) bits and an orientation query takes O(log n) time in the word-RAM model. This encoding is space-optimal for abstract order types. We show how to shorten the encoding to O(n^2 (loglog n)^2 / log n) bits for realizable order types, giving the first subquadratic encoding for those order types with fast orientation queries. We further refine our encoding to attain O(log n/loglog n) query time without blowing up the space requirement. In the realizable case, we show that all those encodings can be computed efficiently. Finally, we generalize our results to the encoding of point configurations in higher dimension.

💡 Research Summary

**
The paper addresses a fundamental problem in computational geometry: how to store the order type of a planar point set compactly while still being able to answer orientation queries (i.e., the sign of the determinant for any triple of points) efficiently. An order type captures the combinatorial configuration of a point set by recording, for every unordered triple, whether the points are oriented clockwise, counter‑clockwise, or collinear. Although many geometric algorithms only need this combinatorial information, real‑RAM models assume exact real arithmetic, which is unrealistic for actual computers. Traditional ways of encoding order types either store all Θ(n³) orientation bits (far from optimal) or store a realizing set of coordinates. The latter can require doubly‑exponential coordinate sizes for some configurations, making it impractical. Prior compact encodings (e.g., λ‑matrices, wiring diagrams) achieve O(n² log n) bits but do not support sublinear query time.

The authors propose a new encoding framework based on hierarchical cuttings, a classic tool for divide‑and‑conquer in computational geometry. A 1/r‑cutting partitions the plane into O(r²) cells such that each cell is intersected by at most n/r of the input lines (or pseudolines). By recursively applying this construction, they obtain a hierarchy of depth O(log_r n). For each cell C and each line ℓ intersecting C, they store a constant‑size descriptor indicating whether ℓ lies entirely above C, below C, intersects the interior of C, or contains C. When ℓ does intersect C, they also store the two indices of ℓ’s intersections with the boundary of C in the cyclic order of all intersecting lines around C. This “cyclic permutation” completely determines the relative position of any two lines inside C without needing any real coordinates.

The encoding stores, for every cell‑line pair, a contiguous block of bits (the “signature” of the line in that cell). Because each line appears in only O(r² + r log (n r^i)) cells at level i, the total space across all levels sums to O(n²) bits for abstract order types. To answer a query (a,b,c), the algorithm first locates the cell where lines a and b intersect by descending the hierarchy (constant work per level). Once the cell is known, the stored descriptor for line c tells whether c lies above, below, or through that cell, which resolves the orientation. The recursion depth is O(log n), yielding O(log n) query time.

For realizable order types (those that can be represented by actual straight lines), the authors exploit additional structure to compress further. By choosing the cutting parameter r so that the number of lines intersecting any leaf cell, t = n r^ℓ, is bounded by O(log n / (log log n)²), the leaf cells become small enough that a naïve lookup table of size τ = O(t³) per leaf suffices. The total space then drops to O(n² · (log log n)² / log n) bits, which is sub‑quadratic and close to the information‑theoretic lower bound of Θ(n log n) for realizable order types. Moreover, by arranging signatures in word‑aligned blocks and using word‑parallel bit operations, the query time improves to O(log n / log log n) without increasing space.

The paper also discusses preprocessing. In the real‑RAM model (or the constant‑degree algebraic decision tree model), given the actual coordinates of the points, the hierarchical cutting and all signatures can be constructed in O(n²) time, which is polynomial and practical compared to earlier constructions that required higher complexity. This preprocessing bound holds for both abstract and realizable cases.

Finally, the authors generalize the approach to higher dimensions. In d‑dimensional space, the orientation of (d + 1) points is determined by the sign of a (d + 1) × (d + 1) determinant. By using d‑dimensional cuttings (cells are constant‑complexity polytopes) and storing the appropriate higher‑dimensional “permutations” of hyperplane intersections with cell boundaries, the same hierarchical scheme yields O(log n) query time with comparable space bounds, again achieving sub‑quadratic storage for realizable configurations.

In summary, the contributions are:

1. An optimal O(n²)‑bit encoding for abstract order types with O(log n) orientation queries, the first to achieve both optimal space and logarithmic query time simultaneously.
2. A sub‑quadratic O(n² · (log log n)² / log n)‑bit encoding for realizable order types, together with O(log n) and O(log n / log log n) query times, improving both space and time over previous work.
3. Efficient O(n²) preprocessing algorithms in realistic computation models.
4. A clear extension of the technique to higher dimensions.

These results bridge the gap between theoretical models that assume exact real arithmetic and practical implementations that must work with finite‑precision data, providing a compact, query‑efficient representation of the combinatorial essence of point configurations.