Soft Geometric Predicates

• Soft geometric predicates are formalisms that relax strict geometric decisions while preserving invariant properties like conservativeness and exact sign certification.
• They have practical applications in digital geometry, motion planning, and differentiable optimization, enabling efficient algorithms such as saturated subpath decomposition and arithmetic filtering.
• The approach underpins smooth relaxations and probabilistic models in varied domains, balancing computational tractability with rigorous geometric guarantees.

Soft geometric predicates are a family of formalisms that relax the use of rigid geometric decision procedures without abandoning structure. In digital geometry, the relaxation appears as predicate-agnostic but conservative tests on subpaths of a curve; in robust computational geometry, it appears as floating-point filters, symbolic perturbation, and indirect predicates that retain exact sign semantics; in differentiable geometry, it appears as smooth surrogates for signed distance, intersection, containment, and directional relations; in motion planning, it appears as conservative and convergent box classifiers; and in random geometric graphs, it appears as distance-dependent connection probabilities rather than hard thresholds (Feschet, 2018, Bartels et al., 2022, Luo et al., 3 Apr 2026, Zhou et al., 2019, Baker et al., 21 Jan 2026).

1. Formal scope and recurring ideas

The term covers several non-equivalent constructions, but they share a common pattern: the primitive geometric test is made more permissive, more modular, or more computationally tractable, while some structural guarantee is preserved. In one line of work, a predicate is simply a Boolean function on contiguous subpaths of a digital curve, and “softness” comes from allowing arbitrary geometric tests provided they are conservative under restriction to subpaths (Feschet, 2018). In another, a predicate remains a sign test of a polynomial expression, but a fast floating-point stage is allowed to answer only when accompanied by a certificate of correctness; otherwise computation falls back to stronger arithmetic (Bartels et al., 2022). In differentiable logic, the same idea is recast as smooth approximations that preserve optimization signals rather than exact signs (Luo et al., 3 Apr 2026).

Setting	Soft mechanism	Preserved guarantee
Digital curves	Conservative predicate on subpaths	Maximal saturated subpaths and linear-size decomposition
Robust predicates	Arithmetic filter with threshold	Returned sign is certified correct
Intermediate constructions	Indirect predicate on primitive elements	Exact sign despite approximate constructed coordinates
Motion planning	Conservative and convergent box classifier	Resolution-exact path or NO-PATH outcome
Random geometric graphs	Soft connection function $p(r/r_0)$	Entropy and degree remain geometry-dependent but analyzable

A common misconception is that softness is synonymous with heuristic approximation. The literature shows several stricter alternatives. Filtered predicates are soft only in their evaluation strategy, not in their mathematical output, because an accepted sign is guaranteed to equal the exact sign of the target expression (Bartels et al., 2022). By contrast, differentiable relaxations explicitly replace crisp semantics by smooth robustness objectives, and probabilistic graph models replace hard adjacency by Bernoulli trials with geometry-dependent probabilities (Luo et al., 3 Apr 2026, Baker et al., 21 Jan 2026).

2. Conservative predicates on digital curves

In the digital-plane formulation, a digital $\alpha$-path is a list of points $P=(p_0,\dots,p_n)$ in $\mathbb{Z}^2$ such that $p_i$ and $p_{i+1}$ are $\alpha$-adjacent and $p_i\neq p_{i+1}$. A subpath is a contiguous sublist $(p_i,\dots,p_j)$, and a geometric predicate is any Boolean map

$$\mathcal{P}:\mathcal{SP}(P)\to\{\mathrm{true},\mathrm{false}\}.$$

This framework generalizes the classical Tangential Cover, whose original predicate was “$\alpha$0 is a Digital Straight Segment,” to arbitrary predicates on subpaths (Feschet, 2018).

The key structural notion is conservativeness: $\alpha$1 A conservative predicate is therefore monotone under restriction to contiguous subpaths. The paper explicitly presents this as natural for digital straight segments, arcs of circles, arcs of parabolas, and thick or blurred segments, because a shorter contiguous piece of a valid primitive should remain valid. By contrapositive, once a subpath violates the predicate, no superpath containing it can recover validity (Feschet, 2018).

This monotonicity supports the notion of a saturated subpath: a subpath $\alpha$2 such that $\alpha$3 holds and no strict superpath of $\alpha$4 also satisfies $\alpha$5. Saturated subpaths are the inclusion-maximal valid pieces. The paper proves that any path with $\alpha$6 points has at most $\alpha$7 saturated subpaths, using an injective mapping from saturated subpaths to their middle points. On that basis it defines the Saturated Subpaths Decomposition, or generalized Tangential Cover, as the set of all saturated subpaths for $\alpha$8. The SSD algorithm computes exactly these saturated subpaths for any conservative predicate, and its running time is linear in the number of predicate checks; for constant-time incremental recognition, the overall complexity is linear in the input size (Feschet, 2018).

Several consequences matter for the broader concept of soft predicates. First, the decomposition algorithm is predicate-agnostic: the geometry resides inside $\alpha$9, while the traversal logic depends only on conservativeness. Second, the size bound is structural rather than model-specific. Third, the framework does not rely on adjacency in the usual geometric sense but only on the ordering of indices along the path, so the argument extends beyond simple connected digital curves. The paper also shows that the family of saturated subpaths induces a proper circular-arc graph under a canonical circular embedding of indices, giving a compact combinatorial representation of the decomposition (Feschet, 2018).

3. Arithmetic filters and exact sign computation

In computational geometry, a geometric predicate usually consists of evaluating the sign of an algebraic expression. The central problem is that floating-point evaluation may produce a wrong sign when the exact value is close to zero. Arithmetic filters address this by pairing an arithmetic engine with a threshold $P=(p_0,\dots,p_n)$0: if the rounded value $P=(p_0,\dots,p_n)$1 satisfies $P=(p_0,\dots,p_n)$2, then its sign is certified to equal the sign of the exact expression; otherwise the filter fails and a stronger arithmetic stage is invoked 9907029.

This model yields both deterministic correctness and a probabilistic analysis of how often the expensive stage is needed. For randomly chosen input points in a unit ball or unit cube with uniform density, the probability that the absolute value of the determinant for the which-side predicate is at most $P=(p_0,\dots,p_n)$3 is $P=(p_0,\dots,p_n)$4. For the insphere predicate it is $P=(p_0,\dots,p_n)$5 in dimension $P=(p_0,\dots,p_n)$6, $P=(p_0,\dots,p_n)$7 in dimension $P=(p_0,\dots,p_n)$8, and $P=(p_0,\dots,p_n)$9 in higher dimensions, with small constants reported in the paper [9907029]. A related note on arithmetic filters for the cosphericity predicate states that the relevant probability is $\mathbb{Z}^2$0, improving previous bounds [9907028].

A later synthesis of this approach appears in a C++ meta-programming framework for arbitrary polynomial predicates. That framework combines filtering, branch reduction, and overflow avoidance, and generates robust predicates from polynomial expressions. It treats 2D orientation, 2D incircle, 3D orientation, and higher-degree predicates in a uniform manner. The runtime structure remains the canonical soft-predicate pipeline: a fast approximate stage with a certified bound, then interval or exact fallback only when the bound is inconclusive (Bartels et al., 2022).

Deterministic symbolic perturbation extends the same philosophy to degenerate polynomial predicates. A deterministic pseudorandom perturbation scheme replaces the input $\mathbb{Z}^2$1 by

$\mathbb{Z}^2$2

where the $\mathbb{Z}^2$3 are ordered infinitesimals and the $\mathbb{Z}^2$4 are pseudorandom but deterministic vectors. The sign of a polynomial predicate is then taken from the first non-zero infinitesimal coefficient. The method accepts black-box polynomial predicates, is deterministic, does not require algorithmic restart, and scales reasonably with polynomial degree even for fully degenerate input (Irving et al., 2013).

The cumulative picture is that softness in robust geometric computing is not defined by a loss of exactness. It is defined by staged evaluation, algebraic certification, and carefully controlled degeneracy handling.

4. Indirect predicates, degeneracies, and degree control

A major limitation of direct filtered predicates is that they assume their arguments are exact geometric primitives. When a predicate is applied to an intermediate construction represented only approximately in floating point, correctness is no longer guaranteed even if the predicate itself is exact relative to its explicit inputs. Indirect predicates solve this by passing the primitive geometric elements that define the construction, rather than the approximate constructed coordinates. For points of intersection of linear elements, the constructed point is represented as a rational function of the defining endpoints or planes, and the predicate polynomial is rewritten accordingly. This allows efficient filters and expansion arithmetic to resolve the sign exactly while tracking approximation introduced by the construction stage (Attene, 2021).

The same concern with intermediate structure motivates specialized degeneracy machinery. In free-space construction for a rotating polyhedron, every predicate is expressible as the sign of an angle polynomial $\mathbb{Z}^2$5 evaluated at a zero $\mathbb{Z}^2$6 of another angle polynomial $\mathbb{Z}^2$7, and degeneracy occurs when $\mathbb{Z}^2$8 and $\mathbb{Z}^2$9 share a common factor. A table-based algorithm performs a one-time factorization of all possible angle polynomials and makes degeneracy detection $p_i$0 times faster than greatest-common-divisor computation, reducing the share of degeneracy detection from $p_i$1 to $p_i$2 of running time (Milenkovic et al., 2018).

Control of algebraic degree is another recurrent theme. For the Euclidean Voronoi diagram of axis-aligned line segments, the most demanding Incircle configurations can be reduced to the sign of a linear polynomial evaluated at a known root of a quadratic polynomial, and the resulting algebraic degree is at most $p_i$3, half the degree of the earlier specialized approach (Kamarianakis et al., 2011). In the 3D Apollonius diagram, the EdgeConflict predicate is decomposed into three sub-predicates and four primitives, and the maximum algebraic degree needed to answer any of them is $p_i$4. A 3D inversion transformation is central to that reduction, because it turns ordering along a trisector into a planar tangent-incidence problem with lower-degree algebraic tests (Kamarianakis, 2018).

These developments also clarify the boundary between soft and exact strategies. In mesh CSG, exact predicates and exact constructions are used precisely because combinatorics are shared between co-refinement, constrained Delaunay remeshing, radial sorting around non-manifold edges, and region classification. The proposed kernels use arithmetic expansions or multi-precision floating point, and symbolic perturbations are applied to disambiguate co-cyclic configurations in constrained Delaunay triangulation (Lévy, 2024). This suggests that when combinatorial consistency across many stages is the dominant requirement, exact kernels may be simpler than soft surrogates; when local sign queries dominate, filtered and indirect predicates are often preferable.

5. Differentiable relaxations and optimization-oriented predicates

A different meaning of softness arises when predicates must remain inside a computational graph. In differentiable spatio-temporal logic for manipulation, polygonal objects are represented as tensors of vertices, and spatial predicates are implemented as smooth functions of those tensors rather than as discrete geometry-engine calls. This includes differentiable signed distance, intersection, containment, and directional relations, all composed with smooth temporal-logic operators to yield an end-to-end differentiable robustness score (Luo et al., 3 Apr 2026).

The main smoothing device is the LogSumExp approximation: $p_i$5 These operators replace exact min and max in projection bounds, signed-distance calculations, Boolean connectives, and temporal operators. For convex polygons, overlap is relaxed using a smooth version of the Separating Axis Theorem, while containment and polygon-to-polygon distance are built from boundary sampling, half-space tests, sigmoids, and smooth minima. Directional predicates such as LeftOf are implemented by replacing coordinatewise extrema with the corresponding smooth extrema over vertex tensors (Luo et al., 3 Apr 2026).

The formal effect is not exact certification but differentiable robustness. Spatial predicates are combined into temporal logic by smooth conjunction, disjunction, always, and eventually operators, again via smooth min and max. The result is a smooth robustness function $p_i$6 whose gradients with respect to states and parameters can be backpropagated. This makes it possible to perform trajectory optimization under spatio-temporal constraints and to learn logic margins from demonstrations. The paper states that the resulting toolbox is fully tensorized and, to the authors’ knowledge, the first end-to-end differentiable symbolic spatio-temporal logic toolbox (Luo et al., 3 Apr 2026).

This branch of the literature shows that softness may be motivated by optimization rather than arithmetic robustness. The predicate becomes a smooth surrogate not because the exact sign is unavailable, but because gradient-based search requires dense derivatives almost everywhere.

6. Resolution-exact planning, probabilistic graph models, and conceptual boundaries

In motion planning, soft predicates appear as conservative and convergent classifiers of configuration-space boxes. A box predicate $p_i$7 returns FREE, STUCK, or MIXED. Conservativeness means that whenever it returns FREE or STUCK, the answer matches the exact classification of the entire box; convergence means that under repeated subdivision around a point, the soft predicate eventually stabilizes to the exact point classification. Within the Soft Subdivision Search framework, such predicates support resolution-exact planners: for an input parameter $p_i$8, the planner always halts and returns either a path or NO-PATH, with a clearance gap controlled by a constant $p_i$9 (Zhou et al., 2019).

For planar polygonal rigid robots, the central structural fact is decomposability. If a robot polygon is decomposed into triangular pieces with a common rotation center, and each piece has a $p_{i+1}$0-effective soft collision predicate, then the global predicate is obtained by declaring the box FREE if every piece is FREE, STUCK if some piece is STUCK, and MIXED otherwise. The paper proves that any $p_{i+1}$1-gon can be refined into at most $p_{i+1}$2 nice triangles, and that the resulting collision-predicate cost scales linearly in the number of robot edges $p_{i+1}$3, contrasting with the $p_{i+1}$4 complexity known for exact planners (Zhou et al., 2019).

A probabilistic variant of soft geometry appears in soft random geometric graphs. There, the hard predicate “$p_{i+1}$5” is replaced by a connection probability $p_{i+1}$6, and the entropy per edge is

$p_{i+1}$7

where $p_{i+1}$8 is the pair-distance density and $p_{i+1}$9 is the binary entropy function. For small connection range, the leading asymptotic depends only on the dimension of the embedding geometry and not its shape; for large connection range, boundary effects enter through moments of the pair-distance distribution (Baker et al., 21 Jan 2026). In this setting, softness means probabilistic adjacency rather than filtered exactness or differentiable smoothing, but the same design tension remains: local tractability is gained while retaining analyzable global structure.

Taken together, these strands show that soft geometric predicates are not a single formal object but a stable methodological family. They replace rigid geometric decisions by conservative monotone tests, certified approximate evaluations, symbolic perturbations, smooth relaxations, or probabilistic connection laws, depending on which invariant is to be preserved: exact sign, linear decomposition, differentiability, resolution-exactness, or entropy-controlled random structure.