diff --git a/README.md b/README.md index 321ae3c9..d2b728c0 100644 --- a/README.md +++ b/README.md @@ -202,12 +202,13 @@ just notebook-clear-outputs-all The crate treats a finite point-set triangulation as an oriented abstract simplicial complex plus a coordinate realization in a supported geometric model. Level 1 certifies element validity, including coordinate storage and local coordinate invariants. Levels 2-3 certify combinatorial consistency and -intrinsic PL topology without depending on coordinates. Level 4 certifies geometric validity: -affine-chart maximal simplices must be positively oriented, every maximal simplex must satisfy its -model's nondegeneracy constraints, and realized simplices may intersect only in their shared abstract -faces. Level 5 -certifies geometric optimality or predicate satisfaction, currently the Delaunay empty-circumsphere -property. +intrinsic PL topology without depending on coordinates: Level 2 checks coherent stored simplex +orderings, while Level 3 independently certifies intrinsic orientability for supported 2D/3D +PL-manifold guarantees, including periodic quotient constraints. Level 4 certifies geometric validity: +Euclidean/toroidal affine-chart maximal simplices must be positively oriented and nondegenerate, and +their realizations may intersect only in shared abstract faces. The bounded spherical prototype +separately certifies model-specific simplex nondegeneracy in `S^D \subset R^(D+1)`. Level 5 certifies +geometric optimality or predicate satisfaction, currently the Delaunay empty-circumsphere property. Correctness evidence comes from the invariant model, exact predicate fallbacks, deterministic Simulation of Simplicity, validation reports, property tests, regression tests, and public examples. @@ -230,9 +231,9 @@ For the detailed contract, see [`docs/validation.md`](docs/validation.md), | Level | Validates | Primary API | |---|---|---| | 1 | Element Validity: vertex, simplex, facet, coordinate, and local-object invariants | `is_valid()` / element reports | -| 2 | Combinatorial Consistency: TDS incidences, neighbors, and simplex/ridge connectivity | `validate_structure()` / `structure_report()` | -| 3 | Intrinsic PL Topology: manifold/pseudomanifold links, components, and Euler consistency | `is_valid_topology()` / `topology_report()` | -| 4 | Valid Realization: model-valid orientation, nondegeneracy, and only shared-face intersections | `is_valid_realization()` / `realization_report()` | +| 2 | Combinatorial Consistency: TDS incidence, adjacency, indexes, and stored orientation | `is_valid_structure()` / `structure_report()` | +| 3 | Intrinsic PL Topology: manifold links, components, Euler consistency, and orientability | `is_valid_topology()` / `topology_report()` | +| 4 | Valid Realization: affine-chart validity or bounded spherical simplex nondegeneracy, by backend | `is_valid_realization()` / `realization_report()` | | 5 | Geometric Predicates: Delaunay and future geometry-specific optimality predicates | `is_valid_delaunay()` / `delaunay_report()` | | 1-5 | Cumulative diagnostics | `dt.validate()` / `dt.validation_report()` | @@ -250,6 +251,7 @@ PL-manifold topology with explicit full-validation checkpoints. Layer-local APIs use `is_valid()` for unambiguous element/TDS owners, `is_valid_*` for higher-level fast-fail checks, and `*_diagnostic` / `*_report` for diagnostics; cumulative APIs use `validate()` / `validation_report()`. +`orientation_witness()` exposes the supported 2D/3D Level 3 orientability certificate directly. For generated failure pictures, public test anchors, and diagnostics for each layer, run [`notebooks/01_validation.ipynb`](notebooks/01_validation.ipynb). For the paper-facing mathematical @@ -271,7 +273,7 @@ exposition, see [`papers/validation.tex`](papers/validation.tex) and the compile - [Property Testing Summary](docs/property_testing_summary.md) - Property-test layout and coverage summary. - [Releasing](docs/RELEASING.md) - Changelog, benchmark, and publish workflow. - [Roadmap](docs/roadmap.md) - Current release sequence and deferred feature tracks. -- [Topology](docs/topology.md) - Level 3 Intrinsic PL Topology validation and global topology models. +- [Topology](docs/topology.md) - Level 3 Intrinsic PL Topology validation, orientability, and global topology models. - [Validation Guide](docs/validation.md) - Validation hierarchy and policy configuration. - [Validation Paper](papers/validation.pdf) - Reviewer-facing PDF for the validation architecture. - [Workflows](docs/workflows.md) - Practical recipes for construction, repair, toroidal domains, payloads, and flips. diff --git a/docs/README.md b/docs/README.md index 87ca6ad2..a627b946 100644 --- a/docs/README.md +++ b/docs/README.md @@ -8,7 +8,7 @@ Historical design notes, investigations, and completed optimization roadmaps liv ## Start here - [`api_design.md`](api_design.md): construction, vertex lifecycle, and Pachner move APIs. -- [`topology.md`](topology.md): Level 3 Intrinsic PL Topology invariants (manifold checks, Euler characteristic). +- [`topology.md`](topology.md): Level 3 Intrinsic PL Topology invariants (manifold checks, orientability, Euler characteristic). - [`validation.md`](validation.md): the five-level validation model (Levels 1–5) and how to configure it. - [`../papers/validation.pdf`](../papers/validation.pdf): reviewer-facing validation architecture paper. - [`diagnostics.md`](diagnostics.md): opt-in diagnostic helpers, structured reports, and debug switches. diff --git a/docs/diagnostics.md b/docs/diagnostics.md index c5f71f47..d9a4087c 100644 --- a/docs/diagnostics.md +++ b/docs/diagnostics.md @@ -98,6 +98,13 @@ Layer-local diagnostics follow a standard naming pattern: - `*_diagnostic`: first actionable repair/retry diagnostic for that layer. - `*_report`: all checkable layer-local failures. +Orientation failures retain their owning layer. Level 2 stored-ordering +incoherence is reported as `TdsError::OrientationViolation`; Level 3 intrinsic +orientability is queried with `Triangulation::orientation_witness()` and reports +`TriangulationValidationError::NonOrientable` for a contradictory 2D/3D parity +system. Level 4 positive geometric orientation remains part of the realization +diagnostic/report surface below. + For Level 4 realization failures specifically, use `dt.as_triangulation().realization_diagnostic()` for the first repair-oriented failure and `dt.as_triangulation().realization_report()` for all checkable diff --git a/docs/invariants.md b/docs/invariants.md index 8161c7a8..c399b325 100644 --- a/docs/invariants.md +++ b/docs/invariants.md @@ -25,7 +25,7 @@ the guarantees stated in the public API documentation. - [Simplicial complexes and manifolds](#simplicial-complexes-and-manifolds) - [Simplicial complex model](#simplicial-complex-model) - [Validation layering](#validation-layering) - - [Coherent orientation](#coherent-orientation) + - [Orientation contracts](#orientation-contracts) - [Geometric invariants](#geometric-invariants) - [Valid realization](#valid-realization) - [Geometric predicates and the Delaunay condition](#geometric-predicates-and-the-delaunay-condition) @@ -115,7 +115,7 @@ operation has certified which part of the structure: simplices, simplex/ridge connectivity, and coherent combinatorial orientation. 3. **Level 3 — Intrinsic PL Topology**: the abstract simplicial complex satisfies the requested `TopologyGuarantee` (pseudomanifold, PL manifold, or strict PL manifold) through incidence, - connected components, Euler-characteristic, and link checks. + connected components, Euler-characteristic, link, and supported 2D/3D orientability checks. 4. **Level 4 — Valid Realization**: the complex is geometrically valid in the chosen coordinate model. `Triangulation::is_valid_realization()` owns realization-only fast-fail validation, and `Triangulation::validate_realization()` owns cumulative Levels 1–4 certification. Euclidean and @@ -142,22 +142,29 @@ explicit certification steps for workflows that need them. --- -## Coherent orientation +## Orientation contracts -Coherent orientation has two related meanings in this crate: +Orientation has three related but independently validated meanings in this crate: -- **TDS orientation**: adjacent simplices must induce opposite orientations on their shared facet. In +- **Intrinsic PL orientability (Level 3)**: the shared-facet parity constraints + must admit a coherent simplex-orientation assignment independently of the + orderings currently stored in the TDS. `Triangulation::orientation_witness()` + returns the opaque assignment for supported pure 2D/3D complexes. +- **Stored TDS coherence (Level 2)**: adjacent simplices must induce opposite orientations on their shared facet. In practice this is checked by comparing the facet index in one simplex with the reciprocal mirror index in its neighbor. -- **Geometric orientation**: a full `Triangulation` should store simplices with positive orientation in - Euclidean coordinates, except where an operation is explicitly handling a degenerate or - intermediate state. +- **Geometric orientation (Level 4)**: Euclidean/toroidal maximal simplices + should have positive orientation in their active affine charts, while the + spherical backend enforces its model-specific realization conditions. An + operation may handle a degenerate or intermediate state only inside a + failure-atomic transaction. The orientation checker uses the robust orientation predicate directly instead of a kernel-level predicate that may apply Simulation of Simplicity. That preserves the distinction between an actually degenerate simplex and a deterministically tie-broken predicate result. At the TDS layer, periodic-image simplices compare lifted `(vertex, offset)` facet identities after translation -normalization, so quotient facets participate in the same combinatorial-orientation contract. +normalization, so quotient facets participate in stored-coherence and intrinsic-orientability +constraints without conflating either property with geometric sign. Pachner and bistellar-editing transactions must keep coherent combinatorial orientation and positive geometric simplex orientation separate. A move can leave the TDS coherently oriented while affected @@ -187,9 +194,9 @@ Level 4 is the valid-realization check. It is independent of Level 5 geometric p enforces: - every Euclidean/toroidal maximal simplex has positive geometric orientation in its affine chart; -- every maximal simplex has nonzero `D`-volume under the robust orientation predicate; -- every pair of maximal simplices intersects only in the realization of the face spanned by their - shared vertices; +- every Euclidean/toroidal maximal simplex has nonzero `D`-volume under the robust orientation predicate; +- every pair of Euclidean/toroidal maximal simplices intersects only in the realization of the face + spanned by their shared vertices; - Euclidean and toroidal triangulations use valid affine-chart realization checks, with toroidal triangulations checked in periodic covering-space charts, including translated images that can overlap across the fundamental-domain boundary. @@ -197,9 +204,10 @@ enforces: in `S^D \subset R^(D+1)`. This is intentionally separate from topology. Non-orientable spaces are valid objects in topology in -general, but this crate's TDS contract maintains coherent orientation for the oriented complexes its -construction, flip, and predicate machinery operate on. Level 4 then asks whether that oriented -complex is a valid realization in the active realization model. For Euclidean/toroidal affine-chart models, this means +general, but the crate's 2D/3D PL-manifold guarantees require an intrinsic orientation witness, and +its TDS contract separately maintains coherent stored orderings for the complexes its construction, +flip, and predicate machinery operate on. Level 4 then asks whether that oriented complex is a valid +realization in the active realization model. For Euclidean/toroidal affine-chart models, this means the vertex map is injective, every abstract simplex is realized as a nondegenerate affine simplex, and realized simplex intersections satisfy `|sigma| ∩ |tau| = |sigma ∩ tau|`. General spherical integration with the ordinary mutable triangulation surface and hyperbolic topology need diff --git a/docs/limitations.md b/docs/limitations.md index 508bc397..572b66d9 100644 --- a/docs/limitations.md +++ b/docs/limitations.md @@ -73,7 +73,9 @@ Toroidal support has two modes: - `.try_toroidal([..])` uses the 3^D image-point method to construct a true periodic quotient with rewired neighbor pointers. This path is release covered in 2D and compact 3D, where periodic triangulations validate as - closed tori through Levels 1-5. Construction moves each canonical coordinate + closed tori through Levels 1-5, including translation-normalized Level 2 + stored-orientation coherence and Level 3 intrinsic orientability. Construction + moves each canonical coordinate by at most about 2^-32 of its domain period using a deterministic perturbation that resolves periodic covering-space degeneracies while preserving vertex UUIDs and payloads. diff --git a/docs/topology.md b/docs/topology.md index 72a5e08a..3bc2c782 100644 --- a/docs/topology.md +++ b/docs/topology.md @@ -88,16 +88,24 @@ Level 3 always checks: `TopologyGuarantee` controls which additional PL-manifold checks Level 3 runs: -- `TopologyGuarantee::Pseudomanifold`: no additional link checks. +- `TopologyGuarantee::Pseudomanifold`: no additional link or orientability checks. - `TopologyGuarantee::PLManifold`: runs ridge-link validation during insertion and - requires a completion-time vertex-link pass for full certification. + requires a completion-time vertex-link pass for full certification; in 2D/3D, + it also certifies intrinsic orientability. - `TopologyGuarantee::PLManifoldStrict`: runs vertex-link validation after every - insertion (slowest, maximum safety). + insertion and certifies 2D/3D intrinsic orientability (slowest, maximum safety). + +`Triangulation::orientation_witness()` returns the opaque coherent assignment +used by the 2D/3D Level 3 check. This is independent of Level 2 stored-ordering +coherence and Level 4 positive geometric orientation. Periodic quotient facets +contribute parity constraints through translation-normalized lifted vertex +identities, including explicit self-identifications. Implementation pointers: - Level 3 entry points and validation vocabulary: `src/core/validation.rs` - (`Triangulation::is_valid_topology`, `Triangulation::validate`) + (`Triangulation::is_valid_topology`, `Triangulation::orientation_witness`, + `OrientationWitness`, and `Triangulation::validate`) - Owner-level topology validators: `src/core/validation.rs` and `src/delaunay/query.rs` (`Triangulation::validate_ridge_links`, diff --git a/docs/validation.md b/docs/validation.md index 03b4047b..057eee2d 100644 --- a/docs/validation.md +++ b/docs/validation.md @@ -18,7 +18,7 @@ paper-claim mapping is tracked in [#408](https://github.com/acgetchell/delaunay/ Five-level validation hierarchy The Level 3–5 panels make the critical separation explicit: intrinsic topology -can be valid while a realization overlaps, and a faithful realization can +can be valid while a realization overlaps, and a valid realization can still violate the Delaunay empty-circumsphere predicate. ### Level 1 — Element Validity @@ -60,8 +60,8 @@ The library provides **five levels of validation**, each answering a different correctness question while building on the previous level: 1. **Element Validity** - Are individual geometric and combinatorial objects internally valid? -2. **Combinatorial Consistency** - Does the simplicial complex satisfy the required incidence invariants? -3. **Intrinsic PL Topology** - Does the abstract complex represent the intended PL topology? +2. **Combinatorial Consistency** - Does the TDS satisfy its incidence, adjacency, index, and stored-orientation invariants? +3. **Intrinsic PL Topology** - Does the abstract complex represent the intended PL topology, including orientability when required? 4. **Valid Realization** - Does the complex satisfy model-specific orientation and nondegeneracy constraints with only shared-face intersections? 5. **Geometric Predicates** - Does a valid realization satisfy the selected geometry-specific predicate family? @@ -81,16 +81,19 @@ spherical Delaunay belongs in Level 5. ```text Level 1: Element Validity - ↓ (called by) + ↓ (cumulative validation adds) Level 2: Combinatorial Consistency - ↓ (called by) + ↓ (cumulative validation adds) Level 3: Intrinsic PL Topology - ↓ (independent) + ↓ (cumulative validation adds) Level 4: Valid Realization - ↓ (independent) + ↓ (cumulative validation adds) Level 5: Geometric Predicates ``` +Layer-local `is_valid_*` checks isolate one level; cumulative `validate()` and +`validation_report()` APIs add every lower layer owned by the receiver. + ## Validation API Pattern Each validation layer exposes the same public API shape when the layer can @@ -145,6 +148,8 @@ When the policy triggers automatic validation, it runs **Level 3** - Codimension-2 boundary manifoldness (the boundary is closed; "no boundary of boundary") - Ridge-link validation (when `TopologyGuarantee::PLManifold` or `TopologyGuarantee::PLManifoldStrict`) - Vertex-link validation during insertion (when `TopologyGuarantee::PLManifoldStrict`) +- Intrinsic orientability for 2D/3D PL-manifold guarantees, including ordinary + and periodic quotient parity constraints - Connectedness (single component) - No isolated vertices - Euler characteristic @@ -298,18 +303,26 @@ The library separates **construction-time** failures from **validation-time** in ### Validation errors (checking invariants) - `TdsError` (Levels 1–2): element + structural invariants. -- `TriangulationValidationError` (Level 3): wraps `TdsError` and adds +- `TriangulationValidationError` (Level 3 topology validation): reports codimension-1 manifoldness + codimension-2 boundary manifoldness (closed boundary) + - (optional) vertex-link PL-manifold checks + connectedness + isolated-vertex + Euler characteristic checks. -- `TriangulationRealizationValidationError` (Level 4): wraps - `TriangulationValidationError` and adds Euclidean/toroidal affine-chart - orientation, nondegeneracy, and overlap checks. + (optional) link-based PL-manifold checks + 2D/3D intrinsic orientability + + connectedness + isolated-vertex + Euler characteristic checks. The type also + carries `OrientationPromotionNonConvergence` when a triangulation-layer repair + cannot restore positive simplex orientation; that variant is a repair diagnostic, + not an intrinsic-topology invariant. +- `InvariantError` (cumulative layer wrapper): preserves `TdsError`, + `TriangulationValidationError`, `TriangulationRealizationValidationError`, or + `DelaunayTriangulationValidationError` according to the failing level. +- `TriangulationRealizationValidationError` (Level 4): preserves lower-layer + `TdsError` and `TriangulationValidationError` values and adds + Euclidean/toroidal affine-chart orientation, nondegeneracy, and overlap checks. - `SphericalDelaunayValidationError` (spherical prototype Levels 3-5): reports intrinsic PL-topology failures, spherical realization failures, and spherical Delaunay predicate failures for the bounded `S^2`/`S^3` backend. -- `DelaunayTriangulationValidationError` (Level 5): wraps - `TriangulationRealizationValidationError` and adds the implemented geometric - predicate checks, currently Delaunay. +- `DelaunayTriangulationValidationError` (Level 5): preserves lower-layer + `TdsError`, `TriangulationValidationError`, and + `TriangulationRealizationValidationError` values and adds the implemented + geometric predicate checks, currently Delaunay. ### Reporting (full diagnostics) @@ -401,11 +414,18 @@ by the Triangulation Data Structure. `Tds::is_valid()` (Level 2) checks: 1. **UUID ↔ Key Mappings**: Bidirectional consistency for vertices and simplices -2. **No Duplicate Simplices**: No simplices with identical vertex sets -3. **Facet Sharing Invariant**: Each facet shared by at most 2 simplices -4. **Neighbor Consistency**: Mutual neighbor relationships are correct: +2. **Resolved References**: Every simplex vertex, simplex neighbor, and optional + vertex incident-simplex hint resolves to a compatible stored object +3. **Vertex-to-Simplices Index**: The derived incidence index exactly matches + simplex membership +4. **No Duplicate Simplices**: No simplices with identical vertex sets +5. **Facet Sharing Invariant**: Each facet shared by at most 2 simplices +6. **Neighbor Consistency**: Mutual neighbor relationships are correct: manifold boundary facets are open, interior facets have reciprocal neighbors, and admissible periodic self-neighbors are closed topology. +7. **Stored Coherent Orientation**: Adjacent simplex orderings induce compatible + opposite facet orientations. Periodic facets compare translation-normalized + lifted `(vertex, offset)` identities, including quotient self-identifications. `Tds::validate()` (Levels 1–2) additionally rolls up these Level 1 checks: @@ -618,10 +638,10 @@ coordinates. - **Positive affine-chart orientation**: every Euclidean/toroidal maximal simplex has the canonical positive geometric sign in its active chart. -- **Nondegenerate maximal simplices**: every maximal simplex has nonzero `D`-volume by the robust - orientation predicate. -- **No overlap outside shared faces**: any two maximal simplices may intersect only in the - realization of the face spanned by their shared vertices. +- **Nondegenerate affine-chart simplices**: every Euclidean/toroidal maximal simplex has nonzero + `D`-volume by the robust orientation predicate. +- **No affine-chart overlap outside shared faces**: any two Euclidean/toroidal maximal simplices may + intersect only in the realization of the face spanned by their shared vertices. - **Toroidal periodic images**: toroidal topology is checked in covering-space charts, including periodic translates that can overlap across the fundamental-domain boundary. - **Spherical prototype simplices**: `SphericalDelaunayTriangulation` validates `S^2`/`S^3` @@ -636,6 +656,9 @@ until model-specific chart validators are implemented. ### Complexity +The following bounds describe the ordinary Euclidean/toroidal affine-chart validator; the bounded +spherical prototype uses its separate model-specific realization checks. + - **Time**: O(simplices² × f(D)) for pairwise simplex-intersection checks in fixed dimension, with bounding-box pruning before exact rational barycentric witness construction. - **Space**: O(D²) to O(simplices) temporary space depending on the number of candidate overlaps. @@ -941,16 +964,19 @@ pub fn validate_with_level( **Problem**: Structural invariants violated **Likely Cause**: Bug in construction or mutation code -**Fix**: Check for duplicate simplices, incorrect neighbor assignments, or mapping inconsistencies +**Fix**: Check for duplicate simplices, incorrect neighbor assignments, mapping/index inconsistencies, +or incompatible stored simplex orderings across ordinary or periodic facets ### Validation Passes Level 2, Fails at Level 3 **Problem**: Codimension-1 manifoldness violated (facet has 0 or >2 simplices), boundary is not closed ("boundary of boundary"), -triangulation disconnected, isolated vertex present, or Euler characteristic wrong +triangulation disconnected, isolated vertex present, intrinsic orientation constraints are contradictory, +or Euler characteristic is wrong **Likely Cause**: Non-manifold topology, missing/broken neighbor wiring, boundary topology corruption, -or disconnected components +non-orientable 2D/3D PL topology, contradictory periodic quotient parity, or disconnected components **Fix**: Check facet-to-simplices mapping, ensure boundary ridges have degree 2 within boundary facets, -ensure no isolated vertices, and verify the simplex neighbor graph is connected +ensure no isolated vertices, verify the simplex neighbor graph is connected, and inspect +`orientation_witness()` / `TriangulationValidationError::NonOrientable` ### Validation Passes Level 3, Fails at Level 4 diff --git a/papers/validation.pdf b/papers/validation.pdf index da995fbf..c0aecb1f 100644 Binary files a/papers/validation.pdf and b/papers/validation.pdf differ diff --git a/papers/validation.tex b/papers/validation.tex index 2de522ee..9cd8dc66 100644 --- a/papers/validation.tex +++ b/papers/validation.tex @@ -84,6 +84,8 @@ \subsection{Level 2: Combinatorial Consistency} \begin{itemize} \item \AuthorTodo{Describe adjacency, incidence, neighbor symmetry, and TDS integrity.} + \item \AuthorTodo{Distinguish coherent stored simplex orderings, including + periodic quotient facets, from intrinsic orientability.} \item \AuthorTodo{Explain the separation from topology and geometry.} \end{itemize} @@ -93,6 +95,8 @@ \subsection{Level 3: Intrinsic PL Topology} \item \AuthorTodo{State the PL-manifold and boundary conditions.} \item \AuthorTodo{Discuss pseudomanifold and strict PL-manifold policy choices.} + \item \AuthorTodo{Describe the 2D/3D intrinsic orientation witness and + periodic quotient parity constraints.} \item \AuthorTodo{Explain why this layer is independent of Euclidean, toroidal, and spherical realizations.} \end{itemize} @@ -108,6 +112,8 @@ \subsection{Level 4: Valid Realization} model.} \item \AuthorTodo{Compare Euclidean/toroidal affine-chart realizations and spherical realizations.} + \item \AuthorTodo{Keep positive geometric orientation distinct from Level 2 + stored coherence and Level 3 intrinsic orientability.} \item \AuthorTodo{Explain why realization validity is a precondition for geometric predicates.} \end{itemize} @@ -125,6 +131,33 @@ \subsection{Level 5: Geometric Predicates} \section{Implementation Architecture} +\begin{center} + \begin{minipage}{\textwidth} + \captionof{table}{Public validation API by owning layer.} + \label{tab:validation-api} + \small + \begin{tabular}{@{}cp{0.88\textwidth}@{}} + \toprule + Level & Canonical public surface \\ + \midrule + 1 & \texttt{Vertex::is\_valid} / \texttt{vertex\_report}; + \texttt{Simplex::is\_valid} / \texttt{simplex\_report} \\ + 2 & \texttt{Tds::is\_valid} / \texttt{structure\_report}; + \texttt{Tds::validate} certifies Levels 1--2 \\ + 3 & \texttt{Triangulation::is\_valid\_topology} / + \texttt{topology\_report} / \texttt{orientation\_witness}; + \texttt{Triangulation::validate} certifies Levels 1--3 \\ + 4 & \texttt{Triangulation::is\_valid\_realization} / + \texttt{realization\_report}; \texttt{validate\_realization} certifies + Levels 1--4 \\ + 5 & \texttt{DelaunayTriangulation::is\_valid\_delaunay} / + \texttt{delaunay\_report}; \texttt{DelaunayTriangulation::validate} + certifies Levels 1--5 \\ + \bottomrule + \end{tabular} + \end{minipage} +\end{center} + \begin{itemize} \item \AuthorTodo{Map the five validation levels onto the Rust API surface.} \item \AuthorTodo{Describe the role of fast-fail checks, diagnostics,