From 082649ef401175bde02c82d97cd41f90098bd722 Mon Sep 17 00:00:00 2001 From: Tarik Moussa Date: Sat, 30 May 2026 09:37:01 +0200 Subject: [PATCH] docs(reviewer): mark Tier-3 done (PR #30); fix duplicated tier table MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Tier-3 (Lawson HyperIdeal) plain + branch-points marked DONE (PR #30, test_lawson_hyperideal.cpp); status, §3 HIGH/MED rows, §3b table and §4 recommended-order updated accordingly. - Hyperelliptic variant documented as deferred (option c): needs an XML-format reader for lawson_curve_source.xml + a port of HyperIdealHyperellipticUtility (jReality geometry θ); golden vector is non-symmetric. - Removed a pre-existing duplicated/stale copy of the tier-table rows. - Added a status summary (Tier 1 ✅ PR #29 · Tier 2 → Phase 9f/13 · Tier 3 ✅ PR #30). Co-Authored-By: Claude Opus 4.8 --- doc/reviewer/java-ignore-crossvalidation.md | 61 +++++++++++++++------ 1 file changed, 43 insertions(+), 18 deletions(-) diff --git a/doc/reviewer/java-ignore-crossvalidation.md b/doc/reviewer/java-ignore-crossvalidation.md index 5df3a9c..8044e53 100644 --- a/doc/reviewer/java-ignore-crossvalidation.md +++ b/doc/reviewer/java-ignore-crossvalidation.md @@ -43,7 +43,7 @@ These cover the **unit math cores** and **functional evaluation**. They do | Item | Java source | Oracle | Blocker / effort | |---|---|---|---| -| **HyperIdeal Lawson convergence** | `HyperIdealConvergenceTest.testHyperIdealConvergence` | **hard-coded golden u\*** (perfectly symmetric — robust to DOF order) | needs a **low-level half-edge generator** (`make_lawson_square_tiled`); CGAL `add_face` cannot build it (multi-edges, see §5). Effort: medium (1–2 d). | +| **HyperIdeal Lawson convergence** ✅ | `HyperIdealConvergenceTest.testHyperIdealConvergence` | **hard-coded golden u\*** (perfectly symmetric — robust to DOF order) | **DONE — PR #30** via low-level half-edge `make_lawson_square_tiled` (CGAL `add_face` can't: multi-edges, §5). | Golden solution (Lawson square-tiled, BLMVM, tol 1e-10), 22 DOFs: ``` @@ -60,7 +60,7 @@ Assertion strategy: because the values are symmetric per DOF-class, assert | Item | Java source | Oracle | Blocker | |---|---|---|---| | **Genus-1 uniformization** | `UniformizerTest.testGenus1` (Wente, 1240 V) | angle-sum = 2π + vertex count (self-consistency) | needs `wente.obj` asset + a "load OBJ → uniformize" path; C++ Euclidean solver exists. | -| **HyperIdeal Lawson + branch points** | `…WithBranchPoints` | hard-coded golden u\* (near-symmetric — DOF order matters more) | same generator as HIGH + branch-point variant. | +| **HyperIdeal Lawson + branch points** ✅ | `…WithBranchPoints` | hard-coded golden u\* | **DONE — PR #30** (stellar subdivision + ideal centres; per-class symmetric @1e-4). | | **HyperIdeal layout** | `HyperIdealLayoutTest` | layout positions | needs the generator + `layout.hpp` hyper-ideal path exercised. | | **Euclidean big-model scale** | `EuclideanUnwrapperPetscTest.testStaticUnwrapBigModel` | mostly self-check | scale/robustness cross-check; low oracle strength. | @@ -105,8 +105,9 @@ Assertion strategy: because the values are symmetric per DOF-class, assert | **1** | `SphericalConvergenceTest` | octahedron | MTJ Newton (no PETSc) | self-consistency (const. curvature) | spherical ✅, `make_octahedron_face` ✅ | low | | **2** | Wente genus-1 uniformization | `wente_torus02.obj` + `wente_uniformization.xml` | — (stored result) | exact `IsometryPSL2R` uniformizing-group generators | holonomy/`MobiusMap` ✅; **needs XML reader** | medium | | ~~2~~ → **4** | `regular_uniformization.xml`, `LetterB01_canonical_group.xml` | (stored) | — | full `IsometryPSL2R` Fuchsian group + 12-edge `FundamentalPolygon` | **genus ≥ 2 hyperbolic** (not genus-1) → Phase 13 | future | -| **3** | HyperIdeal Lawson convergence (3 golden vectors) | combinatorial `createLawsonSquareTiled` | — (hard-coded u\*) | symmetric u\* | needs **low-level half-edge generator** (§5) | high | -| **4** | genus-2 (`genus2.xml`/`lawson2498.obj`), holomorphic forms (`HolomorphicEuclideanUniformization_*.xml`), Schottky (`genus2.xml`), hyperelliptic | assets present in Java | — | various | Phases 10a/10c/11/13 | future | +| **3** ✅ | HyperIdeal Lawson convergence — plain + branch-points | low-level half-edge `make_lawson_square_tiled` | `newton_hyper_ideal` | hard-coded golden u\* | **DONE — PR #30** (`test_lawson_hyperideal.cpp`) | done | +| **3** ⏸️ | HyperIdeal Lawson **hyperelliptic** | `lawson_curve_source.xml` + `HyperIdealHyperellipticUtility` | — | non-symmetric golden u\* | **deferred** — needs XML-format reader + jReality-geometry θ port | future | +| **4** | genus-2 (`genus2.xml`/`lawson2498.obj`), holomorphic forms (`HolomorphicEuclideanUniformization_*.xml`), Schottky (`genus2.xml`) | assets present in Java | — | various | Phases 10a/10c/11/13 | future | **Tier-2 status (2026-05-30): exhausted.** The only genus-1 case is Wente (deferred to Phase 9f, quad/cyclic). `regular_uniformization.xml` and @@ -114,17 +115,34 @@ Assertion strategy: because the values are symmetric per DOF-class, assert (full PSL(2,ℝ) Fuchsian groups + a 12-edge fundamental polygon) → Phase 13, not Tier 2. -**Tier-3 status: a dedicated mini-project (gated on a mesh generator).** The -Lawson golden vectors require `createLawsonSquareTiled`: a genus-2 surface with -**4 vertices / 12 edges → multi-edges** (≥2 edges per vertex pair). CGAL -`add_face` / polygon-soup / OFF are all vertex-pair-keyed and **cannot** build -it; it needs hand-wired **low-level Surface_mesh halfedge construction** -(`add_edge` + explicit `set_next`/`set_vertex`/`set_face`, then `is_valid`), -plus replicating the external jtem `Triangulator` diagonal choice. The golden -vector is perfectly symmetric (4×1.1462 / 12×1.7627 / 6×2.6339), so a -*symmetry-preserving* triangulation may reproduce the three values without an -exact Triangulator match — but that is unverified. Recommended as its own -focused PR (`make_lawson_square_tiled` + golden-vector oracle), not a quick add. +**Tier-3 status (2026-05-30): DONE for plain + branch-points (PR #30).** The +Lawson base is a genus-2 surface with **4 vertices / 12 edges → multi-edges**, so +CGAL `add_face`/OFF/polygon-soup cannot build it; `make_lawson_square_tiled` +(`test_lawson_hyperideal.cpp`) uses the **low-level Surface_mesh half-edge API** +(`add_edge` + `set_target`/`set_next`/`set_face`/`set_halfedge`), then +`triangulate_faces` (plain) or `Euler::add_center_vertex` (branch-points, +stellar). Two key findings made this clean: +1. The golden vectors are **symmetric per geometric class**, so the external jtem + `Triangulator`/`StellarLinear` orderings need **not** be replicated — any + consistent triangulation/stellar reproduces the values. +2. Java's index-based θ split is actually **geometric** (original vs diagonal; + base vs spoke); branch-point centres are **ideal vertices** (b = 0). + +`newton_hyper_ideal` converges (from x0 = 1.0, **unconstrained** — Java needed +bounded BLMVM) to both golden vectors: +- plain: vertices 1.1462158341786262 / original 1.7627471737467797 / aux 2.633915794495759 +- branch-points: vertices 1.3169579 / base 2.2924317 / spokes 0 + +**Hyperelliptic (the 3rd Lawson variant) is deferred (option c).** It needs a +reader for `lawson_curve_source.xml` (Java conformal-data `HalfedgeEmbedding`, +26 vtx / 144 half-edges, a *cut* surface) **and** a port of +`HyperIdealHyperellipticUtility.calculateCircleIntersections`, which derives θ via +jReality `Pn` (elliptic/hyperbolic), `MatrixBuilder` (rotate / hyperbolic +translate) and stereographic projection. Its golden vector is **not** +class-symmetric (mixed ±values), so no symmetry shortcut — mesh and θ must match +exactly. Viable approaches: (A) port the jReality geometry, or (B) run a Java +dumper for θ + connectivity (no PETSc needed) and hard-code them. Both are +multi-step with numerical-replication risk → its own future task. **Key correction:** the Lawson generator (originally flagged HIGH) is actually **Tier 3** — higher effort than Tier 1/2. Cheapest first wins: @@ -135,9 +153,16 @@ focused PR (`make_lawson_square_tiled` + golden-vector oracle), not a quick add. condition with `phi_e = π−0.1`). Fails if the solver ignores a non-default `φ`, so it is a genuine check, not a tautology. 2. **Tier 1 — `SphericalConvergenceTest`** on the octahedron. -3. **Tier 2 — Wente genus-1 uniformization** (needs a small `UniformizationData` - XML reader; strongest deterministic pipeline oracle that maps to landed C++). -4. **Tier 3 — Lawson generator** (only after Tiers 1–2). +3. **Tier 2 — Wente genus-1 uniformization** — deferred to Phase 9f (quad/cyclic + pipeline; `wente_torus02.obj` is a quad mesh, not triangle). +4. **Tier 3 — Lawson generator** — ✅ DONE (PR #30): plain + branch-points golden + oracles GREEN; hyperelliptic deferred (option c). + +### Status summary (2026-05-30) +- **Tier 1** ✅ done (PR #29): cyclic φ oracle + full analytic edge-DOF Hessian. +- **Tier 2** — exhausted; Wente → Phase 9f, the rest → Phase 13. +- **Tier 3** ✅ done (PR #30): plain + branch-points Lawson golden oracles; + hyperelliptic deferred. ### Build-verification finding (2026-05-29) → resolved (2026-05-30)