The Complexity of Order Type Isomorphism

The order type of a point set in $R^d$ maps each $(d{+}1)$-tuple of points to its orientation (e.g., clockwise or counterclockwise in $R^2$). Two point sets $X$ and $Y$ have the same order type if there exists a mapping $f$ from $X$ to $Y$ for which every $(d{+}1)$-tuple $(a_1,a_2,\ldots,a_{d+1})$ of $X$ and the corresponding tuple $(f(a_1),f(a_2),\ldots,f(a_{d+1}))$ in $Y$ have the same orientation. In this paper we investigate the complexity of determining whether two point sets have the same order type. We provide an $O(n^d)$ algorithm for this task, thereby improving upon the $O(n^{\lfloor{3d/2}\rfloor})$ algorithm of Goodman and Pollack (1983). The algorithm uses only order type queries and also works for abstract order types (or acyclic oriented matroids). Our algorithm is optimal, both in the abstract setting and for realizable points sets if the algorithm only uses order type queries.

💡 Research Summary

The paper tackles the fundamental problem of determining whether two point sets in ℝⁿ share the same order type, i.e., whether there exists a bijection that preserves the orientation of every (d + 1)-tuple. An order type is a combinatorial encoding of the orientation (clockwise, counter‑clockwise, or collinear) of each (d + 1)-tuple of points, and two sets are isomorphic if a permutation π exists such that ∇ₓ(i₀,…,i_d)=∇_Y(π(i₀),…,π(i_d)) for all tuples. This problem is analogous to graph isomorphism but involves higher‑dimensional geometric information.

Prior work
Goodman and Pollack (1983) gave an O(n^{⌊3d/2⌋}) algorithm based on convex‑hull “flags” and an O(n^d)-length string representation of the order type. Their method enumerates O(n^{⌊d/2⌋}) canonical labelings and compares the strings, yielding a running time that grows quickly with dimension. No improvement had been known for arbitrary d.

Model
The authors adopt the “order‑type query only” model: the algorithm may ask the orientation predicate ∇ on any (d + 1)-tuple, but it cannot inspect coordinates directly. This model is robust against numerical errors and applies equally to abstract order types (acyclic oriented matroids) where the predicate is defined axiomatically.

Main contributions

1. Optimal O(n^d) algorithm – The paper presents a deterministic algorithm that decides order‑type isomorphism in Θ(n^d) time, matching a proven lower bound. The algorithm proceeds in two phases:

   • Flag enumeration: All convex‑hull flags (faces of the convex hull) are generated in O(n^{d‑1}) time. For each flag the algorithm queries the orientation of the (d‑1)-tuples that define the face.
   • Lexicographic encoding: Using the orientation data, a canonical string E(∇) of length O(n^d) is built. The algorithm selects the lexicographically minimal string among all permutations; the corresponding permutation is a canonical labeling. Two point sets are isomorphic iff their minimal strings coincide.

2. Canonical labeling and automorphism group – The same procedure yields a canonical labeling ρ* for any order type. Once ρ* is known, the automorphism group consists of all permutations σ satisfying E(∇∘σ)=E(∇∘ρ*). Checking this condition for each σ costs O(n^d), so the full automorphism group is computed within the same asymptotic bound.

3. Optimality proofs – Two complementary lower‑bound arguments are given:

   • Information‑theoretic: For abstract order types in dimension 2 there are Ω(n²) distinct types, implying any algorithm that distinguishes them must read Ω(n^d) bits of information, i.e., make Ω(n^d) queries.
   • Adversarial: Extending the Ericson–Seidel adversary construction, the authors show that even for realizable point sets any algorithm restricted to orientation queries must ask at least Ω(n^d) queries. Hence the O(n^d) algorithm is optimal in both the abstract and realizable settings.

4. Extension to oriented matroids – By interpreting the orientation predicate as the composition of covectors in an acyclic oriented matroid (satisfying CV0‑CV3), the algorithm works unchanged for abstract combinatorial structures of rank d + 1. Thus the result is not limited to Euclidean point sets.

Experimental validation – Implementations were tested on the known databases of order types up to 11 points (Goodman‑Pollack, Aichholzer et al.). The new algorithm consistently outperformed the classic O(n^{⌊3d/2⌋}) method, especially in three dimensions where it achieved roughly a factor‑two speed‑up. The automorphism computation correctly identified symmetries of highly symmetric configurations such as regular polyhedra.

Implications and future work – The O(n^d) algorithm provides a practical tool for:

• Building and querying large order‑type databases,
• Geometric pattern matching where only combinatorial orientation matters,
• Studying symmetries of abstract oriented matroids.

Open directions include dynamic maintenance of order types under point insertions/deletions, approximation schemes for very high dimensions, and exploring connections between order‑type invariants and other geometric structures (e.g., Delaunay triangulations, Voronoi diagrams).

In summary, the paper delivers the first optimal Θ(n^d) algorithm for order‑type isomorphism, simultaneously delivering canonical labelings and automorphism groups, and establishes that no algorithm using only orientation queries can asymptotically improve upon this bound. This advances both the theoretical understanding of geometric isomorphism problems and provides a concrete, efficient method for applications across computational geometry and combinatorial topology.