Merge pull request #12: release v0.9.0 finalisation

Closes the v0.9.0 release loop on top of Phase 9a-Newton + Phase 8b-Lite:

* CHANGELOG.md (NEW) — Keep-A-Changelog format, with v0.9.0 entry
  detailing all Phase 9a / 9b / 8b-Lite contents and the doc-audit
  corrections that landed via PR #10.

* CITATION.cff — version 0.7.0 → 0.9.0, date 2026-05-18 → 2026-05-22.

* Stale HDS-port stubs removed (13 GTEST_SKIPs total):
  - code/tests/test_spherical_functional.cpp
  - code/tests/test_hyper_ideal_functional.cpp
  - code/tests/test_hyper_ideal_hyperelliptic_utility.cpp
  These referenced a "HDS port (Phase 4)" that never happened —
  CoHDS was intentionally replaced by CGAL::Surface_mesh, and the
  functional tests live in code/tests/cgal/test_*_functional.cpp.

* Test-count updates everywhere:
  - Non-CGAL  36 → 23  (drop = 13 deleted stubs)
  - CGAL      176 → 227
  - Total     212 → 250  (+38 net, 0 skipped)
  Files: README.md, CLAUDE.md, CHANGELOG.md, scripts/try_it.sh,
         doc/api/tests.md, doc/contributing.md, doc/getting-started.md,
         doc/math/validation.md.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitea/docker/Dockerfile.ci-cpp

@@ -10,6 +10,7 @@ RUN apt-get update -qq && \
     curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
     apt-get install -y --no-install-recommends \
       nodejs \
+      doxygen \
       cmake \
       build-essential \
       git \

.gitea/workflows/cpp-tests.yml

@@ -11,8 +11,8 @@ on:
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Job 1 — test-fast
-#   Pure-math tests (Clausen, ImLi₂, Hyper-ideal Geometrie).
-#   Kein CGAL, kein Boost. Nur Eigen + GTest. Läuft auf ALLEN Branches.
+#   Pure-math tests (Clausen, ImLi₂, Hyper-ideal geometry).
+#   No CGAL, no Boost. Eigen + GTest only. Runs on ALL branches.
 # ─────────────────────────────────────────────────────────────────────────────
 jobs:
   test-fast:
@@ -35,7 +35,7 @@ jobs:
           --output-on-failure
           --output-junit test-results.xml
 
-      - name: Zusammenfassung
+      - name: Summary
         if: always()
         run: |
           if [ -f test-results.xml ]; then
@@ -48,14 +48,14 @@ jobs:
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Job 2 — test-cgal
-#   Vollständige CGAL-Test-Suite (Phase 3–7, 158 Tests).
-#   Läuft NUR bei Pull Requests (nicht bei direkten Pushes auf dev/main).
-#   Startet erst nach erfolgreichem test-fast.
+#   Full CGAL test suite (Phase 3–7, 158 tests).
+#   Runs ONLY on pull requests (not on direct pushes to dev/main).
+#   Starts only after test-fast succeeds.
 #
-#   Verwendet -DWITH_CGAL_TESTS=ON (nicht -DWITH_CGAL=ON), damit kein
-#   Viewer/GLFW gebaut wird — der CI-Container hat kein wayland-scanner.
+#   Uses -DWITH_CGAL_TESTS=ON (not -DWITH_CGAL=ON) to avoid building
+#   Viewer/GLFW — the CI container has no wayland-scanner.
 #
-#   Boost (libboost-dev) ist seit Image-Rebuild bereits im Container.
+#   Boost (libboost-dev) is already present in the container since the image rebuild.
 # ─────────────────────────────────────────────────────────────────────────────
   test-cgal:
     needs: test-fast
@@ -63,16 +63,21 @@ jobs:
     runs-on: eulernest
     container:
       image: git.eulernest.eu/conformallab/ci-cpp:latest
-      options: "--memory=1400m --memory-swap=1400m"
+      # Memory bumped from 1400m → 1600m to avoid OOM during CGAL header
+      # compilation on ARM64 (CGAL + Eigen templates allocate ~700 MB per
+      # cc1plus instance; -j1 leaves a small margin).
+      # memory-swap == memory disables swap entirely so OOM fails fast
+      # rather than thrashing on the SD card.
+      options: "--memory=1600m --memory-swap=1600m"
 
     steps:
       - uses: actions/checkout@v4
 
-      - name: Configure (WITH_CGAL_TESTS — kein Viewer, kein wayland-scanner)
+      - name: Configure (WITH_CGAL_TESTS — no viewer, no wayland-scanner)
         run: cmake -S code -B build -DWITH_CGAL_TESTS=ON -DCMAKE_BUILD_TYPE=Release
 
       - name: Build CGAL-Tests
-        run: nice -n 19 cmake --build build --target conformallab_cgal_tests -j2
+        run: nice -n 19 cmake --build build --target conformallab_cgal_tests -j1
 
       - name: Run CGAL-Tests
         run: >
@@ -81,7 +86,7 @@ jobs:
           --output-on-failure
           --output-junit cgal-results.xml
 
-      - name: Zusammenfassung
+      - name: Summary
         if: always()
         run: |
           if [ -f cgal-results.xml ]; then

.gitea/workflows/doc-build.yaml

@@ -0,0 +1,56 @@
+name: API Docs
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Doc-build — informational only
+#
+# Generates Doxygen HTML from the public headers and reports warning
+# statistics.  Does NOT block merges: `continue-on-error: true` ensures
+# warnings or extraction issues never fail the CI gate.  When Doxygen
+# coverage is denser (Phase 8c), this job can be promoted to a hard
+# requirement and the HTML deployed to Pages.
+#
+# Note: Gitea Actions on GHES does not support `actions/upload-artifact@v4`,
+# so HTML artifact upload is intentionally omitted.  The warning summary
+# in the job log is the primary reviewer signal; reviewers who want the
+# HTML can rebuild it locally with `cmake --build build --target doc`.
+# ─────────────────────────────────────────────────────────────────────────────
+jobs:
+  doc-build:
+    if: github.event_name == 'pull_request'
+    runs-on: eulernest
+    container:
+      image: git.eulernest.eu/conformallab/ci-cpp:latest
+    continue-on-error: true   # never block the merge
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Generate API documentation
+        run: doxygen Doxyfile 2>&1 | tee doxygen.log
+
+      - name: Summarise warnings
+        if: always()
+        run: |
+          if [ -f doc/doxygen/doxygen-warnings.log ]; then
+            warn=$(wc -l < doc/doxygen/doxygen-warnings.log)
+            echo "DOC ▸ Doxygen warnings: $warn"
+            echo ""
+            echo "First 20 warnings:"
+            head -20 doc/doxygen/doxygen-warnings.log
+          else
+            echo "DOC ▸ No warning log produced — check that Doxyfile WARN_LOGFILE points to doc/doxygen/doxygen-warnings.log"
+          fi
+
+      - name: Report HTML output
+        if: always()
+        run: |
+          if [ -d doc/doxygen/html ]; then
+            files=$(find doc/doxygen/html -type f | wc -l)
+            size=$(du -sh doc/doxygen/html | cut -f1)
+            echo "DOC ▸ HTML output: $files files, $size total"
+          fi

.gitignore

@@ -27,3 +27,7 @@ Testing/
 
 # Claude Code worktrees
 .claude/
+
+# Doxygen output
+doc/doxygen/
+*.dox.tmp

CHANGELOG.md

@@ -0,0 +1,153 @@
+# Changelog
+
+All notable changes to **conformallab++** are recorded here.  Format
+follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); the
+project uses [Semantic Versioning](https://semver.org).
+
+---
+
+## [0.9.0] — 2026-05-22
+
+The “DCE-complete + CGAL-surface-complete” release.  Two new discrete-
+conformal models, the analytic-Hessian optimisation for HyperIdeal, the
+CGAL public API surface for all five models, and a full documentation
+audit that corrects four pre-existing port-vs-research mis-labels.
+
+### Added — new functionals (Phase 9a)
+
+* `code/include/cp_euclidean_functional.hpp` —
+  **CP-Euclidean** functional (face-based circle packing),
+  Bobenko-Pinkall-Springborn 2010.  Direct port of
+  `CPEuclideanFunctional.java` (260 Java lines + 88-line test).
+  Analytic 2×2-per-edge Hessian `h_jk = sin θ / (cosh Δρ − cos θ)`.
+* `code/include/inversive_distance_functional.hpp` —
+  **Inversive-Distance** functional (vertex-based, Luo 2004 + Glickenstein
+  2011).  No Java original — implemented from the literature with
+  Bowers-Stephenson 2004 initialisation.  Cross-validated against the
+  Euclidean functional at the natural initial geometry (Glickenstein §5).
+
+### Added — Newton solvers (Phase 9a-Newton)
+
+* `newton_cp_euclidean()` — uses the analytic Hessian.
+* `newton_inversive_distance()` — uses FD Hessian; analytic via
+  Glickenstein 2011 eq. (4.6) tracked in `research-track.md` as
+  Phase 9a.2-analytic.
+
+### Added — Hessian optimisation (Phase 9b)
+
+* `hyper_ideal_hessian_block_fd()` — per-face 6×6 block-local Hessian
+  for HyperIdeal.  **96.5× speed-up measured on a 200-face mesh
+  (V=202, 603 DOFs)**, full-FD 226 ms → block-FD 2.3 ms.
+* Java parity note: `HyperIdealFunctional.java:295-298` declares
+  `hasHessian() == false`; both FD variants are conformallab++
+  research extensions beyond the Java port.
+
+### Added — CGAL public API surface (Phase 8b-Lite)
+
+* `<CGAL/Discrete_conformal_map.h>` extended with
+  `discrete_conformal_map_spherical()` and
+  `discrete_conformal_map_hyper_ideal()`.
+* `<CGAL/Discrete_circle_packing.h>` — `Default_cp_euclidean_traits` +
+  `discrete_circle_packing_euclidean()`.
+* `<CGAL/Discrete_inversive_distance.h>` — `Default_inversive_distance_traits`
+  + `discrete_inversive_distance_map()`.
+* `<CGAL/Conformal_layout.h>` — thin CGAL-namespace re-exports of
+  `euclidean_layout`, `spherical_layout`, `hyper_ideal_layout`.
+
+All five DCE models are now reachable from a single
+`#include <CGAL/Discrete_*.h>`.
+
+### Added — documentation
+
+* `doc/roadmap/research-track.md` — new consolidated catalogue of
+  every conformallab++ item that goes beyond the Java port, with full
+  literature citations and acceptance criteria.  Includes the
+  Phase 9b-analytic plan (Schläfli 1858 + Springborn 2020 §4 +
+  Cho-Kim 1999 + Glickenstein 2011 §4).
+* `doc/architecture/phase-9a-validation.md` — line-by-line mapping
+  CPEuclideanFunctional.java ↔ C++ port, plus three special-case
+  verifications of Luo’s edge-length formula.
+* `doc/roadmap/phases.md` — Phase 9 split into 9a.1 (Java port) /
+  9a.2 (research) / 9b (research); new Phase 11+ section with
+  optional Schottky uniformisation and Riemann-map sub-packages.
+* `doc/math/references.md` — five new primary literature entries
+  (Bowers-Stephenson 2004, Glickenstein 2011, BPS 2010,
+  Schläfli 1858/60, plus a reframed Luo 2004 entry).
+
+### Changed
+
+* **Four port-vs-research mis-labels** corrected (full audit
+  documented in `research-track.md`):
+  - `InversiveDistanceFunctional.java` does not exist in the Java
+    repo; the C++ implementation is research, not a port.
+  - HyperIdeal Hessian: Java has `hasHessian()==false`; C++ Hessians
+    are research, not ports.
+  - `add-inversive-distance.md` tutorial rewritten end-to-end.
+  - `references.md` and `java-parity.md` reframed.
+* `Discrete_conformal_map.h` (Phase 8a MVP wrapper) now deduces the
+  kernel from `TriangleMesh::Point` via `CGAL::Kernel_traits` rather
+  than hard-coding `Simple_cartesian<double>`.  Regression-guarded by
+  `KernelIsDeducedFromMeshPointType` test.
+
+### Removed
+
+* Three stale stub test files in `code/tests/` (15 GTEST_SKIPs total):
+  - `test_spherical_functional.cpp`
+  - `test_hyper_ideal_functional.cpp`
+  - `test_hyper_ideal_hyperelliptic_utility.cpp`
+  They referenced a "HDS port (Phase 4)" that never happened —
+  CoHDS was intentionally replaced by `CGAL::Surface_mesh`, and the
+  functional tests live in `code/tests/cgal/test_*_functional.cpp`.
+
+### CI / Infrastructure
+
+* `.gitea/workflows/cpp-tests.yml` — test-cgal memory fixed
+  (1400→1600 MB, `-j2 → -j1`).  Addresses OOM on ARM64 runner.
+* `.gitea/workflows/doc-build.yaml` — soft-fail Doxygen job
+  (no merge-blocking).
+* `Doxyfile` + CMake `doc` target — `cmake --build build --target doc`.
+* 12 macOS Finder-duplicate files removed from `code/include/`.
+
+### Test counts
+
+```
+v0.7.0:  176 CGAL + 36 non-CGAL = 212 total,  13 skipped (HDS stubs)
+v0.9.0:  227 CGAL + 23 non-CGAL = 250 total,   0 skipped   (+38 net, +51 CGAL)
+```
+
+Non-CGAL count dropped from 36 → 23 because three stale HDS-port stubs
+were removed (see "Removed" above) — the functionality is fully covered
+in the CGAL test suite where it actually lives.
+
+Five test suites added: `CGALConformalTraits`, `CGALDiscreteConformalMap`,
+`CPEuclideanFunctional`, `InversiveDistanceFunctional`, `HyperIdealHessian`,
+`NewtonPhase9a`, `CGALPhase8bLite`.
+
+---
+
+## [0.7.0] — 2026-05-18
+
+The “mathematician-ready” release.  See the v0.7.0 announcement in
+README.md (legacy) or `CITATION.cff` for the corresponding citation
+entry.  Phases 1–7 complete: three DCE geometry modes (Euclidean /
+Spherical / HyperIdeal), Newton solver, BFS-trilateration layout,
+Gauss-Bonnet, tree-cotree cut graph, Möbius holonomy, period matrix
+for genus 1, fundamental domain (genus 1), texture atlas.
+
+---
+
+## How to update this file
+
+Every new release adds a new top-level section above the previous one.
+For non-trivial PRs that don't trigger a release, add an entry under
+an `[Unreleased]` section at the top; promote it to the next release
+header at tag time.
+
+Categories (Keep-A-Changelog convention):
+
+* **Added** — new features / files / public APIs.
+* **Changed** — behaviour-altering changes to existing features.
+* **Deprecated** — features still present but slated for removal.
+* **Removed** — deleted features / files.
+* **Fixed** — bug fixes.
+* **Security** — security-relevant fixes.

CITATION.cff

@@ -7,8 +7,8 @@ authors:
     email: Tarik.moussa95@gmail.com
 
 title: "conformallab++"
-version: 0.7.0
-date-released: 2026-05-18
+version: 0.9.0
+date-released: 2026-05-22
 url: "https://codeberg.org/TMoussa/ConformalLabpp"
 repository-code: "https://codeberg.org/TMoussa/ConformalLabpp"
 license: MIT

CLAUDE.md

@@ -126,8 +126,13 @@ After `compute_*_lambda0_from_mesh()` the original vertex positions are no longe
 ### Newton solver (`newton_solver.hpp`)
 
 The gradient sign convention differs between modes:
-- **Euclidean/HyperIdeal:** `G_v = actual_angle_sum − Θ_v`, H is PSD → `SimplicialLDLT(H)`
-- **Spherical:** `G_v = Θ_v − actual_angle_sum`, H is NSD → `SimplicialLDLT(−H)`
+- **Euclidean/Spherical:** `G_v = Θ_v − actual_angle_sum` (target minus actual)
+- **HyperIdeal:** `G_v = actual_angle_sum − Θ_v` (actual minus target)
+
+Hessian sign and solver:
+- **Euclidean:** H is PSD (cotangent Laplacian) → `SimplicialLDLT(H)`
+- **Spherical:** H is NSD (concave energy) → `SimplicialLDLT(−H)` (sign flip inside `newton_spherical`)
+- **HyperIdeal:** H is PSD (strictly convex) → `SimplicialLDLT(H)`
 
 When `SimplicialLDLT` fails (rank-deficient H — gauge mode on closed mesh without pinned vertex), the solver automatically retries with `Eigen::SparseQR` to find the minimum-norm step orthogonal to the null space. Public API: `solve_linear_system(H, rhs, &used_fallback)`.
 
@@ -235,31 +240,149 @@ Two jobs in `.gitea/workflows/cpp-tests.yml`:
 | Job | CMake flags | Deps | Triggers on |
 |---|---|---|---|
 | `test-fast` | *(none)* | Eigen + GTest only | all branches |
-| `test-cgal` | `-DWITH_CGAL_TESTS=ON` | + Boost | `main`, `dev`, PRs only |
+| `test-cgal` | `-DWITH_CGAL_TESTS=ON` | + Boost | pull requests only |
 
 Runner: `eulernest` — self-hosted Raspberry Pi, ARM64, Ubuntu 22.04. Docker image: `git.eulernest.eu/conformallab/ci-cpp:latest`. `test-cgal` needs `test-fast` to pass first (`needs: test-fast`).
 
-Expected results: **36 non-CGAL tests pass**, **173 CGAL tests pass, 1 skipped** (intentional `GTEST_SKIP` stub for analytic HyperIdeal Hessian — deferred to Phase 9b).
+Expected results: **23 non-CGAL tests pass**, **227 CGAL tests pass, 0 skipped**.
 
-## Key documentation for mathematical context
+## Release state
 
-When working on math-heavy tasks, read these before reasoning from scratch:
+Current release: **v0.7.0** (tag on `origin/dev`, PR to `main` open).  
+Phase 7 is complete. Phase 7.5 (Doxygen) and Phase 8 (CGAL package) are next.
+
+## Phase 8 strategic decisions (2026-05-19)
+
+The CGAL-package architecture was frozen on 2026-05-19.  Full design:
+[`doc/api/cgal-package.md`](doc/api/cgal-package.md).  Key decisions:
+
+| Decision | Choice |
+|---|---|
+| Submission to upstream CGAL | **Pre-submission-ready, not bound.** 12+ months horizon. |
+| License | **MIT preserved** (no LGPL switch). |
+| Mesh-type flexibility | **Generic `FaceGraph + HalfedgeGraph`** in target design; MVP starts Surface_mesh-only. |
+| Parameter style | **Named Parameters** (`CGAL::parameters::...`). |
+| Default kernel | **`Simple_cartesian<double>`** (status quo). |
+| Backward compatibility | **Dual-layer wrapper** — `code/include/*.hpp` stays as implementation, `include/CGAL/*.h` is thin wrapper.  No algorithm duplication. |
+| Implementation strategy | **Hybrid MVP** — minimum Phase 8 (traits + one wrapper) first, then Phase 9 in full, then Phase 8 extensions only on concrete demand. |
+| Phase-8 MVP acceptance test | **Phase 9a (Inversive-Distance)** as the first new client of the new traits API. |
+
+### Implementation sequence (committed)
+
+```
+1. Phase 7.5  Doxygen + cleanup                         done ✅
+2. Phase 8 MVP — traits + one euclidean wrapper         3–5 days
+3. Phase 9a — Inversive-Distance against new traits     3–5 days
+4. Phase 9b — analytic HyperIdeal Hessian               1 week
+5. Phase 9c — 4g-polygon for genus g > 1                1 week
+   → port really complete, v0.9.0 release
+```
+
+Phase 8 extensions (8a.2 generic FaceGraph, 8c full Doxygen manuals, 8d
+CGAL-format tests, 8e YAML pipeline) are deferred to on-demand status —
+no speculative architecture for an uncertain submission.
+
+Root-level files added at v0.7.0:
+- `CITATION.cff` — machine-readable citation (Sechelmann 2016, Springborn 2020, Bobenko–Springborn 2004)
+- `CONTRIBUTING.md` — short root-level pointer to `doc/contributing.md`
+- `scripts/try_it.sh` — one-script quickstart: build → 209 tests → example run
+- CMake install target: `cmake --install build --prefix /usr/local` → headers land in `include/conformallab/`
+
+## Port-vs-research maintenance rule (2026-05-21 audit)
+
+Before claiming something "ports X from Java", **verify empirically**:
+
+```bash
+find /Users/tarikmoussa/Desktop/conformallab -iname "*X*"
+grep -r "ClassName" /Users/tarikmoussa/Desktop/conformallab/src
+```
+
+If zero matches, the work is **new research** — add it to
+`doc/roadmap/research-track.md` with primary literature citations,
+**not** to `doc/roadmap/java-parity.md`.
+
+The 2026-05-21 audit found four pre-existing mis-labels:
+
+| Item | Wrong claim | Reality |
+|---|---|---|
+| `InversiveDistanceFunctional` | "Java port (Luo 2004)" | No such Java class exists |
+| HyperIdeal Hessian (FD) | "Phase 4a" | Research — Java has `hasHessian()==false` |
+| HyperIdeal Hessian (analytic) | "Phase 9b port" | Research — derivation via Schläfli 1858 |
+| Tutorial framing | "ports `InversiveDistanceFunctional.java`" | Implementation from Luo 2004 + Glickenstein 2011 |
+
+All four are corrected as of this commit.  Future contributors must
+follow the empirical verification rule above before any new claim.
+
+## Documentation map
+
+24 documents across 6 categories. Read the relevant one before reasoning from scratch
+— do not hallucinate content that is already written down.
+
+### Mathematics & theory
 
 | Question | Document |
 |---|---|
-| What is the mathematical problem this library solves? | `doc/math/discrete-conformal-theory.md` |
-| What are the three geometry modes and how do they differ? | `doc/math/geometry-modes.md` |
-| How does conformallab++ relate to geometry-central (CMU)? | `doc/architecture/geometry-central-comparison.md` |
-| What analytic results can be used to validate correctness? | `doc/math/validation.md` |
-| Which Java classes are ported, which are planned? | `doc/roadmap/java-parity.md` |
-| What does each processing function require/provide? | `doc/api/contracts.md` |
+| What problem does this library solve mathematically? | `doc/math/discrete-conformal-theory.md` |
+| How do the three geometry modes differ (Euclidean/Spherical/HyperIdeal)? | `doc/math/geometry-modes.md` |
+| What analytic invariants can be used to validate correctness? | `doc/math/validation.md` |
+| What are the exact ctest commands with expected terminal output? | `doc/math/validation-protocol.md` |
+| What is the O() complexity and how does it scale with mesh size? | `doc/math/complexity.md` |
+| Which papers are referenced by which header? | `doc/math/references.md` |
+| How does conformallab++ compare to libigl, CGAL, geometry-central, pmp-library? | `doc/math/software-landscape.md` |
+| What is unique about conformallab++ (novelty, target audience)? | `doc/math/novelty-statement.md` |
+
+### Architecture & design
+
+| Question | Document |
+|---|---|
+| Full pipeline diagram and data-flow overview | `doc/architecture/overall_pipeline.md` |
+| Directory tree, build targets, file organisation | `doc/architecture/project-structure.md` |
+| Key architectural decisions and their rationale | `doc/architecture/design-decisions.md` |
+| Detailed comparison with geometry-central (CMU): overlap, adoption, scientific value | `doc/architecture/geometry-central-comparison.md` |
+| Phase 9a validation report (CP-Euclidean port + Luo-inversive-distance literature check) | `doc/architecture/phase-9a-validation.md` |
+
+### API & extension
+
+| Question | Document |
+|---|---|
+| All 24 public headers with descriptions | `doc/api/headers.md` |
+| Full pipeline API for all three geometries | `doc/api/pipeline.md` |
+| What does each processing unit require/provide (contracts)? | `doc/api/contracts.md` |
+| How to add a new functional / geometry mode / port from Java | `doc/api/extending.md` |
+| All 39 test suites, 227+23 tests, individual counts | `doc/api/tests.md` |
+| Phase 8 CGAL package design + Declarative YAML pipeline spec | `doc/api/cgal-package.md` |
+
+### Concepts & specs
+
+| Question | Document |
+|---|---|
+| Declarative YAML pipeline: token vocabulary, 5 examples, validation algorithm | `doc/concepts/declarative-pipeline.md` |
+
+### Roadmap & porting
+
+| Question | Document |
+|---|---|
+| Phases 1–10 with status and sub-tasks | `doc/roadmap/phases.md` |
+| Which Java classes are ported, which are planned, which are skipped? | `doc/roadmap/java-parity.md` |
+| New research items (beyond Java) — citations, acceptance criteria | `doc/roadmap/research-track.md` |
+
+### Tutorials & onboarding
+
+| Question | Document |
+|---|---|
+| Build modes, single-test invocation, CLI, Docker image rebuild | `doc/getting-started.md` |
+| Step-by-step: port the Inversive Distance functional (Phase 9a template) | `doc/tutorials/add-inversive-distance.md` |
+| Language policy, test standards, release flow | `doc/contributing.md` |
+
+### geometry-central context
 
 **geometry-central** (Keenan Crane, CMU) implements the same discrete conformal
 equivalence problem (Gillespie, Springborn & Crane, SIGGRAPH 2021) but uses
 Ptolemaic flips on intrinsic triangulations instead of Newton on the original mesh.
 It has no period matrix, holonomy, or spherical geometry mode.
 The shared mathematical core (Springborn 2020) means cross-validation is meaningful.
-See `doc/architecture/geometry-central-comparison.md` for the full comparison.
+Full analysis: `doc/architecture/geometry-central-comparison.md`.
+Optional adoption roadmap (GC-1/2/3): `doc/roadmap/phases.md` (Optional section).
 
 ## Known quirks
 

Doxyfile

@@ -0,0 +1,126 @@
+# Doxyfile for conformallab++
+#
+# Phase 7.5 — minimal CGAL-style Doxygen configuration.
+# Only non-default values are set; Doxygen ≥ 1.9.5 supplies the rest.
+#
+# Usage:
+#   doxygen Doxyfile           # generates HTML into doc/doxygen/html/
+#   open doc/doxygen/html/index.html
+#
+# Or via CMake:
+#   cmake --build build --target doc
+
+# ── Project identity ─────────────────────────────────────────────────────────
+PROJECT_NAME           = "conformallab++"
+PROJECT_NUMBER         = 0.7.0
+PROJECT_BRIEF          = "Discrete conformal maps on triangle meshes — C++17 reimplementation of ConformalLab (TU Berlin)"
+PROJECT_LOGO           =
+OUTPUT_DIRECTORY       = doc/doxygen
+USE_MDFILE_AS_MAINPAGE = README.md
+
+# ── Input ────────────────────────────────────────────────────────────────────
+INPUT                  = README.md \
+                         CLAUDE.md \
+                         code/include \
+                         doc/api \
+                         doc/architecture \
+                         doc/math
+FILE_PATTERNS          = *.hpp *.h *.cpp *.md
+RECURSIVE              = YES
+EXCLUDE_PATTERNS       = */build*/* \
+                         */deps/* \
+                         */.git/* \
+                         */test-reports/* \
+                         */* 2.hpp
+EXCLUDE_SYMBOLS        = Eigen::* boost::* std::*
+
+# ── Source browsing ──────────────────────────────────────────────────────────
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = NO
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+REFERENCES_LINK_SOURCE = YES
+
+# ── Build options ────────────────────────────────────────────────────────────
+JAVADOC_AUTOBRIEF      = YES
+QT_AUTOBRIEF           = NO
+MARKDOWN_SUPPORT       = YES
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = YES
+DISTRIBUTE_GROUP_DOC   = YES
+GROUP_NESTED_COMPOUNDS = YES
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+EXTENSION_MAPPING      = h=C++ hpp=C++
+
+# ── Warnings ─────────────────────────────────────────────────────────────────
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = NO
+WARN_IF_DOC_ERROR      = YES
+WARN_IF_INCOMPLETE_DOC = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = doc/doxygen/doxygen-warnings.log
+
+# ── HTML output ──────────────────────────────────────────────────────────────
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_COLORSTYLE        = LIGHT
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = NO
+HTML_DYNAMIC_SECTIONS  = YES
+GENERATE_TREEVIEW      = YES
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 1
+TREEVIEW_WIDTH         = 280
+EXT_LINKS_IN_WINDOW    = NO
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
+
+# ── Disabled outputs (we only want HTML) ─────────────────────────────────────
+GENERATE_LATEX         = NO
+GENERATE_RTF           = NO
+GENERATE_MAN           = NO
+GENERATE_XML           = NO
+GENERATE_DOCBOOK       = NO
+GENERATE_AUTOGEN_DEF   = NO
+GENERATE_PERLMOD       = NO
+
+# ── Preprocessor ─────────────────────────────────────────────────────────────
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = YES
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = code/include
+PREDEFINED             = CGAL_DISABLE_GMP \
+                         CGAL_DISABLE_MPFR \
+                         DOXYGEN_RUNNING
+
+# ── Diagrams ─────────────────────────────────────────────────────────────────
+HAVE_DOT               = NO
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = NO
+GROUP_GRAPHS           = YES
+INCLUDE_GRAPH          = NO
+INCLUDED_BY_GRAPH      = NO
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+
+# ── Aliases (CGAL-style) ─────────────────────────────────────────────────────
+ALIASES               += "concept{1}=\xrefitem concept \"Concept\" \"Concepts\" \1"
+ALIASES               += "models{1}=\xrefitem models \"Models\" \"Models\" \1"
+ALIASES               += "cgalRequires{1}=\par Requirements: \n\1"
+ALIASES               += "cgalParam{2}=\param \1 \2"

README.md

@@ -13,7 +13,7 @@ Algorithmic foundation:
 > DOI: [10.14279/depositonce-5415](https://depositonce.tu-berlin.de/items/8e2988b2-d991-45b5-aad5-9fb7988f3b2f) · CC BY-SA 4.0 ·
 > [Java original](https://github.com/varylab/conformallab) · [sechel.de](https://sechel.de/)
 
-**Status:** Phase 7 complete. Newton solver for all three geometries (Euclidean / Spherical / HyperIdeal), priority-BFS layout in ℝ²/S²/Poincaré disk, Gauss–Bonnet, tree-cotree cut graph, Möbius holonomy, period matrix (genus 1), fundamental domain, halfedge_uv texture atlas, JSON/XML serialisation, CLI app. **173 CGAL tests + 36 non-CGAL tests.**
+**Status:** v0.9.0 — Phases 1–9a complete, Phase 8b-Lite CGAL API surface. Newton solvers for **five** DCE models (Euclidean / Spherical / HyperIdeal / CP-Euclidean / Inversive-Distance), priority-BFS layout in ℝ²/S²/Poincaré disk, Gauss–Bonnet, tree-cotree cut graph, Möbius holonomy, period matrix (genus 1), fundamental domain, halfedge_uv texture atlas, JSON/XML serialisation, CLI app. **227 CGAL tests + 23 non-CGAL tests, 0 skipped.**
 
 ---
 
@@ -34,6 +34,10 @@ ctest --test-dir build -R "^cgal\." --output-on-failure
 # Full build with CLI + viewer (requires Wayland/X11 dev headers)
 cmake -S code -B build -DWITH_CGAL=ON && cmake --build build -j$(nproc)
 ./bin/conformallab_core -i input.off -g euclidean -o layout.off -j result.json
+
+# API documentation (requires doxygen: brew/apt install doxygen)
+cmake --build build --target doc
+open doc/doxygen/html/index.html
 ```
 
 ---
@@ -80,7 +84,7 @@ Layout2D layout = euclidean_layout(mesh, res.x, maps);
 | **Getting started** — build modes, single-test invocation, CLI, Docker | [doc/getting-started.md](doc/getting-started.md) |
 | **Pipeline API** — all three geometries, holonomy, serialisation | [doc/api/pipeline.md](doc/api/pipeline.md) |
 | **Public headers** — all 24 headers with descriptions | [doc/api/headers.md](doc/api/headers.md) |
-| **Test suites** — 28 suites, 170 tests, individual counts | [doc/api/tests.md](doc/api/tests.md) |
+| **Test suites** — 39 suites, 227+23 tests, individual counts | [doc/api/tests.md](doc/api/tests.md) |
 | **Extending** — new functionals, geometry modes, porting from Java | [doc/api/extending.md](doc/api/extending.md) |
 | **Processing unit contracts** — preconditions / provides table | [doc/api/contracts.md](doc/api/contracts.md) |
 | **CGAL package design** — Phase 8 target, YAML pipeline | [doc/api/cgal-package.md](doc/api/cgal-package.md) |
@@ -97,6 +101,7 @@ Layout2D layout = euclidean_layout(mesh, res.x, maps);
 | **References** — all papers by module | [doc/math/references.md](doc/math/references.md) |
 | **Software landscape** — how conformallab++ relates to libigl, CGAL, geometry-central | [doc/math/software-landscape.md](doc/math/software-landscape.md) |
 | **Novelty statement** — unique features, target audience, what this is not | [doc/math/novelty-statement.md](doc/math/novelty-statement.md) |
+| **Complexity & scalability** — O() analysis, measured timings on real meshes, HyperIdeal bottleneck | [doc/math/complexity.md](doc/math/complexity.md) |
 | **Roadmap** — Phases 1–10 | [doc/roadmap/phases.md](doc/roadmap/phases.md) |
 | **Java parity table** — what is ported, what is planned | [doc/roadmap/java-parity.md](doc/roadmap/java-parity.md) |
 | **Contributing** — language policy, test standards, release flow | [doc/contributing.md](doc/contributing.md) |

code/CMakeLists.txt

@@ -140,3 +140,25 @@ install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/../LICENSE
               ${CMAKE_CURRENT_SOURCE_DIR}/../CITATION.cff
         DESTINATION ${CMAKE_INSTALL_DATADIR}/conformallab)
+
+# ── Doxygen documentation target (Phase 7.5) ──────────────────────────────────
+# Generates HTML API documentation into doc/doxygen/html/.
+# Usage:
+#   cmake --build build --target doc
+#   open doc/doxygen/html/index.html
+#
+# Optional dependency: install Doxygen via `brew install doxygen` (macOS) or
+# `apt install doxygen graphviz` (Linux). The target is silently disabled
+# if Doxygen is not found.
+find_package(Doxygen QUIET)
+if(DOXYGEN_FOUND)
+    set(DOXYGEN_PROJECT_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/..)
+    add_custom_target(doc
+        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_PROJECT_ROOT}/Doxyfile
+        WORKING_DIRECTORY ${DOXYGEN_PROJECT_ROOT}
+        COMMENT "Generating API documentation with Doxygen"
+        VERBATIM)
+    message(STATUS "Doxygen found: target 'doc' available (cmake --build build --target doc)")
+else()
+    message(STATUS "Doxygen not found — 'doc' target unavailable (install: brew/apt install doxygen)")
+endif()

code/include/CGAL/Conformal_layout.h

@@ -0,0 +1,111 @@
+// Copyright (c) 2024-2026 Tarik Moussa.
+// SPDX-License-Identifier: MIT
+//
+// Package: conformallab++ / Discrete_conformal_map (Phase 8b-Lite, 2026-05-21)
+
+/*!
+\file CGAL/Conformal_layout.h
+\ingroup PkgConformalMapRef
+
+Thin CGAL-style wrapper around the legacy `euclidean_layout()`,
+`spherical_layout()` and `hyper_ideal_layout()` functions defined in
+`code/include/layout.hpp`.
+
+This header lets a CGAL-side caller go directly from a `*Maps` bundle
+and the Newton-converged DOF vector to a `Layout2D` / `Layout3D` result,
+without needing to include the legacy header explicitly.
+*/
+
+#ifndef CGAL_CONFORMAL_LAYOUT_H
+#define CGAL_CONFORMAL_LAYOUT_H
+
+#include <CGAL/Conformal_map/internal/parameters.h>
+#include <CGAL/Named_function_parameters.h>
+#include <CGAL/boost/graph/named_params_helper.h>
+
+#include "../layout.hpp"
+
+namespace CGAL {
+
+// ── Re-exported layout types ─────────────────────────────────────────────────
+//
+// `Layout2D`, `Layout3D` and `HolonomyData` are defined in
+// `conformallab::layout` (see `code/include/layout.hpp`).  We re-export
+// them here so users of the CGAL API don't need to know the legacy
+// namespace.
+
+using ::conformallab::Layout2D;
+using ::conformallab::Layout3D;
+using ::conformallab::HolonomyData;
+using ::conformallab::CutGraph;
+
+// ── Wrapper functions ────────────────────────────────────────────────────────
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the planar Euclidean layout of `mesh` from a converged DOF
+vector `x` and a `EuclideanMaps` bundle.  Optional named parameters:
+
+* `cut_graph` (pointer-to `CutGraph`, default `nullptr`) — supply a
+  pre-computed cut graph to get a globally consistent layout on closed
+  meshes.
+* `holonomy_data` (pointer-to `HolonomyData`, default `nullptr`) — if
+  non-null, the wrapper records translation/rotation holonomies around
+  each cut edge.
+* `normalise` (bool, default `false`) — apply the canonical PCA
+  centroid + major-axis normalisation.
+
+\returns A `Layout2D` with `uv[v]` per vertex.
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+Layout2D euclidean_layout(
+    TriangleMesh&                              mesh,
+    const std::vector<double>&                 x,
+    const ::conformallab::EuclideanMaps&       maps,
+    const CGAL_NP_CLASS& = parameters::default_values())
+{
+    // No CGAL-side named-parameter overrides needed for Phase 8b-Lite:
+    // forward straight to the legacy implementation with sensible
+    // defaults.  Richer parameter support (cut/holonomy/normalise via
+    // named params) is on the post-1.0 wishlist; the legacy API can be
+    // called directly in the meantime.
+    return ::conformallab::euclidean_layout(mesh, x, maps);
+}
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the spherical layout of `mesh` (points on S² ⊂ ℝ³).
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+Layout3D spherical_layout(
+    TriangleMesh&                              mesh,
+    const std::vector<double>&                 x,
+    const ::conformallab::SphericalMaps&       maps,
+    const CGAL_NP_CLASS& = parameters::default_values())
+{
+    return ::conformallab::spherical_layout(mesh, x, maps);
+}
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the hyperbolic layout of `mesh` (Poincaré disk model).
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+Layout2D hyper_ideal_layout(
+    TriangleMesh&                              mesh,
+    const std::vector<double>&                 x,
+    const ::conformallab::HyperIdealMaps&      maps,
+    const CGAL_NP_CLASS& = parameters::default_values())
+{
+    return ::conformallab::hyper_ideal_layout(mesh, x, maps);
+}
+
+}  // namespace CGAL
+
+#endif  // CGAL_CONFORMAL_LAYOUT_H

code/include/CGAL/Conformal_map/internal/parameters.h

@@ -0,0 +1,127 @@
+// Copyright (c) 2024-2026 Tarik Moussa.
+// SPDX-License-Identifier: MIT
+//
+// Package: conformallab++ / Discrete_conformal_map (Phase 8 MVP, 2026-05-19)
+
+/*!
+\file CGAL/Conformal_map/internal/parameters.h
+\internal
+\ingroup PkgConformalMapRef
+
+Named-parameter tag definitions specific to the Discrete_conformal_map
+package.  These tags extend the CGAL named-parameter mechanism
+(see `<CGAL/Named_function_parameters.h>`).
+
+Usage from a user perspective is in `CGAL::parameters::*`; the tags
+themselves live in `CGAL::Conformal_map::internal_np`.
+
+This is an internal header — users should not include it directly.
+*/
+
+#ifndef CGAL_CONFORMAL_MAP_INTERNAL_PARAMETERS_H
+#define CGAL_CONFORMAL_MAP_INTERNAL_PARAMETERS_H
+
+#include <CGAL/Named_function_parameters.h>
+
+namespace CGAL {
+namespace Conformal_map {
+
+/// \internal
+/// Parameter tags for the conformal-map package.  Each tag is an
+/// `enum` whose name ends in `_t` and a value whose name does not.
+/// The pattern follows CGAL convention so that the existing
+/// `choose_parameter` / `get_parameter` machinery works directly.
+namespace internal_np {
+
+// ─── Target curvature (Θᵥ) ──────────────────────────────────────────────────
+/// Property-map: vertex_descriptor → FT (target cone angle Θᵥ in radians).
+/// Default: 2π at every interior vertex, π at every boundary vertex.
+enum vertex_curvature_map_t { vertex_curvature_map };
+
+// ─── Newton solver tolerances ───────────────────────────────────────────────
+/// Convergence threshold for the Newton solver: ‖G(u)‖∞ < tol.
+/// Type: FT.  Default: 1e-10.
+enum gradient_tolerance_t { gradient_tolerance };
+
+/// Maximum number of Newton iterations.
+/// Type: int.  Default: 200.
+/// (Reuses the CGAL `number_of_iterations` tag where appropriate; this
+/// alias is provided for vocabulary continuity within the package.)
+enum max_iterations_t { max_iterations };
+
+// ─── DOF / gauge fixing ─────────────────────────────────────────────────────
+/// Property-map: vertex_descriptor → bool.  `true` ⇒ vertex is pinned
+/// (u_v = 0, removed from the Newton DOF vector).
+/// Default: first vertex is pinned, all others are variable.
+enum fixed_vertex_map_t { fixed_vertex_map };
+
+}  // namespace internal_np
+}  // namespace Conformal_map
+
+namespace parameters {
+
+/*!
+\addtogroup PkgConformalMapNamedParameters
+\{
+*/
+
+/// \name Discrete conformal map — package-specific named parameters
+/// \{
+
+/// `vertex_curvature_map(pmap)` — target cone angle Θᵥ per vertex.
+/// Type: model of `ReadablePropertyMap` with key = `vertex_descriptor`,
+/// value = `FT`.  If omitted, the package uses 2π at interior vertices
+/// and π at boundary vertices (the natural Gauss–Bonnet target for an
+/// open disk or closed flat surface).
+template <typename PropertyMap>
+auto vertex_curvature_map(const PropertyMap& pmap)
+{
+    return CGAL::Named_function_parameters<
+        PropertyMap,
+        Conformal_map::internal_np::vertex_curvature_map_t,
+        CGAL::internal_np::No_property
+    >(pmap);
+}
+
+/// `gradient_tolerance(eps)` — Newton stopping criterion ‖G‖∞ < eps.
+template <typename FT>
+auto gradient_tolerance(FT eps)
+{
+    return CGAL::Named_function_parameters<
+        FT,
+        Conformal_map::internal_np::gradient_tolerance_t,
+        CGAL::internal_np::No_property
+    >(eps);
+}
+
+/// `max_iterations(n)` — Newton iteration limit.
+inline auto max_iterations(int n)
+{
+    return CGAL::Named_function_parameters<
+        int,
+        Conformal_map::internal_np::max_iterations_t,
+        CGAL::internal_np::No_property
+    >(n);
+}
+
+/// `fixed_vertex_map(pmap)` — which vertices are pinned for gauge-fixing.
+/// Type: model of `ReadablePropertyMap` with key = `vertex_descriptor`,
+/// value = `bool`.  If omitted, the first vertex in the mesh is pinned
+/// (compatible with the existing legacy API).
+template <typename PropertyMap>
+auto fixed_vertex_map(const PropertyMap& pmap)
+{
+    return CGAL::Named_function_parameters<
+        PropertyMap,
+        Conformal_map::internal_np::fixed_vertex_map_t,
+        CGAL::internal_np::No_property
+    >(pmap);
+}
+
+/// \}
+/// \}
+
+}  // namespace parameters
+}  // namespace CGAL
+
+#endif  // CGAL_CONFORMAL_MAP_INTERNAL_PARAMETERS_H

code/include/CGAL/Conformal_map_traits.h

@@ -0,0 +1,164 @@
+// Copyright (c) 2024-2026 Tarik Moussa.
+// SPDX-License-Identifier: MIT
+//
+// Package: conformallab++ / Discrete_conformal_map (Phase 8 MVP, 2026-05-19)
+
+/*!
+\file CGAL/Conformal_map_traits.h
+\ingroup PkgConformalMapRef
+
+Defines the `ConformalMapTraits` concept and the default model
+`Default_conformal_map_traits<TriangleMesh, K>` for the package.
+
+The concept lists the types and property maps that the discrete-conformal
+algorithms require from any backing data structure.  By templatising the
+algorithms on this concept, the package can run on any CGAL halfedge
+mesh — `Surface_mesh`, `Polyhedron_3`, OpenMesh-adapter, pmp — without
+changes to the algorithm code.
+
+For Phase 8 MVP only the `Surface_mesh` specialisation is provided
+(specialisation 8a.1).  A generic `FaceGraph` specialisation is on the
+roadmap as 8a.2.
+
+\sa `CGAL::Discrete_conformal_map`
+\sa `CGAL::parameters::vertex_curvature_map`
+*/
+
+#ifndef CGAL_CONFORMAL_MAP_TRAITS_H
+#define CGAL_CONFORMAL_MAP_TRAITS_H
+
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/Simple_cartesian.h>
+#include <boost/graph/graph_traits.hpp>
+
+namespace CGAL {
+
+// ════════════════════════════════════════════════════════════════════════════
+// \cgalConcept
+//
+// \concept ConformalMapTraits
+// \ingroup PkgConformalMapConcepts
+//
+// The concept `ConformalMapTraits` describes the requirements that any
+// Traits model must fulfil for the Discrete_conformal_map package.
+//
+// \cgalHasModelsBegin
+// \cgalHasModels{CGAL::Default_conformal_map_traits<TriangleMesh, K>}
+// \cgalHasModelsEnd
+//
+// \section RequiredTypes Required types
+//
+// | Type | Description |
+// |------|-------------|
+// | `Triangle_mesh` | A model of CGAL `FaceGraph` + `HalfedgeGraph`. |
+// | `Kernel`        | A CGAL kernel; defaults to `Simple_cartesian<double>`. |
+// | `FT`            | Field type used internally (typically `double`). |
+// | `Vertex_descriptor`   | `boost::graph_traits<Triangle_mesh>::vertex_descriptor`. |
+// | `Halfedge_descriptor` | analogously. |
+// | `Edge_descriptor`     | analogously. |
+// | `Face_descriptor`     | analogously. |
+//
+// \section RequiredProperties Required property-map accessors
+//
+// The Traits class is responsible for *locating* the property maps that
+// the algorithm reads from and writes to.  The semantics follow the
+// project conventions (see `doc/api/contracts.md` for the full table):
+//
+// | Property             | Key                     | Value | Access  | Used by |
+// |----------------------|-------------------------|-------|---------|---------|
+// | `vertex_points(m)`   | `Vertex_descriptor`     | `Point_3` | Read | input geometry |
+// | `theta_map(m)`       | `Vertex_descriptor`     | `FT`  | RW      | target cone angle Θᵥ |
+// | `vertex_index_map(m)`| `Vertex_descriptor`     | `int` | RW      | DOF index (−1 = pinned) |
+// | `lambda0_map(m)`     | `Edge_descriptor`       | `FT`  | RW      | base log-length λ°ᵢⱼ |
+//
+// Each accessor is a `static` member that returns the map; it must be
+// idempotent (calling twice yields the same map by name lookup).
+// ════════════════════════════════════════════════════════════════════════════
+
+
+// ════════════════════════════════════════════════════════════════════════════
+// Default_conformal_map_traits  —  primary template (undefined)
+// ════════════════════════════════════════════════════════════════════════════
+//
+// The undefined primary template forces specialisation per mesh type.
+// MVP provides only the `Surface_mesh` specialisation below; further
+// mesh types (Polyhedron_3, OpenMesh, pmp) are deferred to Phase 8a.2.
+
+template <typename TriangleMesh,
+          typename Kernel_ = CGAL::Simple_cartesian<double>>
+struct Default_conformal_map_traits;
+
+
+// ════════════════════════════════════════════════════════════════════════════
+// Specialisation: CGAL::Surface_mesh<K::Point_3>
+// ════════════════════════════════════════════════════════════════════════════
+
+/*!
+\ingroup PkgConformalMapRef
+
+Default traits for `CGAL::Surface_mesh`.  Wraps the property maps that
+the existing implementation (`code/include/euclidean_functional.hpp`)
+attaches to a Surface_mesh under the `"ev:idx"`, `"ev:theta"`,
+`"ee:lam0"` etc. names.
+
+This specialisation is the only one available in Phase 8 MVP.  It is
+selected automatically when `TriangleMesh = CGAL::Surface_mesh<...>`.
+
+\tparam K  Any CGAL kernel.  Defaults to `Simple_cartesian<double>`,
+           which is what `conformal_mesh.hpp` uses today.
+*/
+template <typename K>
+struct Default_conformal_map_traits<CGAL::Surface_mesh<typename K::Point_3>, K>
+{
+    using Kernel        = K;
+    using FT            = typename K::FT;
+    using Point_3       = typename K::Point_3;
+    using Triangle_mesh = CGAL::Surface_mesh<Point_3>;
+
+    using Vertex_descriptor   = typename boost::graph_traits<Triangle_mesh>::vertex_descriptor;
+    using Halfedge_descriptor = typename boost::graph_traits<Triangle_mesh>::halfedge_descriptor;
+    using Edge_descriptor     = typename boost::graph_traits<Triangle_mesh>::edge_descriptor;
+    using Face_descriptor     = typename boost::graph_traits<Triangle_mesh>::face_descriptor;
+
+    // Property-map types — match the names used by setup_euclidean_maps().
+    using Vertex_point_map      = typename Triangle_mesh::template Property_map<Vertex_descriptor, Point_3>;
+    using Theta_pmap            = typename Triangle_mesh::template Property_map<Vertex_descriptor, FT>;
+    using Vertex_index_pmap     = typename Triangle_mesh::template Property_map<Vertex_descriptor, int>;
+    using Lambda0_pmap          = typename Triangle_mesh::template Property_map<Edge_descriptor, FT>;
+
+    // ─── Property-map accessors ───────────────────────────────────────────
+    //
+    // Each accessor returns a property map under its canonical legacy name.
+    // If no such map exists yet it is created with sensible defaults — so
+    // calling either `setup_euclidean_maps(m)` first or the accessor first
+    // is equivalent.
+
+    static Vertex_point_map vertex_points(Triangle_mesh& m) {
+        return m.points();
+    }
+
+    static Theta_pmap theta_map(Triangle_mesh& m) {
+        auto [pm, created] = m.template add_property_map<Vertex_descriptor, FT>(
+            "ev:theta", FT(2.0 * 3.141592653589793238));
+        (void)created;
+        return pm;
+    }
+
+    static Vertex_index_pmap vertex_index_map(Triangle_mesh& m) {
+        auto [pm, created] = m.template add_property_map<Vertex_descriptor, int>(
+            "ev:idx", -1);
+        (void)created;
+        return pm;
+    }
+
+    static Lambda0_pmap lambda0_map(Triangle_mesh& m) {
+        auto [pm, created] = m.template add_property_map<Edge_descriptor, FT>(
+            "ee:lam0", FT(0));
+        (void)created;
+        return pm;
+    }
+};
+
+}  // namespace CGAL
+
+#endif  // CGAL_CONFORMAL_MAP_TRAITS_H

code/include/CGAL/Discrete_circle_packing.h

@@ -0,0 +1,166 @@
+// Copyright (c) 2024-2026 Tarik Moussa.
+// SPDX-License-Identifier: MIT
+//
+// Package: conformallab++ / Discrete_conformal_map (Phase 8b-Lite, 2026-05-21)
+
+/*!
+\file CGAL/Discrete_circle_packing.h
+\ingroup PkgConformalMapRef
+
+User-facing entry for the **face-based** circle-packing functional of
+Bobenko-Pinkall-Springborn 2010.  See `cp_euclidean_functional.hpp`
+for the underlying algorithm and `doc/architecture/phase-9a-validation.md`
+for the line-by-line mapping to the Java original
+`CPEuclideanFunctional.java`.
+
+This functional has a fundamentally different DOF structure to the
+classical Euclidean / Spherical / HyperIdeal modes — one log-radius
+`ρ_f` per **face** rather than one log-scale `u_v` per vertex.  We
+therefore expose it via a dedicated header with its own default-trait
+class (Strategy C of the Phase 8b architecture audit).
+*/
+
+#ifndef CGAL_DISCRETE_CIRCLE_PACKING_H
+#define CGAL_DISCRETE_CIRCLE_PACKING_H
+
+#include <CGAL/Conformal_map/internal/parameters.h>
+#include <CGAL/Kernel_traits.h>
+#include <CGAL/Named_function_parameters.h>
+#include <CGAL/boost/graph/named_params_helper.h>
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/Simple_cartesian.h>
+#include <boost/graph/graph_traits.hpp>
+
+#include "../cp_euclidean_functional.hpp"
+#include "../newton_solver.hpp"
+
+namespace CGAL {
+
+// ── Default traits for CP-Euclidean ───────────────────────────────────────────
+
+template <typename TriangleMesh,
+          typename Kernel_ = CGAL::Simple_cartesian<double>>
+struct Default_cp_euclidean_traits;
+
+template <typename K>
+struct Default_cp_euclidean_traits<CGAL::Surface_mesh<typename K::Point_3>, K>
+{
+    using Kernel        = K;
+    using FT            = typename K::FT;
+    using Point_3       = typename K::Point_3;
+    using Triangle_mesh = CGAL::Surface_mesh<Point_3>;
+
+    using Vertex_descriptor   = typename boost::graph_traits<Triangle_mesh>::vertex_descriptor;
+    using Halfedge_descriptor = typename boost::graph_traits<Triangle_mesh>::halfedge_descriptor;
+    using Edge_descriptor     = typename boost::graph_traits<Triangle_mesh>::edge_descriptor;
+    using Face_descriptor     = typename boost::graph_traits<Triangle_mesh>::face_descriptor;
+
+    // CP-Euclidean property maps — note the *face* DOF index map.
+    using Face_index_pmap = typename Triangle_mesh::template Property_map<Face_descriptor,   int>;
+    using Theta_e_pmap    = typename Triangle_mesh::template Property_map<Edge_descriptor,   FT>;
+    using Phi_f_pmap      = typename Triangle_mesh::template Property_map<Face_descriptor,   FT>;
+};
+
+// ── Result type ───────────────────────────────────────────────────────────────
+
+/*!
+\ingroup PkgConformalMapRef
+
+Result of `discrete_circle_packing_euclidean`.  Carries face DOFs
+`ρ_f = log R_f` rather than the vertex DOFs of the classical modes.
+*/
+template <typename FT = double>
+struct Circle_packing_result
+{
+    /// Face DOFs `ρ_f = log R_f` (length = num_faces(mesh); pinned face = 0).
+    std::vector<FT> rho_per_face;
+
+    int  iterations    = 0;
+    FT   gradient_norm = FT(0);
+    bool converged     = false;
+};
+
+// ── Entry function ────────────────────────────────────────────────────────────
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the BPS-2010 face-based circle-packing of `mesh`.
+
+\tparam TriangleMesh  A `CGAL::Surface_mesh<P>`.
+\tparam NamedParameters  Optional CGAL named-parameter pack.
+
+\param mesh  Input triangle mesh.
+\param np    Named parameters (subset of those documented on
+             `discrete_conformal_map_euclidean`; the curvature-map
+             parameter `vertex_curvature_map` is **not** used in this
+             face-based mode — instead the per-face target angle sum
+             `φ_f` and per-edge intersection angle `θ_e` are set via
+             the property maps on `mesh` before this call, or left at
+             their defaults `φ_f = 2π`, `θ_e = π/2`).
+
+\returns A `Circle_packing_result<FT>` with `ρ_f` per face.
+
+\pre `mesh` is a triangle mesh.
+\pre `φ_f` and `θ_e` satisfy the BPS-2010 admissibility conditions
+     (Σ_f φ_f = 2π·χ + Σ_e (π − θ_e), see paper §6).
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+auto discrete_circle_packing_euclidean(
+    TriangleMesh& mesh,
+    const CGAL_NP_CLASS& np = parameters::default_values())
+{
+    using Point_type     = typename TriangleMesh::Point;
+    using Default_kernel = typename CGAL::Kernel_traits<Point_type>::Kernel;
+    using Default_traits = Default_cp_euclidean_traits<TriangleMesh, Default_kernel>;
+    using Traits         = typename internal_np::Lookup_named_param_def<
+                              internal_np::geom_traits_t,
+                              CGAL_NP_CLASS,
+                              Default_traits>::type;
+    using FT             = typename Traits::FT;
+
+    Circle_packing_result<FT> result;
+
+    auto maps = ::conformallab::setup_cp_euclidean_maps(mesh);
+
+    // Pin first face by default; `fixed_vertex_map` is reused here as the
+    // "fixed face" override hook (the parameter tag is generic enough).
+    // For a richer API, a dedicated `fixed_face_map` tag could be added.
+    auto it = mesh.faces().begin();
+    if (it == mesh.faces().end()) {
+        return result;   // empty mesh; trivial
+    }
+    const int n = ::conformallab::assign_cp_euclidean_face_dof_indices(mesh, maps, *it);
+
+    const FT  tol      = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::gradient_tolerance),
+        FT(1e-10));
+    const int max_iter = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::max_iterations),
+        200);
+
+    // Natural-phi default: shift φ_f so the gradient at ρ = 0 is zero.
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = ::conformallab::cp_euclidean_gradient(mesh, x0, maps);
+    for (auto f : mesh.faces()) {
+        int i = maps.f_idx[f];
+        if (i >= 0) maps.phi_f[f] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    auto nr = ::conformallab::newton_cp_euclidean(mesh, x0, maps, tol, max_iter);
+
+    result.rho_per_face.assign(num_faces(mesh), FT(0));
+    for (auto f : mesh.faces()) {
+        int j = maps.f_idx[f];
+        if (j >= 0) result.rho_per_face[f.idx()] = nr.x[static_cast<std::size_t>(j)];
+    }
+    result.iterations    = nr.iterations;
+    result.gradient_norm = nr.grad_inf_norm;
+    result.converged     = nr.converged;
+    return result;
+}
+
+}  // namespace CGAL
+
+#endif  // CGAL_DISCRETE_CIRCLE_PACKING_H

code/include/CGAL/Discrete_conformal_map.h

@@ -0,0 +1,490 @@
+// Copyright (c) 2024-2026 Tarik Moussa.
+// SPDX-License-Identifier: MIT
+//
+// Package: conformallab++ / Discrete_conformal_map (Phase 8 MVP, 2026-05-19)
+
+/*!
+\file CGAL/Discrete_conformal_map.h
+\ingroup PkgConformalMapRef
+
+User-facing entry point for the Discrete_conformal_map package.
+
+This header provides a single function — `discrete_conformal_map_euclidean`
+— that computes a Euclidean discrete-conformal flattening of an open or
+closed triangle mesh.  Spherical and hyperbolic variants are scheduled
+for Phase 8b.2 once the Euclidean pattern is validated by Phase 9a
+(Inversive-Distance functional).
+
+\section Example Simplest usage
+
+\code{.cpp}
+#include <CGAL/Simple_cartesian.h>
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/Discrete_conformal_map.h>
+
+using K = CGAL::Simple_cartesian<double>;
+using Mesh = CGAL::Surface_mesh<K::Point_3>;
+
+int main() {
+    Mesh mesh = ...;  // load a triangle mesh
+    auto result = CGAL::discrete_conformal_map_euclidean(mesh);
+    if (!result.converged)
+        return 1;
+    // result.u_per_vertex[v] now holds the conformal scale factor at v.
+}
+\endcode
+
+\section NamedParams Tuning via named parameters
+
+\code{.cpp}
+auto result = CGAL::discrete_conformal_map_euclidean(
+    mesh,
+    CGAL::parameters::gradient_tolerance(1e-12)
+                     .max_iterations(500));
+\endcode
+
+\sa `CGAL::Default_conformal_map_traits`
+\sa `CGAL::parameters::vertex_curvature_map`
+*/
+
+#ifndef CGAL_DISCRETE_CONFORMAL_MAP_H
+#define CGAL_DISCRETE_CONFORMAL_MAP_H
+
+#include <CGAL/Conformal_map_traits.h>
+#include <CGAL/Conformal_map/internal/parameters.h>
+#include <CGAL/Kernel_traits.h>
+#include <CGAL/Named_function_parameters.h>
+#include <CGAL/boost/graph/named_params_helper.h>
+#include <CGAL/property_map.h>
+
+// Existing implementation headers (Layer 1 — unchanged).
+#include "../euclidean_functional.hpp"
+#include "../spherical_functional.hpp"
+#include "../hyper_ideal_functional.hpp"
+#include "../gauss_bonnet.hpp"
+#include "../newton_solver.hpp"
+
+#include <vector>
+#include <unordered_map>
+
+namespace CGAL {
+
+// ════════════════════════════════════════════════════════════════════════════
+// Result type
+// ════════════════════════════════════════════════════════════════════════════
+
+/*!
+\ingroup PkgConformalMapRef
+
+Result of `discrete_conformal_map_euclidean`.  Carries the converged
+scale factors `u_v`, Newton diagnostics, and the convergence flag.
+*/
+template <typename FT = double>
+struct Conformal_map_result
+{
+    /// Conformal scale factor `u_v` per vertex (indexed by raw vertex index).
+    /// Length: `num_vertices(mesh)`.
+    std::vector<FT> u_per_vertex;
+
+    /// Number of Newton iterations performed.
+    int iterations = 0;
+
+    /// `‖G(u*)‖∞` at termination.
+    FT gradient_norm = FT(0);
+
+    /// `true` iff `gradient_norm < gradient_tolerance`.
+    bool converged = false;
+
+    /// `true` iff the linear solver used the SparseQR fallback at any
+    /// Newton step (gauge mode on closed mesh without pinned vertex).
+    bool sparse_qr_fallback_used = false;
+};
+
+
+// ════════════════════════════════════════════════════════════════════════════
+// discrete_conformal_map_euclidean  —  user-facing entry
+// ════════════════════════════════════════════════════════════════════════════
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the Euclidean discrete-conformal map of `mesh`.
+
+This is the user-facing entry of Phase 8 MVP.  Internally it delegates
+to the existing implementation in `code/include/euclidean_functional.hpp`
+and `code/include/newton_solver.hpp` (Phase 1–7), so the algorithmic
+behaviour is identical to the legacy API; this function only changes
+the public façade.
+
+\tparam TriangleMesh  A `CGAL::Surface_mesh<P>` for some point type `P`.
+                      Other `FaceGraph` models are planned for Phase 8a.2.
+\tparam NamedParameters  Optional CGAL named-parameter pack.
+
+\param mesh  The input mesh (modified in place: property maps are attached).
+\param np    Named parameters:
+  \cgalParamNBegin{vertex_curvature_map}
+    \cgalParamDescription{Property map `vertex → FT` of target cone angles Θᵥ.}
+    \cgalParamDefault{2π at interior vertices, π at boundary vertices.}
+  \cgalParamNEnd
+  \cgalParamNBegin{gradient_tolerance}
+    \cgalParamDescription{Newton stops when `‖G(u)‖∞ < tol`.}
+    \cgalParamDefault{`1e-10`}
+  \cgalParamNEnd
+  \cgalParamNBegin{max_iterations}
+    \cgalParamDescription{Hard limit on Newton steps.}
+    \cgalParamDefault{`200`}
+  \cgalParamNEnd
+  \cgalParamNBegin{fixed_vertex_map}
+    \cgalParamDescription{Property map `vertex → bool`; `true` ⇒ pinned.}
+    \cgalParamDefault{The first vertex in `mesh.vertices()` is pinned.}
+  \cgalParamNEnd
+
+\returns A `Conformal_map_result<FT>` carrying `u_v` and Newton diagnostics.
+
+\pre `mesh` is a triangle mesh.
+\pre `mesh` satisfies the Gauss–Bonnet relation
+     `Σ(2π − Θᵥ) = 2π·χ(mesh)` for the chosen target curvature map.
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+auto discrete_conformal_map_euclidean(
+    TriangleMesh& mesh,
+    const CGAL_NP_CLASS& np = parameters::default_values())
+{
+    // ── Type plumbing ──────────────────────────────────────────────────────
+    //
+    // Deduce the kernel from the mesh's Point_3 type rather than hard-coding
+    // Simple_cartesian<double>.  This lets the wrapper work with any
+    // Surface_mesh<P> whose P is a CGAL kernel point.  The user can override
+    // the entire traits class via the `geom_traits(...)` named parameter
+    // (Phase 8b.2 extension; default below covers the common case).
+    using Point_type      = typename TriangleMesh::Point;
+    using Default_kernel  = typename CGAL::Kernel_traits<Point_type>::Kernel;
+    using Default_traits  = Default_conformal_map_traits<TriangleMesh, Default_kernel>;
+    using Traits          = typename internal_np::Lookup_named_param_def<
+                                internal_np::geom_traits_t,
+                                CGAL_NP_CLASS,
+                                Default_traits>::type;
+    using FT              = typename Traits::FT;
+
+    Conformal_map_result<FT> result;
+
+    // ── 1. Set up property maps (legacy layer) ─────────────────────────────
+    auto maps = ::conformallab::setup_euclidean_maps(mesh);
+    ::conformallab::compute_euclidean_lambda0_from_mesh(mesh, maps);
+
+    // ── 2. Target curvature: user-supplied or "natural-theta" default ─────
+    auto theta_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::vertex_curvature_map);
+    constexpr bool has_theta = !std::is_same_v<
+        decltype(theta_param), internal_np::Param_not_found>;
+    if constexpr (has_theta) {
+        // User-provided Θ: copy into the property map and verify Gauss–Bonnet.
+        // Throws std::runtime_error if the user-supplied Θ violates GB.
+        for (auto v : mesh.vertices())
+            maps.theta_v[v] = get(theta_param, v);
+        ::conformallab::check_gauss_bonnet(mesh, maps);
+    }
+    // If no Θ is supplied, the default behaviour is "natural-theta": set Θ
+    // such that x = 0 is the natural equilibrium (the actual angle sums at
+    // x = 0 become the targets).  This matches the convention of the
+    // existing test suite and guarantees that the default invocation
+    // converges immediately for any well-formed triangle mesh.
+    // The actual Θ adjustment is done after DOF assignment (step 5b below).
+
+    // ── 3. Pin vertices: user map, or the first vertex by default ──────────
+    //
+    // The legacy v_idx property map has -1 as default (= pinned).  We must
+    // first mark every vertex as "free" (any non-negative sentinel), then
+    // pin the requested ones, then assign sequential DOF indices.
+    constexpr int FREE = 0;
+    for (auto v : mesh.vertices())
+        maps.v_idx[v] = FREE;
+
+    auto pin_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::fixed_vertex_map);
+    constexpr bool has_pin = !std::is_same_v<
+        decltype(pin_param), internal_np::Param_not_found>;
+
+    bool any_pinned = false;
+    if constexpr (has_pin) {
+        for (auto v : mesh.vertices())
+            if (get(pin_param, v)) {
+                maps.v_idx[v] = -1;
+                any_pinned = true;
+            }
+    }
+    if (!any_pinned) {
+        auto it = mesh.vertices().begin();
+        if (it != mesh.vertices().end()) {
+            maps.v_idx[*it] = -1;
+            any_pinned = true;
+        }
+    }
+
+    // ── 4. Assign DOF indices 0..n−1 to non-pinned vertices ─────────────────
+    int idx = 0;
+    for (auto v : mesh.vertices())
+        if (maps.v_idx[v] != -1)
+            maps.v_idx[v] = idx++;
+
+    // ── 5. Read tolerances ─────────────────────────────────────────────────
+    const FT  tol      = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::gradient_tolerance),
+        FT(1e-10));
+    const int max_iter = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::max_iterations),
+        200);
+
+    // ── 5b. Natural-theta default: shift Θ so that x = 0 is the equilibrium
+    //
+    // Only applied when the user did NOT supply a vertex_curvature_map.
+    // The trick: evaluate G at x = 0, then subtract G_v from Θ_v.  After
+    // this shift the new G(0) is identically zero, so Newton starts at the
+    // optimum and immediately reports "converged".  This matches the
+    // contract of the existing test suite ("natural-theta" pattern).
+    std::vector<double> x0(static_cast<std::size_t>(idx), 0.0);
+    if constexpr (!has_theta) {
+        auto G0 = ::conformallab::euclidean_gradient(mesh, x0, maps);
+        for (auto v : mesh.vertices()) {
+            const int j = maps.v_idx[v];
+            if (j >= 0)
+                maps.theta_v[v] -= G0[static_cast<std::size_t>(j)];
+        }
+    }
+
+    // ── 6. Newton on x_0 = 0 ───────────────────────────────────────────────
+    auto nr = ::conformallab::newton_euclidean(mesh, x0, maps, tol, max_iter);
+
+    // ── 7. Pack result: u_v for every vertex, including pinned (u=0) ──────
+    result.u_per_vertex.assign(num_vertices(mesh), FT(0));
+    for (auto v : mesh.vertices()) {
+        const int j = maps.v_idx[v];
+        if (j >= 0)
+            result.u_per_vertex[v.idx()] = nr.x[static_cast<std::size_t>(j)];
+        // else: pinned ⇒ u_v stays 0
+    }
+    result.iterations    = nr.iterations;
+    result.gradient_norm = nr.grad_inf_norm;
+    result.converged     = nr.converged;
+
+    return result;
+}
+
+
+// ════════════════════════════════════════════════════════════════════════════
+// discrete_conformal_map_spherical  —  Phase 8b-Lite
+// ════════════════════════════════════════════════════════════════════════════
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the spherical discrete-conformal map of a closed genus-0 mesh.
+
+The spherical DCE energy is *concave*, so its Hessian is NSD at the
+optimum and `newton_spherical()` factorises −H internally (handled by
+the legacy implementation; no caller action required).  A gauge vertex
+is pinned automatically to remove the rotational mode.
+
+\tparam TriangleMesh  A `CGAL::Surface_mesh<P>` for some point type `P`.
+\tparam NamedParameters  Optional CGAL named-parameter pack.
+
+\param mesh  The input mesh (modified in place: property maps attached).
+\param np    Same named parameters as `discrete_conformal_map_euclidean`.
+
+\returns A `Conformal_map_result<FT>` carrying `u_v` per vertex and
+         Newton diagnostics.
+
+\pre `mesh` is a closed genus-0 triangle mesh.
+\pre The user-supplied or natural-theta Θ satisfies the spherical
+     Gauss–Bonnet relation `Σ(2π − Θᵥ) = 4π` (sphere).
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+auto discrete_conformal_map_spherical(
+    TriangleMesh& mesh,
+    const CGAL_NP_CLASS& np = parameters::default_values())
+{
+    using Point_type     = typename TriangleMesh::Point;
+    using Default_kernel = typename CGAL::Kernel_traits<Point_type>::Kernel;
+    using Default_traits = Default_conformal_map_traits<TriangleMesh, Default_kernel>;
+    using Traits         = typename internal_np::Lookup_named_param_def<
+                              internal_np::geom_traits_t,
+                              CGAL_NP_CLASS,
+                              Default_traits>::type;
+    using FT             = typename Traits::FT;
+
+    Conformal_map_result<FT> result;
+
+    auto maps = ::conformallab::setup_spherical_maps(mesh);
+    ::conformallab::compute_lambda0_from_mesh(mesh, maps);
+
+    auto theta_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::vertex_curvature_map);
+    constexpr bool has_theta = !std::is_same_v<
+        decltype(theta_param), internal_np::Param_not_found>;
+    if constexpr (has_theta) {
+        for (auto v : mesh.vertices())
+            maps.theta_v[v] = get(theta_param, v);
+    }
+
+    // Pin one vertex (gauge fix) — user-supplied or first vertex.
+    constexpr int FREE = 0;
+    for (auto v : mesh.vertices()) maps.v_idx[v] = FREE;
+
+    auto pin_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::fixed_vertex_map);
+    constexpr bool has_pin = !std::is_same_v<
+        decltype(pin_param), internal_np::Param_not_found>;
+
+    bool any_pinned = false;
+    if constexpr (has_pin) {
+        for (auto v : mesh.vertices())
+            if (get(pin_param, v)) { maps.v_idx[v] = -1; any_pinned = true; }
+    }
+    if (!any_pinned) {
+        auto it = mesh.vertices().begin();
+        if (it != mesh.vertices().end()) { maps.v_idx[*it] = -1; any_pinned = true; }
+    }
+
+    int idx = 0;
+    for (auto v : mesh.vertices())
+        if (maps.v_idx[v] != -1) maps.v_idx[v] = idx++;
+
+    const FT  tol      = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::gradient_tolerance),
+        FT(1e-10));
+    const int max_iter = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::max_iterations),
+        200);
+
+    // Natural-theta default for the spherical functional.
+    std::vector<double> x0(static_cast<std::size_t>(idx), 0.0);
+    if constexpr (!has_theta) {
+        auto G0 = ::conformallab::spherical_gradient(mesh, x0, maps);
+        for (auto v : mesh.vertices()) {
+            const int j = maps.v_idx[v];
+            if (j >= 0) maps.theta_v[v] -= G0[static_cast<std::size_t>(j)];
+        }
+    }
+
+    auto nr = ::conformallab::newton_spherical(mesh, x0, maps, tol, max_iter);
+
+    result.u_per_vertex.assign(num_vertices(mesh), FT(0));
+    for (auto v : mesh.vertices()) {
+        const int j = maps.v_idx[v];
+        if (j >= 0) result.u_per_vertex[v.idx()] = nr.x[static_cast<std::size_t>(j)];
+    }
+    result.iterations    = nr.iterations;
+    result.gradient_norm = nr.grad_inf_norm;
+    result.converged     = nr.converged;
+    return result;
+}
+
+
+// ════════════════════════════════════════════════════════════════════════════
+// discrete_conformal_map_hyper_ideal  —  Phase 8b-Lite
+// ════════════════════════════════════════════════════════════════════════════
+
+/*!
+\ingroup PkgConformalMapRef
+
+Result of `discrete_conformal_map_hyper_ideal`.  Carries both vertex
+DOFs `b_v` and edge DOFs `a_e` (hyper-ideal triangles in H³).
+*/
+template <typename FT = double>
+struct Hyper_ideal_map_result
+{
+    /// Vertex DOFs `b_v` (length = num_vertices(mesh); pinned vertices = 0).
+    std::vector<FT> b_per_vertex;
+    /// Edge DOFs `a_e` (length = num_edges(mesh); pinned edges = 0).
+    std::vector<FT> a_per_edge;
+
+    int  iterations    = 0;
+    FT   gradient_norm = FT(0);
+    bool converged     = false;
+};
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the hyper-ideal discrete-conformal map of a triangle mesh
+(Springborn 2020 §4).
+
+\note  Phase 8b-Lite scope: vertex DOFs `b_v` are assigned automatically
+       to all vertices; edge DOFs `a_e` are similarly assigned.  The
+       block-FD Hessian (Phase 9b) is used internally — see
+       `newton_hyper_ideal` for the solver convention.
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+auto discrete_conformal_map_hyper_ideal(
+    TriangleMesh& mesh,
+    const CGAL_NP_CLASS& np = parameters::default_values())
+{
+    using Point_type     = typename TriangleMesh::Point;
+    using Default_kernel = typename CGAL::Kernel_traits<Point_type>::Kernel;
+    using Default_traits = Default_conformal_map_traits<TriangleMesh, Default_kernel>;
+    using Traits         = typename internal_np::Lookup_named_param_def<
+                              internal_np::geom_traits_t,
+                              CGAL_NP_CLASS,
+                              Default_traits>::type;
+    using FT             = typename Traits::FT;
+
+    Hyper_ideal_map_result<FT> result;
+
+    auto maps = ::conformallab::setup_hyper_ideal_maps(mesh);
+    // Hyper-ideal init does not derive from mesh geometry: the user's
+    // Θ_v and θ_e are the model inputs.  Defaults from setup are
+    // Θ_v = 2π, θ_e = π (orthogonal).
+
+    auto theta_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::vertex_curvature_map);
+    constexpr bool has_theta = !std::is_same_v<
+        decltype(theta_param), internal_np::Param_not_found>;
+    if constexpr (has_theta) {
+        for (auto v : mesh.vertices())
+            maps.theta_v[v] = get(theta_param, v);
+    }
+
+    const int n = ::conformallab::assign_all_dof_indices(mesh, maps);
+
+    const FT  tol      = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::gradient_tolerance),
+        FT(1e-8));
+    const int max_iter = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::max_iterations),
+        200);
+
+    // Initial point: b_v = 1.0 (positive log-scale), a_e = 0.5 (moderate).
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    for (auto v : mesh.vertices()) {
+        int i = maps.v_idx[v];
+        if (i >= 0) x0[static_cast<std::size_t>(i)] = 1.0;
+    }
+    for (auto e : mesh.edges()) {
+        int i = maps.e_idx[e];
+        if (i >= 0) x0[static_cast<std::size_t>(i)] = 0.5;
+    }
+
+    auto nr = ::conformallab::newton_hyper_ideal(mesh, x0, maps, tol, max_iter);
+
+    result.b_per_vertex.assign(num_vertices(mesh), FT(0));
+    result.a_per_edge   .assign(num_edges(mesh),    FT(0));
+    for (auto v : mesh.vertices()) {
+        int j = maps.v_idx[v];
+        if (j >= 0) result.b_per_vertex[v.idx()] = nr.x[static_cast<std::size_t>(j)];
+    }
+    for (auto e : mesh.edges()) {
+        int j = maps.e_idx[e];
+        if (j >= 0) result.a_per_edge[e.idx()] = nr.x[static_cast<std::size_t>(j)];
+    }
+    result.iterations    = nr.iterations;
+    result.gradient_norm = nr.grad_inf_norm;
+    result.converged     = nr.converged;
+    return result;
+}
+
+}  // namespace CGAL
+
+#endif  // CGAL_DISCRETE_CONFORMAL_MAP_H

code/include/CGAL/Discrete_inversive_distance.h

@@ -0,0 +1,191 @@
+// Copyright (c) 2024-2026 Tarik Moussa.
+// SPDX-License-Identifier: MIT
+//
+// Package: conformallab++ / Discrete_conformal_map (Phase 8b-Lite, 2026-05-21)
+
+/*!
+\file CGAL/Discrete_inversive_distance.h
+\ingroup PkgConformalMapRef
+
+User-facing entry for the **vertex-based** inversive-distance circle-
+packing functional of Luo (2004), with the Bowers-Stephenson (2004)
+initialisation.  See `inversive_distance_functional.hpp` for the
+underlying algorithm and `doc/roadmap/research-track.md` (item 9a.2)
+for the research-track classification — this functional has **no Java
+original** (verified empirically), it is from-the-literature research.
+
+DOF structure
+─────────────
+* Per-vertex `u_i = log r_i` (compatible with the classical Euclidean
+  trait).
+* Per-edge constant `I_ij` computed once by Bowers-Stephenson from the
+  input mesh geometry (handled internally by
+  `compute_inversive_distance_init_from_mesh`).
+
+Because the per-edge constant has a different meaning from the
+Euclidean `λ°_e`, this entry has its own default-trait class
+`Default_inversive_distance_traits`.
+*/
+
+#ifndef CGAL_DISCRETE_INVERSIVE_DISTANCE_H
+#define CGAL_DISCRETE_INVERSIVE_DISTANCE_H
+
+#include <CGAL/Conformal_map/internal/parameters.h>
+#include <CGAL/Kernel_traits.h>
+#include <CGAL/Named_function_parameters.h>
+#include <CGAL/boost/graph/named_params_helper.h>
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/Simple_cartesian.h>
+#include <boost/graph/graph_traits.hpp>
+
+#include <CGAL/Discrete_conformal_map.h>   // for Conformal_map_result<FT>
+
+#include "../inversive_distance_functional.hpp"
+#include "../newton_solver.hpp"
+
+namespace CGAL {
+
+// ── Default traits for Inversive-Distance ────────────────────────────────────
+
+template <typename TriangleMesh,
+          typename Kernel_ = CGAL::Simple_cartesian<double>>
+struct Default_inversive_distance_traits;
+
+template <typename K>
+struct Default_inversive_distance_traits<CGAL::Surface_mesh<typename K::Point_3>, K>
+{
+    using Kernel        = K;
+    using FT            = typename K::FT;
+    using Point_3       = typename K::Point_3;
+    using Triangle_mesh = CGAL::Surface_mesh<Point_3>;
+
+    using Vertex_descriptor   = typename boost::graph_traits<Triangle_mesh>::vertex_descriptor;
+    using Edge_descriptor     = typename boost::graph_traits<Triangle_mesh>::edge_descriptor;
+
+    // Inversive-distance specific property maps.
+    using Vertex_index_pmap = typename Triangle_mesh::template Property_map<Vertex_descriptor, int>;
+    using Theta_v_pmap      = typename Triangle_mesh::template Property_map<Vertex_descriptor, FT>;
+    using R0_pmap           = typename Triangle_mesh::template Property_map<Vertex_descriptor, FT>;
+    using I_e_pmap          = typename Triangle_mesh::template Property_map<Edge_descriptor,   FT>;
+};
+
+// ── Entry function ────────────────────────────────────────────────────────────
+
+/*!
+\ingroup PkgConformalMapRef
+
+Compute the Luo-2004 vertex-based inversive-distance circle packing of `mesh`.
+
+The per-edge constant `I_ij` is computed once at the start from the input
+3-D geometry via the Bowers-Stephenson identity
+    `I_ij = (ℓ_ij² − r_i² − r_j²) / (2 r_i r_j)`,
+with `r_i^(0) = (1/3) min{ℓ_e : e adj v_i}` as the default initial radii.
+The user can override the initial radii by writing into the `r0`
+property map before calling this function.
+
+\tparam TriangleMesh  A `CGAL::Surface_mesh<P>`.
+\tparam NamedParameters  Optional CGAL named-parameter pack.
+
+\param mesh  Input triangle mesh.
+\param np    Named parameters:
+  - `vertex_curvature_map(pmap)` — per-vertex Θ_v target.
+  - `fixed_vertex_map(pmap)` — pinning override.
+  - `gradient_tolerance(ε)` — Newton stop.
+  - `max_iterations(n)` — Newton iteration cap.
+
+\returns A `Conformal_map_result<FT>` with `u_per_vertex[v] = log r_v`
+         (the converged log-radius at each vertex).
+
+\pre `mesh` is a triangle mesh with positive edge lengths.
+\pre The user-supplied or natural-theta Θ satisfies Gauss–Bonnet.
+
+\note  Convergence is sensitive to the initial point and to extreme
+       `I_ij` values.  For testing purposes the natural-theta default
+       (Θ_v shifted so that u = 0 is the equilibrium) always converges
+       in zero iterations.
+*/
+template <typename TriangleMesh,
+          typename CGAL_NP_TEMPLATE_PARAMETERS>
+auto discrete_inversive_distance_map(
+    TriangleMesh& mesh,
+    const CGAL_NP_CLASS& np = parameters::default_values())
+{
+    using Point_type     = typename TriangleMesh::Point;
+    using Default_kernel = typename CGAL::Kernel_traits<Point_type>::Kernel;
+    using Default_traits = Default_inversive_distance_traits<TriangleMesh, Default_kernel>;
+    using Traits         = typename internal_np::Lookup_named_param_def<
+                              internal_np::geom_traits_t,
+                              CGAL_NP_CLASS,
+                              Default_traits>::type;
+    using FT             = typename Traits::FT;
+
+    Conformal_map_result<FT> result;
+
+    auto maps = ::conformallab::setup_inversive_distance_maps(mesh);
+    ::conformallab::compute_inversive_distance_init_from_mesh(mesh, maps);
+
+    auto theta_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::vertex_curvature_map);
+    constexpr bool has_theta = !std::is_same_v<
+        decltype(theta_param), internal_np::Param_not_found>;
+    if constexpr (has_theta) {
+        for (auto v : mesh.vertices())
+            maps.theta_v[v] = get(theta_param, v);
+    }
+
+    // Pin first vertex by default; user can override with fixed_vertex_map.
+    constexpr int FREE = 0;
+    for (auto v : mesh.vertices()) maps.v_idx[v] = FREE;
+
+    auto pin_param = parameters::get_parameter(
+        np, Conformal_map::internal_np::fixed_vertex_map);
+    constexpr bool has_pin = !std::is_same_v<
+        decltype(pin_param), internal_np::Param_not_found>;
+
+    bool any_pinned = false;
+    if constexpr (has_pin) {
+        for (auto v : mesh.vertices())
+            if (get(pin_param, v)) { maps.v_idx[v] = -1; any_pinned = true; }
+    }
+    if (!any_pinned) {
+        auto it = mesh.vertices().begin();
+        if (it != mesh.vertices().end()) { maps.v_idx[*it] = -1; any_pinned = true; }
+    }
+
+    int idx = 0;
+    for (auto v : mesh.vertices())
+        if (maps.v_idx[v] != -1) maps.v_idx[v] = idx++;
+
+    const FT  tol      = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::gradient_tolerance),
+        FT(1e-10));
+    const int max_iter = parameters::choose_parameter(
+        parameters::get_parameter(np, Conformal_map::internal_np::max_iterations),
+        200);
+
+    // Natural-theta default.
+    std::vector<double> x0(static_cast<std::size_t>(idx), 0.0);
+    if constexpr (!has_theta) {
+        auto G0 = ::conformallab::inversive_distance_gradient(mesh, x0, maps);
+        for (auto v : mesh.vertices()) {
+            const int j = maps.v_idx[v];
+            if (j >= 0) maps.theta_v[v] -= G0[static_cast<std::size_t>(j)];
+        }
+    }
+
+    auto nr = ::conformallab::newton_inversive_distance(mesh, x0, maps, tol, max_iter);
+
+    result.u_per_vertex.assign(num_vertices(mesh), FT(0));
+    for (auto v : mesh.vertices()) {
+        const int j = maps.v_idx[v];
+        if (j >= 0) result.u_per_vertex[v.idx()] = nr.x[static_cast<std::size_t>(j)];
+    }
+    result.iterations    = nr.iterations;
+    result.gradient_norm = nr.grad_inf_norm;
+    result.converged     = nr.converged;
+    return result;
+}
+
+}  // namespace CGAL
+
+#endif  // CGAL_DISCRETE_INVERSIVE_DISTANCE_H

code/include/cp_euclidean_functional.hpp

@@ -0,0 +1,364 @@
+#pragma once
+// cp_euclidean_functional.hpp
+//
+// Phase 9a.1 — Circle-Packing Euclidean functional (CP-Euclidean).
+//
+// Ported from de.varylab.discreteconformal.functional.CPEuclideanFunctional
+// (Java, 260 lines).  Mathematical reference:
+//   Bobenko, A. I., Pinkall, U. & Springborn, B. (2010)
+//   "Discrete conformal maps and ideal hyperbolic polyhedra"
+//   Geometry & Topology 14, 379-426.
+//
+// ┌──────────────────────────────────────────────────────────────────────────┐
+// │  FACE-based circle packing                                                │
+// │                                                                           │
+// │  Each face f of the mesh carries a circle of radius R_f.                  │
+// │  The variable is ρ_f = log R_f.                                           │
+// │  Adjacent face-circles intersect at a prescribed angle θ_e per edge.      │
+// │                                                                           │
+// │  This is the FACE-DUAL of the classical vertex-based Luo (2004)           │
+// │  inversive-distance circle packing implemented in                          │
+// │  inversive_distance_functional.hpp (Phase 9a.2).  The relation            │
+// │     I_ij  =  cos θ_e                                                       │
+// │  identifies the two parametrisations (Glickenstein 2011 §5).              │
+// │                                                                           │
+// │  DOFs                                                                     │
+// │    x[f_idx[f]] = ρ_f   (face-dual log-radius)                             │
+// │    f_idx[f] = −1 means f is pinned (ρ_f = 0, gauge fix)                  │
+// │                                                                           │
+// │  Constants                                                                │
+// │    θ_e per edge   intersection angle of the two face-circles              │
+// │    φ_f per face   target sum of corner-angles inside the face             │
+// │                                                                           │
+// │  Energy  (BPS-2010 §6)                                                    │
+// │    E(ρ) =  Σ_f  φ_f · ρ_f                                                  │
+// │         +  Σ_{(h,f=face(h)):                                              │
+// │              [ if opposite face exists ]                                   │
+// │                ½ p(θ*,Δρ)·Δρ + Λ(θ*+p) − θ*·ρ_left                       │
+// │              [ else (boundary halfedge) ]                                  │
+// │                −2 θ*·ρ_left                                                │
+// │            ]                                                              │
+// │                                                                           │
+// │    where    θ* = π − θ                                                    │
+// │             Δρ = ρ_right − ρ_left                                          │
+// │             p(θ*, Δρ) = 2·atan( tan(θ*/2) · tanh(Δρ/2) )                  │
+// │             Λ        = Clausen function (Lobachevsky)                     │
+// │                                                                           │
+// │  Gradient                                                                 │
+// │    Per face f:        +φ_f                                                │
+// │    Per interior hf:   −(p + θ*)  added to G[face(h)]                      │
+// │    Per boundary hf:   −2 θ*       added to G[face(h)]                     │
+// │                                                                           │
+// │  Hessian (analytic, BPS-2010 eq. 6.8; Java getHessian lines 127-166)     │
+// │    Per interior undirected edge e (connecting faces j and k):             │
+// │      h_jk = sin θ / (cosh Δρ − cos θ)                                     │
+// │      H[j,j] += h_jk,  H[k,k] += h_jk,  H[j,k] −= h_jk,  H[k,j] −= h_jk    │
+// │    Pinned faces contribute nothing (their row/col is removed).            │
+// └──────────────────────────────────────────────────────────────────────────┘
+//
+// Halfedge convention (matches Java's "leftFace / rightFace"):
+//   For a directed halfedge h in CGAL::Surface_mesh:
+//     mesh.face(h)             ≡ leftFace
+//     mesh.face(opposite(h))   ≡ rightFace  (may be null on boundary)
+//     mesh.is_border(h) == true iff h has no face (h points outward).
+//   Property-map name prefix: "cf:" (face) and "ce:" (edge).
+
+#include "conformal_mesh.hpp"
+#include "constants.hpp"
+#include "clausen.hpp"
+#include <Eigen/Sparse>
+#include <CGAL/boost/graph/iterator.h>
+#include <vector>
+#include <cmath>
+#include <cstdint>
+#include <iostream>
+
+namespace conformallab {
+
+// ── Property-map type aliases ────────────────────────────────────────────────
+
+using CPFMapI = ConformalMesh::Property_map<Face_index, int>;
+using CPFMapD = ConformalMesh::Property_map<Face_index, double>;
+using CPEMapD = ConformalMesh::Property_map<Edge_index, double>;
+
+// ── Persistent map bundle ─────────────────────────────────────────────────────
+
+struct CPEuclideanMaps {
+    CPFMapI f_idx;     ///< DOF index per face (−1 = pinned)
+    CPEMapD theta_e;   ///< intersection angle per edge (default π/2 = orthogonal)
+    CPFMapD phi_f;     ///< target face-angle sum   (default 2π)
+};
+
+// Create the property maps with sensible defaults.
+// θ_e = π/2 produces an orthogonal circle packing (Koebe-Andreev-Thurston).
+// φ_f = 2π is the natural target for a flat triangle.
+inline CPEuclideanMaps setup_cp_euclidean_maps(ConformalMesh& mesh)
+{
+    CPEuclideanMaps m;
+    m.f_idx   = mesh.add_property_map<Face_index, int>   ("cf:idx",   -1     ).first;
+    m.theta_e = mesh.add_property_map<Edge_index, double>("ce:theta", PI / 2 ).first;
+    m.phi_f   = mesh.add_property_map<Face_index, double>("cf:phi",   TWO_PI ).first;
+    return m;
+}
+
+// Assign DOF indices 0..n-1 to all faces except `pinned`, which gets −1.
+// Mirrors Java CPEuclideanFunctional's convention "skip face index 0".
+inline int assign_cp_euclidean_face_dof_indices(ConformalMesh&  mesh,
+                                                  CPEuclideanMaps& m,
+                                                  Face_index       pinned)
+{
+    int idx = 0;
+    for (auto f : mesh.faces()) {
+        if (f == pinned) m.f_idx[f] = -1;
+        else             m.f_idx[f] = idx++;
+    }
+    return idx;
+}
+
+// Convenience: pin the first face in iteration order.
+inline int assign_cp_euclidean_face_dof_indices(ConformalMesh&  mesh,
+                                                  CPEuclideanMaps& m)
+{
+    auto it = mesh.faces().begin();
+    if (it == mesh.faces().end()) return 0;
+    return assign_cp_euclidean_face_dof_indices(mesh, m, *it);
+}
+
+inline int cp_euclidean_dimension(const ConformalMesh& mesh,
+                                    const CPEuclideanMaps& m)
+{
+    int dim = 0;
+    for (auto f : mesh.faces()) if (m.f_idx[f] >= 0) ++dim;
+    return dim;
+}
+
+// ── Internal helpers ──────────────────────────────────────────────────────────
+
+namespace cp_detail {
+
+// p(θ*, Δρ) = 2·atan( tan(θ*/2) · tanh(Δρ/2) )
+// Numerically stable form lifted directly from CPEuclideanFunctional.java
+// (private method `p`, lines 243-247).
+inline double p_function(double thStar, double dRho) noexcept
+{
+    const double e          = std::exp(dRho);
+    const double tanh_half  = (e - 1.0) / (e + 1.0);
+    return 2.0 * std::atan(std::tan(0.5 * thStar) * tanh_half);
+}
+
+// DOF reader: returns 0 for the pinned face (idx = −1).
+inline double dof_val(int idx, const std::vector<double>& x) noexcept
+{
+    return idx >= 0 ? x[static_cast<std::size_t>(idx)] : 0.0;
+}
+
+} // namespace cp_detail
+
+// ── Energy ────────────────────────────────────────────────────────────────────
+//
+// Mirrors evaluateEnergyAndGradient in the Java code (lines 170-240) for the
+// energy accumulation only.  The gradient is computed in a dedicated function
+// below for clarity.
+inline double cp_euclidean_energy(const ConformalMesh&        mesh,
+                                    const std::vector<double>&  x,
+                                    const CPEuclideanMaps&      m)
+{
+    using cp_detail::dof_val;
+
+    double E = 0.0;
+
+    // Per-face linear term: + φ_f · ρ_f
+    // (The pinned face has f_idx = −1; its ρ is fixed at 0 so it contributes nothing.)
+    for (auto f : mesh.faces()) {
+        const int i = m.f_idx[f];
+        if (i < 0) continue;
+        E += m.phi_f[f] * x[static_cast<std::size_t>(i)];
+    }
+
+    // Per directed halfedge term.  Java iterates over `getEdges()` which in jtem
+    // yields one Edge per directed side; in CGAL we iterate halfedges directly.
+    for (auto h : mesh.halfedges()) {
+        if (mesh.is_border(h)) continue;   // h is in the outer "border" face → skip
+        const Face_index fL = mesh.face(h);
+        const Halfedge_index ho = mesh.opposite(h);
+        const Face_index fR = mesh.is_border(ho) ? Face_index() : mesh.face(ho);
+
+        const double th     = m.theta_e[mesh.edge(h)];
+        const double thStar = PI - th;
+        const double rho_L  = dof_val(m.f_idx[fL], x);
+
+        if (fR == Face_index()) {
+            // Boundary halfedge: only the left face exists.
+            E += -2.0 * thStar * rho_L;
+        } else {
+            const double rho_R = dof_val(m.f_idx[fR], x);
+            const double dRho  = rho_R - rho_L;
+            const double p     = cp_detail::p_function(thStar, dRho);
+            E += 0.5 * p * dRho;
+            E += clausen2(thStar + p);
+            E += -thStar * rho_L;
+        }
+    }
+
+    return E;
+}
+
+// ── Gradient ──────────────────────────────────────────────────────────────────
+//
+// ∂E/∂ρ_f = φ_f − Σ_{h: face(h)=f, !is_border(h)}  (p + θ*)
+//         OR (boundary):                            2 θ*
+inline std::vector<double> cp_euclidean_gradient(const ConformalMesh&        mesh,
+                                                   const std::vector<double>&  x,
+                                                   const CPEuclideanMaps&      m)
+{
+    using cp_detail::dof_val;
+
+    const int n = cp_euclidean_dimension(mesh, m);
+    std::vector<double> G(static_cast<std::size_t>(n), 0.0);
+
+    // Per-face linear term.
+    for (auto f : mesh.faces()) {
+        const int i = m.f_idx[f];
+        if (i < 0) continue;
+        G[static_cast<std::size_t>(i)] += m.phi_f[f];
+    }
+
+    // Per directed halfedge term.
+    for (auto h : mesh.halfedges()) {
+        if (mesh.is_border(h)) continue;
+        const Face_index fL = mesh.face(h);
+        const int        iL = m.f_idx[fL];
+        if (iL < 0) continue;   // pinned face: gradient component is forced to 0
+
+        const Halfedge_index ho = mesh.opposite(h);
+        const Face_index fR = mesh.is_border(ho) ? Face_index() : mesh.face(ho);
+
+        const double th     = m.theta_e[mesh.edge(h)];
+        const double thStar = PI - th;
+        const double rho_L  = dof_val(iL, x);
+
+        if (fR == Face_index()) {
+            G[static_cast<std::size_t>(iL)] -= 2.0 * thStar;
+        } else {
+            const double rho_R = dof_val(m.f_idx[fR], x);
+            const double dRho  = rho_R - rho_L;
+            const double p     = cp_detail::p_function(thStar, dRho);
+            G[static_cast<std::size_t>(iL)] -= (p + thStar);
+        }
+    }
+
+    return G;
+}
+
+// ── Hessian (analytic) ────────────────────────────────────────────────────────
+//
+// Per interior undirected edge e with adjacent faces (j, k):
+//   h_jk = sin θ / (cosh(Δρ) − cos θ)
+// Diagonal contributions on both endpoints; off-diagonal block is −h_jk.
+// Pinned faces are skipped (their DOF index is −1 ⇒ excluded from the matrix).
+inline Eigen::SparseMatrix<double> cp_euclidean_hessian(const ConformalMesh&        mesh,
+                                                          const std::vector<double>&  x,
+                                                          const CPEuclideanMaps&      m)
+{
+    using cp_detail::dof_val;
+
+    const int n = cp_euclidean_dimension(mesh, m);
+    std::vector<Eigen::Triplet<double>> trips;
+    trips.reserve(static_cast<std::size_t>(4 * mesh.number_of_edges()));
+
+    for (auto e : mesh.edges()) {
+        const Halfedge_index h  = mesh.halfedge(e);
+        const Halfedge_index ho = mesh.opposite(h);
+        if (mesh.is_border(h) || mesh.is_border(ho)) continue;   // boundary edge
+
+        const int j = m.f_idx[mesh.face(h)];
+        const int k = m.f_idx[mesh.face(ho)];
+
+        const double rho_j = dof_val(j, x);
+        const double rho_k = dof_val(k, x);
+        const double dRho  = rho_k - rho_j;
+        const double th    = m.theta_e[e];
+        const double hjk   = std::sin(th) / (std::cosh(dRho) - std::cos(th));
+
+        if (j >= 0)              trips.emplace_back(j, j,  hjk);
+        if (k >= 0)              trips.emplace_back(k, k,  hjk);
+        if (j >= 0 && k >= 0) {
+            trips.emplace_back(j, k, -hjk);
+            trips.emplace_back(k, j, -hjk);
+        }
+    }
+
+    Eigen::SparseMatrix<double> H(n, n);
+    H.setFromTriplets(trips.begin(), trips.end());
+    return H;
+}
+
+// ── Finite-difference gradient check ─────────────────────────────────────────
+//
+// Mirrors the Java FunctionalTest pattern:
+//   For each DOF i, compare analytic G[i] to (E(x+ε·e_i) − E(x−ε·e_i)) / (2ε).
+// Default tolerance 1e-6 with ε = 1e-5 leaves ~3 digits of margin for sane meshes.
+inline bool gradient_check_cp_euclidean(const ConformalMesh&        mesh,
+                                          const std::vector<double>&  x,
+                                          const CPEuclideanMaps&      m,
+                                          double eps = 1e-5,
+                                          double tol = 1e-6)
+{
+    auto G = cp_euclidean_gradient(mesh, x, m);
+    const std::size_t n = G.size();
+
+    for (std::size_t i = 0; i < n; ++i) {
+        std::vector<double> xp = x, xm = x;
+        xp[i] += eps;
+        xm[i] -= eps;
+        const double Ep = cp_euclidean_energy(mesh, xp, m);
+        const double Em = cp_euclidean_energy(mesh, xm, m);
+        const double fd = (Ep - Em) / (2.0 * eps);
+        if (std::abs(G[i] - fd) > tol) {
+            std::cerr << "[cp-euclidean] FD gradient mismatch at DOF " << i
+                      << ": analytic=" << G[i]
+                      << "  FD=" << fd
+                      << "  diff=" << (G[i] - fd) << "\n";
+            return false;
+        }
+    }
+    return true;
+}
+
+// ── Finite-difference Hessian check ──────────────────────────────────────────
+//
+// Verifies analytic H against ( G(x+ε·e_i) − G(x−ε·e_i) ) / (2ε) column-wise.
+// Symmetry is implicit in the analytic form; we check both off-diagonal entries.
+inline bool hessian_check_cp_euclidean(const ConformalMesh&        mesh,
+                                         const std::vector<double>&  x,
+                                         const CPEuclideanMaps&      m,
+                                         double eps = 1e-5,
+                                         double tol = 1e-5)
+{
+    const auto H = cp_euclidean_hessian(mesh, x, m);
+    const int n = static_cast<int>(H.rows());
+
+    for (int j = 0; j < n; ++j) {
+        std::vector<double> xp = x, xm = x;
+        xp[static_cast<std::size_t>(j)] += eps;
+        xm[static_cast<std::size_t>(j)] -= eps;
+        auto Gp = cp_euclidean_gradient(mesh, xp, m);
+        auto Gm = cp_euclidean_gradient(mesh, xm, m);
+
+        for (int i = 0; i < n; ++i) {
+            double fd = (Gp[static_cast<std::size_t>(i)] - Gm[static_cast<std::size_t>(i)])
+                        / (2.0 * eps);
+            double an = H.coeff(i, j);
+            if (std::abs(an - fd) > tol) {
+                std::cerr << "[cp-euclidean] FD Hessian mismatch at ("
+                          << i << "," << j << "): analytic=" << an
+                          << "  FD=" << fd
+                          << "  diff=" << (an - fd) << "\n";
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+} // namespace conformallab

code/include/hyper_ideal_functional.hpp

@@ -105,6 +105,76 @@ static inline std::size_t hidx(Halfedge_index h)
     return static_cast<std::size_t>(static_cast<std::uint32_t>(h));
 }
 
+// ── Pure-math face-angle kernel ──────────────────────────────────────────────
+//
+// Computes the six per-face angle outputs (β₁, β₂, β₃, α₁₂, α₂₃, α₃₁) from
+// the six local DOF inputs (b₁, b₂, b₃, a₁₂, a₂₃, a₃₁) and the variability
+// flags (vᵢb).  This is the pure functional core of `compute_face_angles`
+// — no mesh, no property maps, no global x vector.
+//
+// Why exposed as a free function (Phase 9b):
+// ─────────────────────────────────────────
+// The block-FD Hessian (`hyper_ideal_hessian_block_fd`) perturbs only the
+// 6 DOFs adjacent to a single face at a time, recomputes the 6 angle
+// outputs of that face, and uses the local 6×6 Jacobian to scatter into
+// the global Hessian.  Working through a pure 6→6 function (instead of
+// perturbing the full x and re-running the gradient over all faces)
+// reduces the cost of the Hessian from O(F·n) to O(F·36).
+//
+// The clamping logic (negative b → 0.01, negative a → 0) mirrors
+// HyperIdealFunctional.java's defensive behaviour (lines 122-127 of the
+// Java original); this keeps the FD perturbation regime well-defined.
+
+struct FaceAngleOutputs {
+    double beta1, beta2, beta3;       ///< interior angles at v₁,v₂,v₃
+    double alpha12, alpha23, alpha31; ///< dihedral angles at e₁₂,e₂₃,e₃₁
+};
+
+inline FaceAngleOutputs face_angles_from_local_dofs(
+    double b1, double b2, double b3,
+    double a12, double a23, double a31,
+    bool   v1b, bool v2b, bool v3b)
+{
+    // Same defensive clamps as compute_face_angles.
+    if (v1b && v2b && a12 < 0.0) a12 = 0.0;
+    if (v2b && v3b && a23 < 0.0) a23 = 0.0;
+    if (v3b && v1b && a31 < 0.0) a31 = 0.0;
+    if (v1b && b1  < 0.0) b1 = 0.01;
+    if (v2b && b2  < 0.0) b2 = 0.01;
+    if (v3b && b3  < 0.0) b3 = 0.01;
+
+    double l12 = lij(b1, b2, a12, v1b, v2b);
+    double l23 = lij(b2, b3, a23, v2b, v3b);
+    double l31 = lij(b3, b1, a31, v3b, v1b);
+
+    if (l12 < 1E-12 && l23 < 1E-12 && l31 < 1E-12)
+        l12 = l23 = l31 = 1E-12;
+
+    FaceAngleOutputs o;
+
+    if (l12 > l23 + l31) {
+        o.beta1 = 0.0; o.beta2 = 0.0; o.beta3 = PI;
+        o.alpha12 = PI; o.alpha23 = 0.0; o.alpha31 = 0.0;
+    } else if (l23 > l12 + l31) {
+        o.beta1 = PI; o.beta2 = 0.0; o.beta3 = 0.0;
+        o.alpha12 = 0.0; o.alpha23 = PI; o.alpha31 = 0.0;
+    } else if (l31 > l12 + l23) {
+        o.beta1 = 0.0; o.beta2 = PI; o.beta3 = 0.0;
+        o.alpha12 = 0.0; o.alpha23 = 0.0; o.alpha31 = PI;
+    } else {
+        o.beta1 = zeta(l12, l31, l23);
+        o.beta2 = zeta(l23, l12, l31);
+        o.beta3 = zeta(l31, l23, l12);
+        o.alpha12 = alpha_ij(a12, a23, a31, b1, b2, b3,
+                             o.beta1, o.beta2, o.beta3, v1b, v2b, v3b);
+        o.alpha23 = alpha_ij(a23, a31, a12, b2, b3, b1,
+                             o.beta2, o.beta3, o.beta1, v2b, v3b, v1b);
+        o.alpha31 = alpha_ij(a31, a12, a23, b3, b1, b2,
+                             o.beta3, o.beta1, o.beta2, v3b, v1b, v2b);
+    }
+    return o;
+}
+
 // ── Per-face angle kernel ─────────────────────────────────────────────────────
 
 struct FaceAngles {

code/include/hyper_ideal_hessian.hpp

@@ -2,6 +2,7 @@
 // hyper_ideal_hessian.hpp
 //
 // Phase 4a — Hessian of the hyper-ideal discrete conformal functional.
+// Phase 9b — Block-finite-difference Hessian (intermediate optimisation).
 //
 // ┌──────────────────────────────────────────────────────────────────────────┐
 // │  Implementation strategy                                                  │
@@ -9,31 +10,57 @@
 // │  The hyper-ideal functional involves angle functions (ζ, σ, α, β)        │
 // │  composed through several nested layers (lij → ζ13/14/15 → β/α).        │
 // │  Deriving closed-form Hessian entries analytically through all these      │
-// │  layers is feasible but lengthy; an analytical Hessian is left for a    │
-// │  future phase.                                                           │
+// │  layers is feasible but lengthy and is deferred to a future PR.           │
 // │                                                                           │
-// │  Here we compute the Hessian by symmetric finite differences of the     │
-// │  gradient, which is exact to O(ε²) and sufficient for Newton's method   │
-// │  at the meshes typical in Phase 4 (< 500 DOFs):                         │
+// │  TWO Hessian implementations are provided here:                           │
 // │                                                                           │
-// │    H[i,j] = (G(x + ε·eⱼ)[i] − G(x − ε·eⱼ)[i]) / (2ε)                │
+// │    1.  `hyper_ideal_hessian` — full finite-difference baseline.           │
+// │        Cost  ≈  n × (cost of full gradient evaluation)                    │
+// │             =  O(n · F)         where n = #DOFs and F = #faces.           │
+// │        Used for correctness reference and small meshes.                   │
+// │                                                                           │
+// │    2.  `hyper_ideal_hessian_block_fd` — block-local finite-difference,    │
+// │        Phase 9b.  Exploits the fact that each face contributes to the     │
+// │        gradient through exactly 6 DOFs (3 vertex b_i + 3 edge a_e).       │
+// │        Cost  ≈  F × 6 × (cost of a single face-angle evaluation)          │
+// │             =  O(36 · F).                                                 │
+// │        Speed-up factor ≈ n / 36, i.e. typically 10–50× on V > 200.        │
+// │                                                                           │
+// │  Both produce the same Hessian to O(ε²) and pass identical PSD checks.    │
+// │  The block-FD variant is the production default; the full-FD variant is   │
+// │  kept for cross-validation tests.                                         │
+// │                                                                           │
+// │  An analytic Hessian via Schläfli-type differentiation through the chain  │
+// │     (bᵢ, aₑ) → lᵢⱼ → ζ₁₃/ζ₁₄/ζ₁₅ → αᵢⱼ / βᵢ                            │
+// │  is deferred to a future PR (Phase 9b-analytic).  Speed-up would be       │
+// │  another ~6×, taking the cost to O(F).                                    │
 // │                                                                           │
 // │  The hyper-ideal energy is strictly convex (Springborn 2020), so H is    │
 // │  positive semi-definite everywhere and Eigen::SimplicialLDLT applies      │
-// │  directly.                                                               │
+// │  directly to either Hessian variant.                                      │
 // └──────────────────────────────────────────────────────────────────────────┘
+//
+// Note on the Java reference: HyperIdealFunctional.java line 295-298 declares
+//   public boolean hasHessian() { return false; }
+// — i.e. the upstream Java implementation supplies NO Hessian, analytic or
+// numerical.  Both `hyper_ideal_hessian` and `hyper_ideal_hessian_block_fd`
+// are conformallab++ additions beyond Java parity.
 
 #include "hyper_ideal_functional.hpp"
 #include <Eigen/Sparse>
 #include <vector>
 #include <cmath>
+#include <cstdint>
 
 namespace conformallab {
 
-// ── Numerical Hessian via symmetric finite differences ────────────────────────
+// ── Full finite-difference Hessian (baseline, Phase 4a) ──────────────────────
 //
 // Returns the n×n sparse Hessian, where n = hyper_ideal_dimension(mesh, m).
 // eps: finite-difference step size (default 1e-5 gives ~1e-10 relative error).
+//
+// Cost: n × full-gradient evaluations ≈ O(n·F).  Use for small meshes or
+// as a correctness reference for the block-FD variant below.
 inline Eigen::SparseMatrix<double> hyper_ideal_hessian(
     ConformalMesh&             mesh,
     const std::vector<double>& x,
@@ -42,7 +69,7 @@ inline Eigen::SparseMatrix<double> hyper_ideal_hessian(
 {
     const int n = hyper_ideal_dimension(mesh, m);
     std::vector<Eigen::Triplet<double>> trips;
-    trips.reserve(static_cast<std::size_t>(n * n));   // dense upper bound
+    trips.reserve(static_cast<std::size_t>(n * n));
 
     std::vector<double> xp = x, xm = x;
 
@@ -69,7 +96,7 @@ inline Eigen::SparseMatrix<double> hyper_ideal_hessian(
     return H;
 }
 
-// ── Symmetrised Hessian ───────────────────────────────────────────────────────
+// ── Symmetrised Hessian (full-FD variant) ────────────────────────────────────
 //
 // The FD Hessian is symmetric in exact arithmetic; floating-point rounding
 // can introduce tiny asymmetries.  This helper returns (H + Hᵀ)/2.
@@ -84,4 +111,122 @@ inline Eigen::SparseMatrix<double> hyper_ideal_hessian_sym(
     return (H + Ht) * 0.5;
 }
 
+// ── Block-FD Hessian (Phase 9b) ──────────────────────────────────────────────
+//
+// Computes the Hessian by FD on each face's 6×6 local block.  The 6 local
+// DOFs of a face f are:
+//      (b_{v1}, b_{v2}, b_{v3}, a_{e12}, a_{e23}, a_{e31}).
+// For each face we recompute the 6 output angles (β₁,β₂,β₃,α₁₂,α₂₃,α₃₁)
+// at x ± ε along each local axis and read off the 6×6 Jacobian.  The result
+// scatters into the global Hessian via the DOF-index lookup.
+//
+// Why this is correct:
+// ─────────────────────
+// The global gradient decomposes by face:
+//     G_b_v = Σ_{f ∋ v} β_v(f)  −  Θ_v
+//     G_a_e = Σ_{f ∋ e} α_e(f)  −  θ_e
+// Since β and α at face f depend ONLY on the 6 local DOFs of f, the
+// Hessian also decomposes:
+//     ∂G_x/∂y = Σ_{f: x,y ∈ local(f)}  ∂(β or α)/∂y  at f.
+// So accumulating per-face 6×6 blocks reproduces the full Hessian.
+//
+// Cost: F × 12 face-angle evaluations  (6 DOFs × 2 directions).
+// On a tetrahedron (F=4, n≈10):       48 face evaluations
+//                                     vs full-FD ≈ 80         → ~1.7× speed-up.
+// On cathead.obj (F=248, n≈400):     2976 face evaluations
+//                                     vs full-FD ≈ 99,200    → ~33× speed-up.
+// On brezel.obj (F=13824, n≈14000): 165 888 face evaluations
+//                                     vs full-FD ≈ 193 M     → ~1166× speed-up.
+inline Eigen::SparseMatrix<double> hyper_ideal_hessian_block_fd(
+    ConformalMesh&             mesh,
+    const std::vector<double>& x,
+    const HyperIdealMaps&      m,
+    double                     eps = 1e-5)
+{
+    const int n = hyper_ideal_dimension(mesh, m);
+    std::vector<Eigen::Triplet<double>> trips;
+    trips.reserve(36 * mesh.number_of_faces());
+
+    for (auto f : mesh.faces()) {
+        Halfedge_index h0 = mesh.halfedge(f);
+        Halfedge_index h1 = mesh.next(h0);
+        Halfedge_index h2 = mesh.next(h1);
+
+        Vertex_index v1 = mesh.source(h0);
+        Vertex_index v2 = mesh.source(h1);
+        Vertex_index v3 = mesh.source(h2);
+        Edge_index   e12 = mesh.edge(h0);
+        Edge_index   e23 = mesh.edge(h1);
+        Edge_index   e31 = mesh.edge(h2);
+
+        // Local DOF indices: (b1, b2, b3, a12, a23, a31).  Pinned slots = -1.
+        const int idx[6] = {
+            m.v_idx[v1], m.v_idx[v2], m.v_idx[v3],
+            m.e_idx[e12], m.e_idx[e23], m.e_idx[e31]
+        };
+        const bool v1b = idx[0] >= 0;
+        const bool v2b = idx[1] >= 0;
+        const bool v3b = idx[2] >= 0;
+
+        // Local DOF values (0 for pinned).
+        const double vals[6] = {
+            dof_val(idx[0], x), dof_val(idx[1], x), dof_val(idx[2], x),
+            dof_val(idx[3], x), dof_val(idx[4], x), dof_val(idx[5], x)
+        };
+
+        // For each free local DOF, evaluate the 6 outputs at ±ε.
+        // We never perturb a pinned DOF (its column would be physically zero
+        // because it is not part of the DOF vector at all).
+        for (int j = 0; j < 6; ++j) {
+            if (idx[j] < 0) continue;
+
+            double vp[6], vm[6];
+            for (int k = 0; k < 6; ++k) { vp[k] = vm[k] = vals[k]; }
+            vp[j] += eps;
+            vm[j] -= eps;
+
+            auto Op = face_angles_from_local_dofs(
+                vp[0], vp[1], vp[2], vp[3], vp[4], vp[5], v1b, v2b, v3b);
+            auto Om = face_angles_from_local_dofs(
+                vm[0], vm[1], vm[2], vm[3], vm[4], vm[5], v1b, v2b, v3b);
+
+            const double Gp[6] = {
+                Op.beta1, Op.beta2, Op.beta3,
+                Op.alpha12, Op.alpha23, Op.alpha31
+            };
+            const double Gm[6] = {
+                Om.beta1, Om.beta2, Om.beta3,
+                Om.alpha12, Om.alpha23, Om.alpha31
+            };
+
+            for (int i = 0; i < 6; ++i) {
+                if (idx[i] < 0) continue;   // pinned: contributes nothing
+                const double val = (Gp[i] - Gm[i]) / (2.0 * eps);
+                if (std::abs(val) > 1e-15)
+                    trips.emplace_back(idx[i], idx[j], val);
+            }
+        }
+    }
+
+    Eigen::SparseMatrix<double> H(n, n);
+    H.setFromTriplets(trips.begin(), trips.end());
+    return H;
+}
+
+// ── Symmetrised block-FD Hessian ─────────────────────────────────────────────
+//
+// The per-face block is symmetric to within FD rounding, but the
+// accumulation may amplify tiny asymmetries.  This helper returns
+// (H + Hᵀ)/2, identical in spirit to `hyper_ideal_hessian_sym`.
+inline Eigen::SparseMatrix<double> hyper_ideal_hessian_block_fd_sym(
+    ConformalMesh&             mesh,
+    const std::vector<double>& x,
+    const HyperIdealMaps&      m,
+    double                     eps = 1e-5)
+{
+    auto H = hyper_ideal_hessian_block_fd(mesh, x, m, eps);
+    Eigen::SparseMatrix<double> Ht = H.transpose();
+    return (H + Ht) * 0.5;
+}
+
 } // namespace conformallab

code/include/inversive_distance_functional.hpp

@@ -0,0 +1,344 @@
+#pragma once
+// inversive_distance_functional.hpp
+//
+// Phase 9a.2 — Inversive-distance circle-packing functional (Luo 2004).
+//
+// VERTEX-based circle packing.  Each vertex carries a circle of radius
+// r_i = exp(u_i).  The inversive distance I_ij between two adjacent
+// circles is a constant of the edge, derived once from the initial
+// geometry via Bowers-Stephenson 2004.
+//
+// This is the FACE-DUAL of CPEuclideanFunctional (Phase 9a.1).  The
+// correspondence is I_ij = cos θ_e (Glickenstein 2011 §5).
+//
+// ┌──────────────────────────────────────────────────────────────────────────┐
+// │  Mathematical model                                                       │
+// │  ──────────────────                                                       │
+// │                                                                           │
+// │  Variables:    u_i = log r_i           (per vertex; r_i is the radius)   │
+// │  Constants:    I_ij                    (per edge; inversive distance)    │
+// │                Θ_v                     (per vertex; target cone angle)   │
+// │                                                                           │
+// │  Bowers-Stephenson (init from initial geometry):                          │
+// │    I_ij = ( ℓ_ij² − r_i² − r_j² ) / ( 2 r_i r_j )                        │
+// │                                                                           │
+// │  Edge length (Luo 2004 §3, Glickenstein 2011 eq. 2.1):                   │
+// │    ℓ_ij(u)²  =  exp(2 u_i) + exp(2 u_j) + 2 I_ij exp(u_i + u_j)         │
+// │             =  r_i² + r_j² + 2 I_ij r_i r_j                              │
+// │                                                                           │
+// │  Triangle angles:    same half-tangent law of cosines as the              │
+// │                      Euclidean functional (numerically stable).           │
+// │                                                                           │
+// │  Gradient  (Luo 2004 Lemma 3.1):                                          │
+// │    ∂E/∂u_v  =  Θ_v  −  Σ_{T ∋ v}  α_v(T)                                 │
+// │                                                                           │
+// │  Energy:     path integral E(u) = ∫₀¹ ⟨G(tu), u⟩ dt                      │
+// │              (Luo's 1-form is closed; we use 10-point Gauss-Legendre      │
+// │               quadrature, identical to euclidean_functional.hpp)          │
+// │                                                                           │
+// │  Hessian:    finite-difference for the MVP port; an analytic form is      │
+// │              given in Glickenstein 2011 eq. (4.6) and may be added        │
+// │              later for performance.                                       │
+// └──────────────────────────────────────────────────────────────────────────┘
+//
+// Relation to euclidean_functional.hpp
+// ────────────────────────────────────
+// The two are structurally identical in:
+//   • DOF layout (per vertex), DOF index sentinel (−1 = pinned)
+//   • Gradient pattern (Θ − Σ α)
+//   • Energy via path integral (same Gauss-Legendre constants)
+//   • Halfedge convention (h0/h1/h2, source pattern, α opposite-edge)
+//
+// They differ ONLY in:
+//   • Per-edge constant: λ°_ij (log²-length) vs I_ij (inversive distance)
+//   • Edge-length formula:
+//       Euclidean:           ℓ_ij  = exp((λ°_ij + u_i + u_j) / 2)
+//       Inversive distance:  ℓ_ij² = exp(2u_i) + exp(2u_j)
+//                                  + 2 I_ij exp(u_i + u_j)
+//
+// In particular at the tangential limit I_ij = 1 the inversive-distance length
+// reduces to (exp(u_i) + exp(u_j))² ⇒ ℓ_ij = r_i + r_j (tangential circles),
+// which is *different* from the Euclidean-conformal length even at the same
+// initial geometry.  The two functionals describe distinct geometric objects.
+//
+// Property-map name prefix: "iv:" (vertex) and "ie:" (edge).
+
+#include "conformal_mesh.hpp"
+#include "constants.hpp"
+#include "euclidean_geometry.hpp"   // euclidean_angles(λ12, λ23, λ31)
+#include <CGAL/boost/graph/iterator.h>
+#include <vector>
+#include <cmath>
+#include <cstdint>
+#include <iostream>
+
+namespace conformallab {
+
+// ── Property-map type aliases ────────────────────────────────────────────────
+
+using IDVMapI = ConformalMesh::Property_map<Vertex_index, int>;
+using IDVMapD = ConformalMesh::Property_map<Vertex_index, double>;
+using IDEMapD = ConformalMesh::Property_map<Edge_index, double>;
+
+// ── Persistent map bundle ─────────────────────────────────────────────────────
+
+struct InversiveDistanceMaps {
+    IDVMapI v_idx;       ///< DOF index per vertex (−1 = pinned / u_v = 0)
+    IDVMapD theta_v;     ///< target cone angle Θ_v   (default 2π)
+    IDVMapD r0;          ///< initial radius r_i^(0)  (default 1)
+    IDEMapD I_e;         ///< inversive distance I_ij (per edge, constant)
+};
+
+// Create the property maps with sensible defaults.
+inline InversiveDistanceMaps setup_inversive_distance_maps(ConformalMesh& mesh)
+{
+    InversiveDistanceMaps m;
+    m.v_idx   = mesh.add_property_map<Vertex_index, int>   ("iv:idx",   -1     ).first;
+    m.theta_v = mesh.add_property_map<Vertex_index, double>("iv:theta", TWO_PI ).first;
+    m.r0      = mesh.add_property_map<Vertex_index, double>("iv:r0",    1.0    ).first;
+    m.I_e     = mesh.add_property_map<Edge_index,   double>("ie:I",     1.0    ).first;
+    return m;
+}
+
+// Assign sequential DOF indices to all vertices (no gauge pinning here —
+// the caller should set one v_idx to −1 before assigning).
+inline int assign_inversive_distance_vertex_dof_indices(ConformalMesh&         mesh,
+                                                          InversiveDistanceMaps& m)
+{
+    int idx = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = idx++;
+    return idx;
+}
+
+// Count free DOFs.
+inline int inversive_distance_dimension(const ConformalMesh&         mesh,
+                                          const InversiveDistanceMaps& m)
+{
+    int dim = 0;
+    for (auto v : mesh.vertices()) if (m.v_idx[v] >= 0) ++dim;
+    return dim;
+}
+
+// ── Initialisation from initial mesh geometry ────────────────────────────────
+//
+// Two-phase init mirroring "compute_lambda0" for euclidean_functional:
+//   1. Choose r_i^(0).  Simplest heuristic: r_i = (1/3)·(min adjacent ℓ).
+//      Other choices (max ℓ, mean ℓ, length-of-shortest-vertex-cycle) are
+//      possible; the user can override `m.r0[v]` between setup and init.
+//   2. Compute I_ij = ( ℓ² − r_i² − r_j² ) / ( 2 r_i r_j ) for each edge.
+//
+// Note: a valid inversive-distance packing requires I_ij > −1 on every edge,
+// and the triangle inequality must hold on every face under the resulting ℓ.
+// The choice r_i = ⅓·min(ℓ_e adj v) keeps I_ij safely positive for most
+// real meshes.
+inline void compute_inversive_distance_init_from_mesh(ConformalMesh&         mesh,
+                                                        InversiveDistanceMaps& m)
+{
+    // Phase 1: r_i = (1/3) · min adjacent edge length.
+    for (auto v : mesh.vertices()) {
+        double min_len = std::numeric_limits<double>::infinity();
+        for (auto h : CGAL::halfedges_around_target(v, mesh)) {
+            auto p1 = mesh.point(mesh.source(h));
+            auto p2 = mesh.point(mesh.target(h));
+            double dx = p1.x() - p2.x();
+            double dy = p1.y() - p2.y();
+            double dz = p1.z() - p2.z();
+            double len = std::sqrt(dx*dx + dy*dy + dz*dz);
+            if (len < min_len) min_len = len;
+        }
+        m.r0[v] = (std::isfinite(min_len) && min_len > 1e-15)
+                ? min_len / 3.0
+                : 1.0;
+    }
+
+    // Phase 2: I_ij from initial geometry.
+    for (auto e : mesh.edges()) {
+        auto h  = mesh.halfedge(e);
+        auto vi = mesh.source(h);
+        auto vj = mesh.target(h);
+        auto p1 = mesh.point(vi);
+        auto p2 = mesh.point(vj);
+        double dx = p1.x() - p2.x();
+        double dy = p1.y() - p2.y();
+        double dz = p1.z() - p2.z();
+        double l2 = dx*dx + dy*dy + dz*dz;
+        double ri = m.r0[vi];
+        double rj = m.r0[vj];
+        m.I_e[e] = (l2 - ri*ri - rj*rj) / (2.0 * ri * rj);
+    }
+}
+
+// ── Internal helpers ──────────────────────────────────────────────────────────
+
+namespace id_detail {
+
+inline double dof_val(int idx, const std::vector<double>& x) noexcept
+{
+    return idx >= 0 ? x[static_cast<std::size_t>(idx)] : 0.0;
+}
+
+inline std::size_t hidx(Halfedge_index h) noexcept
+{
+    return static_cast<std::size_t>(static_cast<std::uint32_t>(h));
+}
+
+// Inversive-distance edge length squared: ℓ² = exp(2u_i) + exp(2u_j) + 2 I r_i r_j
+// where r_i = exp(u_i), so:  ℓ² = r_i² + r_j² + 2 I r_i r_j.
+// Returns -1 if the result is non-positive (degenerate; the caller skips the face).
+inline double edge_length_squared(double u_i, double u_j, double I_ij) noexcept
+{
+    double ri = std::exp(u_i);
+    double rj = std::exp(u_j);
+    double l2 = ri*ri + rj*rj + 2.0 * I_ij * ri * rj;
+    return l2 > 0.0 ? l2 : -1.0;
+}
+
+} // namespace id_detail
+
+// ── Gradient ──────────────────────────────────────────────────────────────────
+//
+// G_v = Θ_v − Σ_{f ∋ v} α_v(f)
+//
+// Halfedge convention (identical to euclidean_functional.hpp):
+//   h_alpha[h] = corner angle OPPOSITE to the edge of halfedge h in its face.
+inline std::vector<double> inversive_distance_gradient(
+    const ConformalMesh&             mesh,
+    const std::vector<double>&       x,
+    const InversiveDistanceMaps&     m)
+{
+    const int n = inversive_distance_dimension(mesh, m);
+    std::vector<double> G(static_cast<std::size_t>(n), 0.0);
+
+    const std::size_t nh = mesh.number_of_halfedges();
+    std::vector<double> h_alpha(nh, 0.0);
+
+    // Pass 1 — per face, compute corner angles via the law of cosines.
+    // We reuse euclidean_angles(λ12, λ23, λ31) which takes 2·log(ℓ) per edge.
+    for (auto f : mesh.faces()) {
+        Halfedge_index h0 = mesh.halfedge(f);
+        Halfedge_index h1 = mesh.next(h0);
+        Halfedge_index h2 = mesh.next(h1);
+
+        Vertex_index v1 = mesh.source(h0);
+        Vertex_index v2 = mesh.source(h1);
+        Vertex_index v3 = mesh.source(h2);
+
+        Edge_index e12 = mesh.edge(h0);
+        Edge_index e23 = mesh.edge(h1);
+        Edge_index e31 = mesh.edge(h2);
+
+        double u1 = id_detail::dof_val(m.v_idx[v1], x);
+        double u2 = id_detail::dof_val(m.v_idx[v2], x);
+        double u3 = id_detail::dof_val(m.v_idx[v3], x);
+
+        double l12sq = id_detail::edge_length_squared(u1, u2, m.I_e[e12]);
+        double l23sq = id_detail::edge_length_squared(u2, u3, m.I_e[e23]);
+        double l31sq = id_detail::edge_length_squared(u3, u1, m.I_e[e31]);
+
+        if (l12sq <= 0 || l23sq <= 0 || l31sq <= 0) continue;
+
+        // euclidean_angles expects 2·log(ℓ) per edge — feed log(ℓ²).
+        auto fa = euclidean_angles(std::log(l12sq), std::log(l23sq), std::log(l31sq));
+        if (!fa.valid) continue;
+
+        h_alpha[id_detail::hidx(h0)] = fa.alpha3;
+        h_alpha[id_detail::hidx(h1)] = fa.alpha1;
+        h_alpha[id_detail::hidx(h2)] = fa.alpha2;
+    }
+
+    // Pass 2 — accumulate vertex gradient.
+    for (auto v : mesh.vertices()) {
+        int iv = m.v_idx[v];
+        if (iv < 0) continue;
+        double sum_alpha = 0.0;
+        for (auto h : CGAL::halfedges_around_target(v, mesh)) {
+            if (mesh.is_border(h)) continue;
+            sum_alpha += h_alpha[id_detail::hidx(mesh.prev(h))];
+        }
+        G[static_cast<std::size_t>(iv)] = m.theta_v[v] - sum_alpha;
+    }
+
+    return G;
+}
+
+// ── Energy via Gauss-Legendre path integral ─────────────────────────────────
+//
+// E(u) = ∫₀¹ ⟨G(tu), u⟩ dt   (10-point GL, identical constants to euclidean_functional)
+inline double inversive_distance_energy(
+    const ConformalMesh&             mesh,
+    const std::vector<double>&       x,
+    const InversiveDistanceMaps&     m)
+{
+    static const double gl_s[10] = {
+        -0.9739065285171717,  -0.8650633666889845,
+        -0.6794095682990244,  -0.4333953941292472,
+        -0.1488743389816312,   0.1488743389816312,
+         0.4333953941292472,   0.6794095682990244,
+         0.8650633666889845,   0.9739065285171717
+    };
+    static const double gl_w[10] = {
+        0.0666713443086881,  0.1494513491505806,
+        0.2190863625159820,  0.2692667193099963,
+        0.2955242247147529,  0.2955242247147529,
+        0.2692667193099963,  0.2190863625159820,
+        0.1494513491505806,  0.0666713443086881
+    };
+
+    const std::size_t n = x.size();
+    double E = 0.0;
+    std::vector<double> tx(n);
+    for (int k = 0; k < 10; ++k) {
+        double t  = (1.0 + gl_s[k]) * 0.5;
+        double wt = gl_w[k] * 0.5;
+        for (std::size_t i = 0; i < n; ++i) tx[i] = t * x[i];
+        auto G = inversive_distance_gradient(mesh, tx, m);
+        double dot = 0.0;
+        for (std::size_t i = 0; i < n; ++i) dot += G[i] * x[i];
+        E += wt * dot;
+    }
+    return E;
+}
+
+// ── Finite-difference gradient check ─────────────────────────────────────────
+inline bool gradient_check_inversive_distance(
+    const ConformalMesh&             mesh,
+    const std::vector<double>&       x,
+    const InversiveDistanceMaps&     m,
+    double eps = 1e-5,
+    double tol = 1e-6)
+{
+    auto G = inversive_distance_gradient(mesh, x, m);
+    const std::size_t n = G.size();
+
+    for (std::size_t i = 0; i < n; ++i) {
+        std::vector<double> xp = x, xm = x;
+        xp[i] += eps;
+        xm[i] -= eps;
+        double Ep = inversive_distance_energy(mesh, xp, m);
+        double Em = inversive_distance_energy(mesh, xm, m);
+        double fd = (Ep - Em) / (2.0 * eps);
+        if (std::abs(G[i] - fd) > tol) {
+            std::cerr << "[inversive-distance] FD gradient mismatch at DOF " << i
+                      << ": analytic=" << G[i]
+                      << "  FD=" << fd
+                      << "  diff=" << (G[i] - fd) << "\n";
+            return false;
+        }
+    }
+    return true;
+}
+
+// ── Newton equilibrium check: gradient vanishes at converged u ──────────────
+inline bool is_inversive_distance_equilibrium(
+    const ConformalMesh&             mesh,
+    const std::vector<double>&       x,
+    const InversiveDistanceMaps&     m,
+    double tol = 1e-8)
+{
+    auto G = inversive_distance_gradient(mesh, x, m);
+    for (double g : G)
+        if (std::abs(g) > tol) return false;
+    return true;
+}
+
+} // namespace conformallab

code/include/layout.hpp

@@ -698,6 +698,12 @@ inline Layout3D spherical_layout(
                 result.pos[vs.idx()], result.pos[vt.idx()],
                 arc_len(mesh.prev(hx)), arc_len(mesh.next(hx)));
             Eigen::Vector3d diff = p_tri - result.pos[vn.idx()];
+            // Note: spherical holonomy is geometrically a 3-D rotation, not a 2-D
+            // translation.  The Vector2d here stores only the (x,y) component of the
+            // S²-position difference across the cut, which is an approximation.
+            // For accurate spherical holonomy (rotation axis + angle) use the full
+            // 3-D positions in result.pos[] directly.  Phase 10+ will replace this
+            // with a proper SO(3) representation.
             holonomy->translations.push_back(Eigen::Vector2d(diff.x(), diff.y()));
         }
     }
@@ -823,6 +829,13 @@ inline Layout2D hyper_ideal_layout(
             Eigen::Vector2d p_tri = detail::trilaterate_hyp(result.uv[vs.idx()], result.uv[vt.idx()], D, da, db);
             detail::set_face_huv_2d(result.halfedge_uv, mesh, hx, result.uv, p_tri);
             using C = std::complex<double>;
+            // Möbius deck transformation T across cut edge (vs,vt):
+            // T is the unique Möbius isometry of the Poincaré disk that:
+            //   - fixes vs and vt  (z1=w1, z2=w2: the cut-edge endpoints are
+            //     identified across the seam, so T maps each to itself)
+            //   - maps vn (placed side) → p_tri (virtual side)
+            // This uniquely determines the hyperbolic translation/rotation
+            // along the geodesic through vs and vt.
             holonomy->mobius_maps.push_back(MobiusMap::from_three(
                 C(result.uv[vs.idx()].x(), result.uv[vs.idx()].y()),
                 C(result.uv[vs.idx()].x(), result.uv[vs.idx()].y()),

code/include/mesh_utils.hpp

@@ -36,7 +36,7 @@ void simple_visualize_mesh(Eigen::MatrixXd& V, Eigen::MatrixXi& F) {
   viewer.data().set_mesh(V, F);
   viewer.launch();
 }
-// Zero-Copy Map für V (optional)
+// Zero-copy map for V (optional)
 template <typename Kernel>
 Eigen::Map<Eigen::Matrix<double, Eigen::Dynamic, 3, Eigen::RowMajor>>
 get_vertex_map(CGAL::Surface_mesh<typename Kernel::Point_3>& mesh) {

code/include/newton_solver.hpp

@@ -31,6 +31,8 @@
 #include "euclidean_hessian.hpp"
 #include "spherical_hessian.hpp"
 #include "hyper_ideal_hessian.hpp"
+#include "cp_euclidean_functional.hpp"
+#include "inversive_distance_functional.hpp"
 #include <Eigen/SparseCholesky>
 #include <Eigen/SparseQR>
 #include <Eigen/OrderingMethods>
@@ -375,4 +377,187 @@ inline NewtonResult newton_hyper_ideal(
     return res;
 }
 
+// ── CP-Euclidean Newton solver (Phase 9a.1) ───────────────────────────────────
+
+/// Solve the CP-Euclidean circle-packing problem: find ρ ∈ ℝ^F such that the
+/// per-face angle sums match φ_f at every free face.
+///
+/// The CP-Euclidean energy (Bobenko-Pinkall-Springborn 2010 §6) is strictly
+/// convex on its open domain of validity, so the Hessian H is PSD and the
+/// solution is unique up to the gauge mode pinned by `f_idx == −1`.
+/// `cp_euclidean_hessian` provides the analytic 2×2-per-edge formula
+/// `h_jk = sin θ / (cosh Δρ − cos θ)`; no FD machinery is required.
+///
+/// \param mesh      Input triangle mesh (closed or with boundary).
+/// \param x0        Initial DOF vector (length = number of free faces).
+///                  All-zeros is a valid start.
+/// \param m         CPEuclideanMaps: f_idx must have one pinned face
+///                  (`f_idx[f0] == −1`); theta_e and phi_f set by the caller.
+/// \param tol       Convergence threshold on `‖G‖∞`.  Default: 1e-8.
+/// \param max_iter  Newton iteration limit.  Default: 200.
+/// \return          NewtonResult{x*, iterations, grad_inf_norm, converged}.
+///
+/// \note  Unlike the Euclidean solver, the CP-Euclidean Hessian is exact
+///        (analytic), so the SparseQR fallback only triggers in genuine
+///        gauge-singular situations (no pinned face).
+/// \see   doc/architecture/phase-9a-validation.md §1 for the BPS-2010 mapping.
+inline NewtonResult newton_cp_euclidean(
+    ConformalMesh&             mesh,
+    std::vector<double>        x0,
+    const CPEuclideanMaps&     m,
+    double                     tol      = 1e-8,
+    int                        max_iter = 200)
+{
+    std::vector<double> x = x0;
+    const int n = static_cast<int>(x.size());
+
+    NewtonResult res;
+    res.converged      = false;
+    res.iterations     = 0;
+    res.grad_inf_norm  = 0.0;
+
+    for (int iter = 0; iter < max_iter; ++iter) {
+        auto G_std = cp_euclidean_gradient(mesh, x, m);
+        Eigen::Map<const Eigen::VectorXd> G(G_std.data(), n);
+
+        double inf_norm = G.cwiseAbs().maxCoeff();
+        if (inf_norm < tol) {
+            res.converged     = true;
+            res.grad_inf_norm = inf_norm;
+            res.iterations    = iter;
+            res.x             = x;
+            return res;
+        }
+
+        auto H = cp_euclidean_hessian(mesh, x, m);
+        bool ok = false;
+        Eigen::VectorXd dx = detail::solve_with_fallback(H, -G, ok);
+        if (!ok) break;
+
+        double norm0 = G.norm();
+        x = detail::line_search(x, dx, norm0,
+            [&](const std::vector<double>& xnew) {
+                return cp_euclidean_gradient(mesh, xnew, m);
+            });
+
+        res.iterations = iter + 1;
+    }
+
+    auto G_final = cp_euclidean_gradient(mesh, x, m);
+    double inf_final = 0.0;
+    for (double v : G_final) inf_final = std::max(inf_final, std::abs(v));
+    res.grad_inf_norm = inf_final;
+    res.x             = x;
+    return res;
+}
+
+// ── Inversive-Distance Newton solver (Phase 9a.2) ─────────────────────────────
+
+/// Solve the inversive-distance circle-packing problem: find u ∈ ℝ^V such that
+/// Σ_{faces adj v} α_v(u) = Θ_v at every free vertex (Luo 2004 Lemma 3.1).
+///
+/// The inversive-distance energy is (locally) strictly convex on the open
+/// domain where every triangle satisfies the inequalities.  Luo's 1-form is
+/// closed there, so the path-integral energy is well-defined.
+///
+/// MVP implementation: the Hessian is computed by **finite differences** of
+/// the analytic gradient (same pattern as the Phase 4a HyperIdeal solver).
+/// An analytic Hessian via Glickenstein 2011 eq. (4.6) is tracked in
+/// `doc/roadmap/research-track.md` as Phase 9a.2-analytic.
+///
+/// \param mesh      Input triangle mesh.
+/// \param x0        Initial DOF vector (length = number of free vertices).
+/// \param m         InversiveDistanceMaps: v_idx has at least one pinned
+///                  vertex; I_e and r0 set by compute_inversive_distance_init.
+/// \param tol       Convergence threshold on `‖G‖∞`.  Default: 1e-8.
+/// \param max_iter  Newton iteration limit.  Default: 200.
+/// \param hess_eps  FD step size for the Hessian.  Default: 1e-5.
+/// \return          NewtonResult{x*, iterations, grad_inf_norm, converged}.
+///
+/// \note  Convergence is sensitive to the initial point: u = 0 is the
+///        natural choice when `compute_inversive_distance_init_from_mesh`
+///        has been called, since the Bowers-Stephenson identity reconstructs
+///        the input edge lengths at u = 0.
+inline NewtonResult newton_inversive_distance(
+    ConformalMesh&                mesh,
+    std::vector<double>           x0,
+    const InversiveDistanceMaps&  m,
+    double                        tol      = 1e-8,
+    int                           max_iter = 200,
+    double                        hess_eps = 1e-5)
+{
+    std::vector<double> x = x0;
+    const int n = static_cast<int>(x.size());
+
+    NewtonResult res;
+    res.converged      = false;
+    res.iterations     = 0;
+    res.grad_inf_norm  = 0.0;
+
+    // Local FD Hessian builder — n × (cost of gradient eval).
+    auto build_hessian = [&](const std::vector<double>& xc) -> Eigen::SparseMatrix<double> {
+        std::vector<Eigen::Triplet<double>> trips;
+        trips.reserve(static_cast<std::size_t>(n) * 16);   // sparse heuristic
+
+        std::vector<double> xp = xc, xm = xc;
+        for (int j = 0; j < n; ++j) {
+            const std::size_t sj = static_cast<std::size_t>(j);
+            xp[sj] = xc[sj] + hess_eps;
+            xm[sj] = xc[sj] - hess_eps;
+
+            auto Gp = inversive_distance_gradient(mesh, xp, m);
+            auto Gm = inversive_distance_gradient(mesh, xm, m);
+
+            xp[sj] = xm[sj] = xc[sj];   // restore
+
+            for (int i = 0; i < n; ++i) {
+                double val = (Gp[static_cast<std::size_t>(i)]
+                            - Gm[static_cast<std::size_t>(i)])
+                             / (2.0 * hess_eps);
+                if (std::abs(val) > 1e-15)
+                    trips.emplace_back(i, j, val);
+            }
+        }
+        Eigen::SparseMatrix<double> H(n, n);
+        H.setFromTriplets(trips.begin(), trips.end());
+        // Symmetrise — FD rounding may introduce tiny asymmetries.
+        Eigen::SparseMatrix<double> Ht = H.transpose();
+        return (H + Ht) * 0.5;
+    };
+
+    for (int iter = 0; iter < max_iter; ++iter) {
+        auto G_std = inversive_distance_gradient(mesh, x, m);
+        Eigen::Map<const Eigen::VectorXd> G(G_std.data(), n);
+
+        double inf_norm = G.cwiseAbs().maxCoeff();
+        if (inf_norm < tol) {
+            res.converged     = true;
+            res.grad_inf_norm = inf_norm;
+            res.iterations    = iter;
+            res.x             = x;
+            return res;
+        }
+
+        auto H = build_hessian(x);
+        bool ok = false;
+        Eigen::VectorXd dx = detail::solve_with_fallback(H, -G, ok);
+        if (!ok) break;
+
+        double norm0 = G.norm();
+        x = detail::line_search(x, dx, norm0,
+            [&](const std::vector<double>& xnew) {
+                return inversive_distance_gradient(mesh, xnew, m);
+            });
+
+        res.iterations = iter + 1;
+    }
+
+    auto G_final = inversive_distance_gradient(mesh, x, m);
+    double inf_final = 0.0;
+    for (double v : G_final) inf_final = std::max(inf_final, std::abs(v));
+    res.grad_inf_norm = inf_final;
+    res.x             = x;
+    return res;
+}
+
 } // namespace conformallab

code/tests/CMakeLists.txt

@@ -1,5 +1,5 @@
 add_executable(conformallab_tests
-    # ── Fully ported (pure math, no HDS) ────────────────────────────────────
+    # ── Pure-math test suite (no CGAL, no mesh — runs on every branch) ─────
     test_clausen.cpp
     test_hyper_ideal_utility.cpp
     test_matrix_utility.cpp
@@ -7,12 +7,14 @@ add_executable(conformallab_tests
     test_discrete_elliptic_utility.cpp
     test_p2_utility.cpp
     test_hyper_ideal_visualization_utility.cpp
-
-    # ── Stubs: blocked until HDS port (Phase 4) ──────────────────────────────
-    # All tests call GTEST_SKIP() with a clear explanation.
-    test_hyper_ideal_functional.cpp
-    test_hyper_ideal_hyperelliptic_utility.cpp
-    test_spherical_functional.cpp
+    #
+    # Stale stub files were removed in v0.9.0:
+    #   test_hyper_ideal_functional.cpp
+    #   test_hyper_ideal_hyperelliptic_utility.cpp
+    #   test_spherical_functional.cpp
+    # They referenced a "HDS port (Phase 4)" that never happened —
+    # CoHDS was intentionally replaced by CGAL::Surface_mesh, and the
+    # functionals + tests live in code/tests/cgal/test_*_functional.cpp.
 )
 
 target_include_directories(conformallab_tests SYSTEM PRIVATE

code/tests/cgal/CMakeLists.txt

@@ -25,6 +25,13 @@ add_executable(conformallab_cgal_tests
     test_euclidean_hessian.cpp
     test_spherical_hessian.cpp
 
+    # ── Phase 9b: Hyper-ideal Hessian — block-FD vs full-FD validation ───
+    #    Verifies the O(F·36) block-local Hessian agrees with the
+    #    O(F·n) full-FD baseline.  Java upstream has no Hessian at all
+    #    (HyperIdealFunctional.hasHessian() returns false) — both
+    #    variants are conformallab++ extensions beyond the port.
+    test_hyper_ideal_hessian.cpp
+
     # ── Phase 4a: Newton solver ────────────────────────────────────────────
     test_newton_solver.cpp
 
@@ -44,11 +51,44 @@ add_executable(conformallab_cgal_tests
     #             period matrix, fundamental domain, tiling
     test_phase7.cpp
 
-    # ── Java-Parität: Geometrie-Utility-Tests ─────────────────────────────────
-    #    Portiert aus CuttinUtilityTest, UnwrapUtilityTest,
-    #    ConvergenceUtilityTests, HomologyTest (Tests 1–6).
-    #    Test 7 (Genus-2-Homologie) als GTEST_SKIP-Stub bis Phase 8.
+    # ── Java parity: geometry utility tests ──────────────────────────────────
+    #    Ported from CuttinUtilityTest, UnwrapUtilityTest,
+    #    ConvergenceUtilityTests, HomologyTest (tests 1–6).
+    #    Test 7 (genus-2 homology) as GTEST_SKIP stub until Phase 8.
     test_geometry_utils.cpp
+
+    # ── Scalability smoke tests ────────────────────────────────────────────────
+    #    Newton convergence on large real-world meshes (cathead, brezel, brezel2).
+    #    Assert correctness only (< 30 iterations, ||G|| < 1e-8).
+    #    Wall-clock time is printed for documentation but NOT asserted,
+    #    so the tests remain stable on slow CI hardware (Raspberry Pi ARM64).
+    test_scalability_smoke.cpp
+
+    # ── Phase 8 MVP: new CGAL-style public API ────────────────────────────────
+    #    First client of Conformal_map_traits.h + Discrete_conformal_map.h.
+    #    Acceptance probe before Phase 9a (Inversive-Distance) lands.
+    test_cgal_traits_mvp.cpp
+
+    # ── Phase 9a.1: CPEuclideanFunctional (BPS 2010 circle packing) ──────────
+    #    Face-based circle-packing functional ported from
+    #    CPEuclideanFunctional.java.  Reference: Bobenko-Pinkall-Springborn 2010.
+    test_cp_euclidean_functional.cpp
+
+    # ── Phase 9a.2: InversiveDistance (Luo 2004 + Glickenstein 2011) ─────────
+    #    Vertex-based inversive-distance circle-packing functional.  No Java
+    #    reference; implemented from the literature.  Cross-validated against
+    #    EuclideanCyclicFunctional at the natural initial geometry (u = 0).
+    test_inversive_distance_functional.cpp
+
+    # ── Phase 9a: Newton solvers for the two new circle-packing functionals ──
+    #    Convergence tests for newton_cp_euclidean (analytic Hessian) and
+    #    newton_inversive_distance (FD Hessian).
+    test_newton_phase9a.cpp
+
+    # ── Phase 8b-Lite: CGAL entry wrappers for the 4 non-Euclidean modes ─────
+    #    Spherical, HyperIdeal, CircleP-Euclidean, Inversive-Distance via
+    #    <CGAL/Discrete_*.h> public API + Conformal_layout.h wrapper.
+    test_cgal_phase8b_lite.cpp
 )
 
 target_include_directories(conformallab_cgal_tests SYSTEM PRIVATE

code/tests/cgal/test_cgal_phase8b_lite.cpp

@@ -0,0 +1,188 @@
+// test_cgal_phase8b_lite.cpp
+//
+// Phase 8b-Lite — Smoke tests for the four new CGAL-style entry functions
+// added on top of the Phase 8a MVP (`discrete_conformal_map_euclidean`).
+//
+// All entries are thin wrappers around the legacy Newton solvers; the
+// purpose of these tests is to verify:
+//   • the wrapper compiles + dispatches correctly
+//   • named parameters pass through (gradient_tolerance, max_iterations)
+//   • the returned Result struct contains the expected DOF vector
+//   • Newton convergence happens end-to-end via the public API
+
+#include <CGAL/Discrete_conformal_map.h>
+#include <CGAL/Discrete_circle_packing.h>
+#include <CGAL/Discrete_inversive_distance.h>
+#include <CGAL/Conformal_layout.h>
+
+#include "mesh_builder.hpp"
+#include "conformal_mesh.hpp"
+
+#include <gtest/gtest.h>
+#include <cmath>
+
+using namespace conformallab;
+
+namespace {
+
+// Mesh helper — closed regular tetrahedron, used for spherical / hyper-ideal /
+// circle-packing tests.
+inline ConformalMesh make_closed_tet() { return make_tetrahedron(); }
+
+// Open 3-face tetrahedron-minus-face, for layout testing.
+inline ConformalMesh make_open_3face()
+{
+    ConformalMesh mesh;
+    auto v0 = mesh.add_vertex(Point3( 1,  1,  1));
+    auto v1 = mesh.add_vertex(Point3( 1, -1, -1));
+    auto v2 = mesh.add_vertex(Point3(-1,  1, -1));
+    auto v3 = mesh.add_vertex(Point3(-1, -1,  1));
+    mesh.add_face(v0, v2, v1);
+    mesh.add_face(v0, v1, v3);
+    mesh.add_face(v0, v3, v2);
+    return mesh;
+}
+
+} // anonymous
+
+// ════════════════════════════════════════════════════════════════════════════
+// 1.  Spherical entry — closed genus-0 tetrahedron, natural-theta default
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALPhase8bLite, Spherical_ClosedTetrahedron_NaturalThetaConverges)
+{
+    auto mesh = make_closed_tet();
+    auto res  = CGAL::discrete_conformal_map_spherical(mesh);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.gradient_norm, 1e-8);
+    EXPECT_EQ(res.u_per_vertex.size(), num_vertices(mesh));
+    // Natural-theta ⇒ u = 0 is the equilibrium ⇒ all values ≈ 0.
+    for (double u : res.u_per_vertex) EXPECT_NEAR(u, 0.0, 1e-8);
+}
+
+TEST(CGALPhase8bLite, Spherical_NamedParametersTakeEffect)
+{
+    auto mesh = make_closed_tet();
+    auto res  = CGAL::discrete_conformal_map_spherical(
+        mesh,
+        CGAL::parameters::max_iterations(0));
+    EXPECT_EQ(res.iterations, 0);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 2.  Hyper-ideal entry — wrapper compiles + runs, returns both b_v and a_e
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALPhase8bLite, HyperIdeal_Tetrahedron_ReturnsBothVertexAndEdgeDOFs)
+{
+    auto mesh = make_closed_tet();
+    auto res  = CGAL::discrete_conformal_map_hyper_ideal(
+        mesh,
+        CGAL::parameters::max_iterations(20));
+
+    // Newton on default targets (Θ=2π, θ=π) from the "natural" b=1, a=0.5
+    // start may or may not converge in 20 iterations — but the wrapper must
+    // populate the result struct in any case.
+    EXPECT_EQ(res.b_per_vertex.size(), num_vertices(mesh));
+    EXPECT_EQ(res.a_per_edge.size(),    num_edges   (mesh));
+    EXPECT_GE(res.iterations, 0);
+    EXPECT_TRUE(std::isfinite(res.gradient_norm));
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 3.  Circle-packing (face-based) entry — natural-phi convergence
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALPhase8bLite, CirclePacking_ClosedTetrahedron_NaturalPhiConverges)
+{
+    auto mesh = make_closed_tet();
+    auto res  = CGAL::discrete_circle_packing_euclidean(mesh);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.gradient_norm, 1e-8);
+    EXPECT_EQ(res.rho_per_face.size(), num_faces(mesh));
+    // Pinned face is at index 0 (first iterated face); its ρ is 0 by gauge.
+    // After natural-phi the equilibrium is ρ_f = 0 for every face.
+    for (double r : res.rho_per_face) EXPECT_NEAR(r, 0.0, 1e-8);
+}
+
+TEST(CGALPhase8bLite, CirclePacking_GradientToleranceTakesEffect)
+{
+    auto mesh = make_closed_tet();
+    auto res_loose = CGAL::discrete_circle_packing_euclidean(
+        mesh,
+        CGAL::parameters::gradient_tolerance(1e-4));
+    EXPECT_TRUE(res_loose.converged);
+
+    auto mesh2 = make_closed_tet();
+    auto res_strict = CGAL::discrete_circle_packing_euclidean(
+        mesh2,
+        CGAL::parameters::gradient_tolerance(1e-12));
+    EXPECT_TRUE(res_strict.converged);
+    EXPECT_LT(res_strict.gradient_norm, 1e-10);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 4.  Inversive-distance (vertex-based) entry — natural-theta convergence
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALPhase8bLite, InversiveDistance_Triangle_NaturalThetaConverges)
+{
+    auto mesh = make_triangle();
+    auto res  = CGAL::discrete_inversive_distance_map(mesh);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.gradient_norm, 1e-8);
+    EXPECT_EQ(res.u_per_vertex.size(), num_vertices(mesh));
+    for (double u : res.u_per_vertex) EXPECT_NEAR(u, 0.0, 1e-8);
+}
+
+TEST(CGALPhase8bLite, InversiveDistance_QuadStrip_NamedParametersWork)
+{
+    auto mesh = make_quad_strip();
+    // Named-parameter chaining (`a.b().c()`) is not currently supported on
+    // the package-local tags; pass one parameter per call instead.
+    auto res  = CGAL::discrete_inversive_distance_map(
+        mesh,
+        CGAL::parameters::max_iterations(50));
+    EXPECT_TRUE(res.converged);
+    EXPECT_LE(res.iterations, 50);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 5.  Layout wrapper — end-to-end through CGAL API on an open mesh
+//
+// Uses the legacy maps explicitly because the wrappers return the
+// Newton-converged x vector but not the maps.  This exercises that the
+// `CGAL::euclidean_layout` shim works as expected.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALPhase8bLite, Layout_EuclideanWrapper_RoundTrip)
+{
+    auto mesh = make_open_3face();
+
+    // Set up the maps + run Newton via the CGAL Euclidean entry.
+    auto res  = CGAL::discrete_conformal_map_euclidean(mesh);
+    ASSERT_TRUE(res.converged);
+
+    // The wrapper does its own DOF assignment internally; we re-fetch
+    // the (now-populated) EuclideanMaps from the mesh's property maps
+    // to feed the layout wrapper.
+    auto maps = setup_euclidean_maps(mesh);
+    compute_euclidean_lambda0_from_mesh(mesh, maps);
+    // Pin first vertex (mirrors the wrapper's gauge choice).
+    auto vit = mesh.vertices().begin();
+    maps.v_idx[*vit++] = -1;
+    int idx = 0;
+    for (; vit != mesh.vertices().end(); ++vit) maps.v_idx[*vit] = idx++;
+    std::vector<double> x(idx, 0.0);   // wrapper's natural-theta equilibrium
+
+    auto layout = CGAL::euclidean_layout(mesh, x, maps);
+    EXPECT_EQ(layout.uv.size(), num_vertices(mesh));
+    // All UVs finite — basic sanity that the layout ran.
+    for (auto& uv : layout.uv) {
+        EXPECT_TRUE(std::isfinite(uv.x()));
+        EXPECT_TRUE(std::isfinite(uv.y()));
+    }
+}

code/tests/cgal/test_cgal_traits_mvp.cpp

@@ -0,0 +1,246 @@
+// test_cgal_traits_mvp.cpp
+//
+// Phase 8 MVP — first tests for the new CGAL-style public API.
+//
+// Validates:
+//   1. Default_conformal_map_traits<Surface_mesh, K> compiles and
+//      provides all advertised types and property-map accessors.
+//   2. discrete_conformal_map_euclidean() runs end-to-end on a small mesh.
+//   3. Named-parameter overrides (gradient_tolerance, max_iterations)
+//      change the Newton behaviour as expected.
+//   4. The result agrees with the legacy newton_euclidean() at the
+//      same DOF assignment — proving the wrapper is non-destructive.
+//
+// These tests are the Phase 8 MVP acceptance probe.  Phase 9a
+// (Inversive-Distance) will become the next, deeper validation by
+// implementing a new functional against this same trait API.
+
+#include <CGAL/Conformal_map_traits.h>
+#include <CGAL/Discrete_conformal_map.h>
+#include <CGAL/Kernel_traits.h>
+
+#include "mesh_builder.hpp"   // make_triangle, make_quad_strip, make_tetrahedron
+#include "euclidean_functional.hpp"
+#include "newton_solver.hpp"
+
+#include <gtest/gtest.h>
+#include <cmath>
+
+using namespace conformallab;
+
+// ════════════════════════════════════════════════════════════════════════════
+// 1.  Traits class: compile-time type sanity
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALConformalTraits, DefaultTraitsTypes)
+{
+    using K     = CGAL::Simple_cartesian<double>;
+    using Mesh  = CGAL::Surface_mesh<K::Point_3>;
+    using Tr    = CGAL::Default_conformal_map_traits<Mesh, K>;
+
+    // FT comes from the kernel.
+    static_assert(std::is_same_v<typename Tr::FT, double>);
+
+    // Descriptors come from boost::graph_traits, not from Surface_mesh directly.
+    static_assert(std::is_same_v<typename Tr::Triangle_mesh, Mesh>);
+    static_assert(std::is_same_v<
+        typename Tr::Vertex_descriptor,
+        typename boost::graph_traits<Mesh>::vertex_descriptor>);
+
+    // Property-map types should match Surface_mesh::Property_map for the
+    // appropriate key.
+    static_assert(std::is_same_v<
+        typename Tr::Theta_pmap,
+        typename Mesh::template Property_map<typename Tr::Vertex_descriptor, double>>);
+    static_assert(std::is_same_v<
+        typename Tr::Vertex_index_pmap,
+        typename Mesh::template Property_map<typename Tr::Vertex_descriptor, int>>);
+    static_assert(std::is_same_v<
+        typename Tr::Lambda0_pmap,
+        typename Mesh::template Property_map<typename Tr::Edge_descriptor, double>>);
+
+    // Default kernel: Simple_cartesian<double>.
+    using TrDefault = CGAL::Default_conformal_map_traits<Mesh>;
+    static_assert(std::is_same_v<typename TrDefault::Kernel,
+                                 CGAL::Simple_cartesian<double>>);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 2.  Traits property-map accessors are non-destructive
+//
+// Setting up via the trait helpers and via setup_euclidean_maps() must yield
+// the same property map (Surface_mesh deduplicates by name).
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALConformalTraits, AccessorsReuseExistingMaps)
+{
+    using K   = CGAL::Simple_cartesian<double>;
+    using Mesh = CGAL::Surface_mesh<K::Point_3>;
+    using Tr  = CGAL::Default_conformal_map_traits<Mesh, K>;
+
+    auto mesh = make_triangle();
+    auto maps = setup_euclidean_maps(mesh);
+
+    auto theta_via_traits   = Tr::theta_map(mesh);
+    auto idx_via_traits     = Tr::vertex_index_map(mesh);
+    auto lambda0_via_traits = Tr::lambda0_map(mesh);
+
+    // Surface_mesh property maps with the same key type are equality-comparable
+    // by name lookup — accessing through the traits class must return the
+    // same map that setup_euclidean_maps() created.
+    EXPECT_EQ(theta_via_traits,   maps.theta_v);
+    EXPECT_EQ(idx_via_traits,     maps.v_idx);
+    EXPECT_EQ(lambda0_via_traits, maps.lambda0);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 3.  End-to-end: discrete_conformal_map_euclidean() on a small open mesh
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALDiscreteConformalMap, SingleTriangleConverges)
+{
+    auto mesh = make_triangle();
+    auto result = CGAL::discrete_conformal_map_euclidean(mesh);
+
+    EXPECT_TRUE(result.converged)
+        << "Newton did not converge on a single triangle";
+    EXPECT_LT(result.gradient_norm, 1e-8);
+    EXPECT_GE(result.iterations, 0);
+    EXPECT_EQ(result.u_per_vertex.size(), num_vertices(mesh));
+
+    // With the default flat-disc target curvature and the first vertex pinned,
+    // the natural-theta equilibrium is at u = 0 — Newton should accept x0=0.
+    for (double u : result.u_per_vertex)
+        EXPECT_NEAR(u, 0.0, 1e-8);
+}
+
+TEST(CGALDiscreteConformalMap, QuadStripConverges)
+{
+    auto mesh = make_quad_strip();
+    auto result = CGAL::discrete_conformal_map_euclidean(mesh);
+
+    EXPECT_TRUE(result.converged);
+    EXPECT_LT(result.gradient_norm, 1e-8);
+    EXPECT_EQ(result.u_per_vertex.size(), num_vertices(mesh));
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 4.  Named-parameter overrides take effect
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALDiscreteConformalMap, MaxIterationsTakesEffect)
+{
+    auto mesh = make_triangle();
+
+    // max_iterations(0) forces Newton to give up immediately.
+    auto result = CGAL::discrete_conformal_map_euclidean(
+        mesh,
+        CGAL::parameters::max_iterations(0));
+
+    EXPECT_EQ(result.iterations, 0);
+    // Trivial natural-theta case: gradient is already zero at x=0,
+    // so even 0 iterations may report "converged" depending on the
+    // initial gradient check.  The point is just that the parameter
+    // was *read* — verified by EXPECT_EQ on iterations above.
+}
+
+TEST(CGALDiscreteConformalMap, GradientToleranceTakesEffect)
+{
+    auto mesh = make_quad_strip();
+
+    // Loose tolerance — must still converge, but possibly in fewer steps.
+    auto result_loose = CGAL::discrete_conformal_map_euclidean(
+        mesh,
+        CGAL::parameters::gradient_tolerance(1e-4));
+    EXPECT_TRUE(result_loose.converged);
+
+    // Strict tolerance — also must converge, gradient norm must be tighter.
+    auto result_strict = CGAL::discrete_conformal_map_euclidean(
+        mesh,
+        CGAL::parameters::gradient_tolerance(1e-12));
+    EXPECT_TRUE(result_strict.converged);
+    EXPECT_LT(result_strict.gradient_norm, 1e-10);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 5.  Wrapper agrees with the legacy newton_euclidean() at the same setup
+//
+// This is the cross-API consistency check: same mesh, same default settings
+// (first vertex pinned, x0=0) — the u-vector returned by the wrapper must
+// match what newton_euclidean produces directly.
+// ════════════════════════════════════════════════════════════════════════════
+
+// ════════════════════════════════════════════════════════════════════════════
+// 6.  Kernel deduction: the wrapper must NOT hard-code Simple_cartesian
+//
+// Regression guard: the wrapper deduces its kernel from the mesh point type
+// via `CGAL::Kernel_traits`.  If anyone re-introduces a hard-coded
+// `Simple_cartesian<double>` in the wrapper, the static_asserts here still
+// pass (the legacy ConformalMesh uses that kernel) — but Phase 9a or any
+// user with a different kernel-backed Surface_mesh would fail to compile.
+// This test pins the deduction *contract* explicitly.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CGALDiscreteConformalMap, KernelIsDeducedFromMeshPointType)
+{
+    using Mesh = ConformalMesh;
+    using P    = typename Mesh::Point;
+
+    using DeducedKernel = typename CGAL::Kernel_traits<P>::Kernel;
+    using DeducedTraits = CGAL::Default_conformal_map_traits<Mesh, DeducedKernel>;
+
+    static_assert(std::is_same_v<DeducedKernel, CGAL::Simple_cartesian<double>>,
+                  "ConformalMesh point type must deduce to Simple_cartesian<double>");
+    static_assert(std::is_same_v<typename DeducedTraits::FT, double>);
+    static_assert(std::is_same_v<typename DeducedTraits::Triangle_mesh, Mesh>);
+
+    // Run-time sanity: the wrapper accepts the deduced-kernel mesh end-to-end.
+    auto mesh = make_quad_strip();
+    auto result = CGAL::discrete_conformal_map_euclidean(mesh);
+    EXPECT_TRUE(result.converged);
+}
+
+TEST(CGALDiscreteConformalMap, WrapperMatchesLegacyAPI)
+{
+    auto mesh = make_quad_strip();
+
+    // ── New API: applies natural-theta automatically ───────────────────────
+    auto result_new = CGAL::discrete_conformal_map_euclidean(mesh);
+
+    // ── Legacy API on a fresh mesh — must replicate the *same* preparation
+    //    that the wrapper performs internally (pin first vertex, assign
+    //    DOFs, apply natural-theta).  Otherwise the comparison is unfair
+    //    (Newton would diverge without natural-theta on these meshes). ────
+    auto mesh_legacy = make_quad_strip();
+    auto maps = setup_euclidean_maps(mesh_legacy);
+    compute_euclidean_lambda0_from_mesh(mesh_legacy, maps);
+
+    // Pin first vertex (gauge), assign sequential DOFs to the rest.
+    auto vit = mesh_legacy.vertices().begin();
+    maps.v_idx[*vit++] = -1;
+    int idx = 0;
+    for (; vit != mesh_legacy.vertices().end(); ++vit)
+        maps.v_idx[*vit] = idx++;
+
+    // Natural-theta: shift Θ so that x = 0 is the natural equilibrium.
+    std::vector<double> x0(idx, 0.0);
+    auto G0 = euclidean_gradient(mesh_legacy, x0, maps);
+    for (auto v : mesh_legacy.vertices()) {
+        int j = maps.v_idx[v];
+        if (j >= 0) maps.theta_v[v] -= G0[static_cast<std::size_t>(j)];
+    }
+
+    auto nr = newton_euclidean(mesh_legacy, x0, maps, 1e-10, 200);
+
+    // ── Compare ────────────────────────────────────────────────────────────
+    EXPECT_EQ(result_new.converged, nr.converged);
+    EXPECT_NEAR(result_new.gradient_norm, nr.grad_inf_norm, 1e-12);
+
+    // Pinned vertex u is 0 in both; for the rest the values agree.
+    for (auto v : mesh_legacy.vertices()) {
+        int j = maps.v_idx[v];
+        double u_legacy = (j >= 0) ? nr.x[static_cast<std::size_t>(j)] : 0.0;
+        EXPECT_NEAR(result_new.u_per_vertex[v.idx()], u_legacy, 1e-10)
+            << "Wrapper diverges from legacy for vertex " << v.idx();
+    }
+}

code/tests/cgal/test_cp_euclidean_functional.cpp

@@ -0,0 +1,267 @@
+// test_cp_euclidean_functional.cpp
+//
+// Phase 9a.1 — CPEuclideanFunctional (BPS 2010) tests.
+//
+// Replicates de.varylab.discreteconformal.functional.CPEuclideanFunctionalTest
+// (88 lines) and adds boundary-edge coverage plus a closed-mesh case.
+//
+// Java test pattern (lines 50-87):
+//   1. Build dodecahedron via HalfEdgeUtils.addDodecahedron.
+//   2. Remove face 0 to produce an open mesh.
+//   3. theta_e = π/2 for every edge.       (orthogonal circle packing)
+//   4. phi_f   = 2π for every face.        (flat target)
+//   5. Random ρ ∈ [−0.5, 0.5] (seed 1).
+//   6. FunctionalTest.setXGradient(ρ) → FD-vs-analytic gradient check.
+//   7. FunctionalTest.setXHessian(ρ)  → FD-vs-analytic Hessian  check.
+//
+// C++ port uses the tetrahedron (4 faces) instead of the dodecahedron (12 faces)
+// because the analytic structure is identical and the smaller mesh keeps the
+// test fast and human-inspectable.  We exercise the boundary-edge code path
+// by additionally testing a tetrahedron with one face removed (3 faces, 3
+// boundary edges, 3 interior edges).
+
+#include "cp_euclidean_functional.hpp"
+#include "mesh_builder.hpp"
+#include "conformal_mesh.hpp"
+
+#include <Eigen/Eigenvalues>
+#include <gtest/gtest.h>
+#include <vector>
+#include <random>
+
+using namespace conformallab;
+
+// ════════════════════════════════════════════════════════════════════════════
+// 1.  Helper: explicit values for p(θ*, Δρ) at known inputs
+//
+// p(θ*, 0) = 0          (tanh 0 = 0)
+// p(π, Δρ) = π·sign(Δρ) (tan(π/2) = ∞, atan saturates to ±π/2)
+// p(0, Δρ) = 0          (tan(0) = 0)
+// p odd in Δρ (tanh is odd).
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, PFunctionKnownValues)
+{
+    using cp_detail::p_function;
+    constexpr double PI_ = 3.14159265358979323846;
+
+    // p(any, 0) = 0
+    EXPECT_NEAR(p_function(PI_ / 4,  0.0), 0.0, 1e-15);
+    EXPECT_NEAR(p_function(PI_ / 2,  0.0), 0.0, 1e-15);
+
+    // Odd in Δρ
+    const double thStar = PI_ / 3;
+    for (double dr : {0.1, 0.5, 1.0, 2.0}) {
+        EXPECT_NEAR(p_function(thStar, dr) + p_function(thStar, -dr), 0.0, 1e-12)
+            << "p(θ*, Δρ) should be odd in Δρ";
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 2.  Property-map setup defaults
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, SetupDefaults)
+{
+    auto mesh = make_tetrahedron();
+    auto m = setup_cp_euclidean_maps(mesh);
+
+    constexpr double PI_ = 3.14159265358979323846;
+    for (auto e : mesh.edges()) EXPECT_NEAR(m.theta_e[e], PI_ / 2, 1e-15);
+    for (auto f : mesh.faces()) EXPECT_NEAR(m.phi_f[f],   2.0 * PI_, 1e-15);
+    for (auto f : mesh.faces()) EXPECT_EQ(m.f_idx[f], -1) << "all faces start pinned";
+}
+
+TEST(CPEuclideanFunctional, AssignDofIndices_PinsOneFace)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    EXPECT_EQ(n, 3) << "tetrahedron has 4 faces; 1 pinned ⇒ 3 free DOFs";
+
+    int pinned_count = 0;
+    int max_idx = -1;
+    for (auto f : mesh.faces()) {
+        if (m.f_idx[f] == -1) ++pinned_count;
+        else max_idx = std::max(max_idx, m.f_idx[f]);
+    }
+    EXPECT_EQ(pinned_count, 1);
+    EXPECT_EQ(max_idx, 2);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 3.  Tangential limit (θ = 0): p = 0, energy collapses, gradient = φ_f
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, TangentialLimitGradientEqualsPhi)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    for (auto e : mesh.edges()) m.theta_e[e] = 0.0;   // tangential limit
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    // At θ = 0: θ* = π.  Interior edge contribution: −(p+θ*) where p = π·sign(Δρ).
+    // Boundary contribution: −2π.  At ρ = 0, Δρ = 0 so p = 0; each interior face
+    // contributes −π per incident interior halfedge; for a tetrahedron each face
+    // has 3 interior halfedges ⇒ −3π.  Net gradient: 2π − 3π = −π per free face.
+    std::vector<double> x(static_cast<std::size_t>(n), 0.0);
+    auto G = cp_euclidean_gradient(mesh, x, m);
+
+    constexpr double PI_ = 3.14159265358979323846;
+    for (double g : G) EXPECT_NEAR(g, -PI_, 1e-10);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 4.  FD gradient check on closed tetrahedron at random ρ
+//
+// Java parity: this is exactly the structure of CPEuclideanFunctionalTest.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, FDGradientCheck_ClosedTetrahedron_RandomRho)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    // Java: rnd.setSeed(1);  rho_i = rnd.nextDouble() − 0.5
+    std::mt19937 rng(1);
+    std::uniform_real_distribution<double> u(-0.5, 0.5);
+    std::vector<double> rho(static_cast<std::size_t>(n));
+    for (auto& r : rho) r = u(rng);
+
+    EXPECT_TRUE(gradient_check_cp_euclidean(mesh, rho, m))
+        << "FD vs analytic gradient mismatch on closed tetrahedron";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 5.  FD Hessian check on closed tetrahedron at random ρ
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, FDHessianCheck_ClosedTetrahedron_RandomRho)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    std::mt19937 rng(1);
+    std::uniform_real_distribution<double> u(-0.5, 0.5);
+    std::vector<double> rho(static_cast<std::size_t>(n));
+    for (auto& r : rho) r = u(rng);
+
+    EXPECT_TRUE(hessian_check_cp_euclidean(mesh, rho, m))
+        << "FD vs analytic Hessian mismatch on closed tetrahedron";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 6.  Boundary-edge coverage: open mesh (tetrahedron with one face removed)
+//
+// Java test does this via `hds.removeFace(hds.getFace(0))`.  In CGAL we get
+// an equivalent open mesh by skipping the construction of one face.
+// ════════════════════════════════════════════════════════════════════════════
+
+inline ConformalMesh make_open_tetrahedron()
+{
+    ConformalMesh mesh;
+    auto v0 = mesh.add_vertex(Point3( 1,  1,  1));
+    auto v1 = mesh.add_vertex(Point3( 1, -1, -1));
+    auto v2 = mesh.add_vertex(Point3(-1,  1, -1));
+    auto v3 = mesh.add_vertex(Point3(-1, -1,  1));
+    // Three faces (omit the one opposite v0):
+    mesh.add_face(v0, v2, v1);
+    mesh.add_face(v0, v1, v3);
+    mesh.add_face(v0, v3, v2);
+    return mesh;
+}
+
+TEST(CPEuclideanFunctional, FDGradientCheck_OpenTetrahedron_RandomRho)
+{
+    auto mesh = make_open_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    EXPECT_EQ(n, 2);   // 3 faces, 1 pinned ⇒ 2 free DOFs
+
+    std::mt19937 rng(1);
+    std::uniform_real_distribution<double> u(-0.5, 0.5);
+    std::vector<double> rho(static_cast<std::size_t>(n));
+    for (auto& r : rho) r = u(rng);
+
+    EXPECT_TRUE(gradient_check_cp_euclidean(mesh, rho, m))
+        << "FD vs analytic gradient mismatch on open tetrahedron";
+}
+
+TEST(CPEuclideanFunctional, FDHessianCheck_OpenTetrahedron_RandomRho)
+{
+    auto mesh = make_open_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    std::mt19937 rng(1);
+    std::uniform_real_distribution<double> u(-0.5, 0.5);
+    std::vector<double> rho(static_cast<std::size_t>(n));
+    for (auto& r : rho) r = u(rng);
+
+    EXPECT_TRUE(hessian_check_cp_euclidean(mesh, rho, m))
+        << "FD vs analytic Hessian mismatch on open tetrahedron";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 7.  Hessian is symmetric positive-semidefinite (BPS-2010 §6 convexity)
+//
+// The energy is convex in ρ on its domain of validity.  Hence H is PSD with
+// a 1-dim null space (constant shift of all ρ, removed by gauge pin).
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, HessianIsPSD)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    std::vector<double> rho(static_cast<std::size_t>(n), 0.1);
+    auto H = cp_euclidean_hessian(mesh, rho, m);
+
+    // Symmetry
+    Eigen::MatrixXd Hd(H);
+    EXPECT_NEAR((Hd - Hd.transpose()).cwiseAbs().maxCoeff(), 0.0, 1e-15);
+
+    // Smallest eigenvalue ≥ 0 (PSD)
+    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es(Hd);
+    EXPECT_GE(es.eigenvalues().minCoeff(), -1e-12)
+        << "Hessian must be PSD (BPS-2010 §6)";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 8.  At equilibrium (Newton-converged ρ*), the gradient is zero by construction
+//
+// We do not run a full Newton solver here; we set up the "natural-theta" trick:
+// adjust φ_f so that ρ = 0 is the equilibrium.  This is the analog of the
+// natural-theta convention already used in euclidean_functional tests
+// (see test_euclidean_functional.cpp lines 159-189).
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(CPEuclideanFunctional, NaturalPhiMakesZeroTheEquilibrium)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    std::vector<double> rho(static_cast<std::size_t>(n), 0.0);
+
+    // Step 1: gradient at ρ = 0 with default φ.
+    auto G0 = cp_euclidean_gradient(mesh, rho, m);
+
+    // Step 2: adjust φ_f so the new gradient at ρ = 0 is zero.
+    //   ∂E/∂ρ_f = φ_f − (sum of edge contributions)
+    //   To zero G_f: subtract G_f from φ_f.
+    for (auto f : mesh.faces()) {
+        int i = m.f_idx[f];
+        if (i < 0) continue;
+        m.phi_f[f] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    // Step 3: gradient at ρ = 0 should now be ~zero.
+    auto G_eq = cp_euclidean_gradient(mesh, rho, m);
+    for (double g : G_eq) EXPECT_NEAR(g, 0.0, 1e-13);
+}

code/tests/cgal/test_euclidean_functional.cpp

@@ -6,7 +6,7 @@
 //
 // Test map (Java → C++)
 // ──────────────────────
-//   testHessian (Ignored)       → GradientCheck_Hessian           (SKIPPED)
+//   testHessian (Ignored)       → GradientCheck_Hessian           (ported)
 //   testGradient…Triangle       → GradientCheck_TriangleVertex     (ported)
 //   testGradient…QuadStrip      → GradientCheck_QuadStripVertex    (ported)
 //   testGradient…Tetrahedron    → GradientCheck_TetrahedronVertex  (ported)
@@ -22,6 +22,7 @@
 #include "mesh_builder.hpp"
 #include "euclidean_geometry.hpp"
 #include "euclidean_functional.hpp"
+#include "euclidean_hessian.hpp"
 #include <gtest/gtest.h>
 #include <cmath>
 #include <vector>
@@ -29,12 +30,31 @@
 using namespace conformallab;
 
 // ════════════════════════════════════════════════════════════════════════════
-// @Ignore in Java: no Hessian implemented yet
+// Cross-module Hessian check: euclidean_gradient() ↔ euclidean_hessian()
+//
+// Java @Ignore reason: "no Hessian implemented yet" — the Java functional
+// test was written before the Hessian existed.  In C++ the analytic
+// cotangent-Laplace Hessian (euclidean_hessian.hpp, Phase 3f) is complete.
+//
+// This test verifies cross-module consistency:
+//   H[i,j] ≈ (G_i(x+ε·eⱼ) − G_i(x−ε·eⱼ)) / (2ε)
+// using the gradient from euclidean_functional.hpp and the Hessian from
+// euclidean_hessian.hpp.  A bug in DOF-index mapping or sign convention
+// that affects both modules independently would only be caught here.
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(EuclideanFunctional, GradientCheck_Hessian)
 {
-    GTEST_SKIP() << "@Ignore in Java – Hessian not yet implemented";
+    auto mesh = make_triangle();
+    auto maps = setup_euclidean_maps(mesh);
+    compute_euclidean_lambda0_from_mesh(mesh, maps);
+    int n = assign_euclidean_vertex_dof_indices(mesh, maps);
+
+    std::vector<double> x(static_cast<std::size_t>(n), -0.1);
+
+    // hessian_check_euclidean: H[i,j] ≈ FD(G)[i,j] using euclidean_gradient()
+    EXPECT_TRUE(hessian_check_euclidean(mesh, x, maps))
+        << "Cross-module: euclidean_gradient() and euclidean_hessian() are inconsistent";
 }
 
 // ════════════════════════════════════════════════════════════════════════════

code/tests/cgal/test_geometry_utils.cpp

@@ -1,64 +1,64 @@
 // test_geometry_utils.cpp
 //
-// Portierung der Java ConformalLab Geometrie-Utility-Tests.
+// Port of the Java ConformalLab geometry utility tests.
 //
-// Java-Quelle                           Java-Testmethode                         Status
+// Java source                           Java test method                         Status
 // ─────────────────────────────────────────────────────────────────────────────────────
-// CuttinUtilityTest.java                testIsInConvexTextureFace_False          PORTIERT
-// CuttinUtilityTest.java                testIsInConvexTextureFace_True           PORTIERT
-// UnwrapUtilityTest.java                testGetAngleReturnsPI                    PORTIERT
-// ConvergenceUtilityTests.java          testGetTextureCircumRadius               PORTIERT
-// ConvergenceUtilityTests.java          testGetTextureTriangleArea               PORTIERT
-// ConvergenceUtilityTests.java          testScaleInvariantCircumCircleRadius     PORTIERT
-// HomologyTest.java                     testHomology                             PORTIERT
-// EuclideanLayoutTest.java              testDoLayout                             PORTIERT
-// EuclideanCyclicConvergenceTest.java   testEuclideanConvergence                 PORTIERT
-// SphericalConvergenceTest.java         testSphericalConvergence                 PORTIERT
+// CuttinUtilityTest.java                testIsInConvexTextureFace_False          PORTED
+// CuttinUtilityTest.java                testIsInConvexTextureFace_True           PORTED
+// UnwrapUtilityTest.java                testGetAngleReturnsPI                    PORTED
+// ConvergenceUtilityTests.java          testGetTextureCircumRadius               PORTED
+// ConvergenceUtilityTests.java          testGetTextureTriangleArea               PORTED
+// ConvergenceUtilityTests.java          testScaleInvariantCircumCircleRadius     PORTED
+// HomologyTest.java                     testHomology                             PORTED
+// EuclideanLayoutTest.java              testDoLayout                             PORTED
+// EuclideanCyclicConvergenceTest.java   testEuclideanConvergence                 PORTED
+// SphericalConvergenceTest.java         testSphericalConvergence                 PORTED
 //
-// ─── Geometrische Grundlage ──────────────────────────────────────────────────────────
+// ─── Geometric background ────────────────────────────────────────────────────────────
 //
-//  Tests 1–2  Punkt-in-konvexem-Dreieck (2D UV-Raum, baryzentrische Vorzeichen-Methode)
+//  Tests 1–2  Point-in-convex-triangle (2D UV space, barycentric sign method)
 //             Java: CuttingUtility.isInConvexTextureFace(pp, face, adapters)
-//             Hinweis: Java-Test 2 hat ein 5-elementiges T-Array mit w=0 (Punkt im
-//             Unendlichen), was ein Tippfehler im Original ist. Hier werden
-//             äquivalente, wohlgeformte Koordinaten verwendet.
+//             Note: Java test 2 has a 5-element T-array with w=0 (point at
+//             infinity), which is a typo in the original. Equivalent, well-formed
+//             coordinates are used here instead.
 //
-//  Test 3     Eckenwinkel für kollineare Vertices über den Kosinussatz.
-//             Java: UnwrapUtility.getAngle(edge, adapters) — gibt den Winkel am
-//             Zielknoten zurück. Für v0=(-1,0,0), v1=(0,0,0), v2=(1,0,0) ist
-//             der Winkel bei v1 genau π (Dreiecksungleichung entartet).
+//  Test 3     Corner angle for collinear vertices via the law of cosines.
+//             Java: UnwrapUtility.getAngle(edge, adapters) — returns the angle at
+//             the target vertex. For v0=(-1,0,0), v1=(0,0,0), v2=(1,0,0) the
+//             angle at v1 is exactly π (degenerate triangle inequality).
 //
-//  Tests 4–5  2D Umkreisradius und Dreiecksfläche.
+//  Tests 4–5  2D circumradius and triangle area.
 //             Java: ConvergenceUtility.getTextureCircumCircleRadius(face)
 //                   ConvergenceUtility.getTextureTriangleArea(face)
-//             Formeln: Area = |det([B-A, C-A])| / 2
+//             Formulas: Area = |det([B-A, C-A])| / 2
 //                       R    = (a·b·c) / (4·Area)
 //
-//  Test 6     Skaleninvarianter Umkreisradius über ein Mesh.
+//  Test 6     Scale-invariant circumradius over a mesh.
 //             Java: ConvergenceUtility.getMaxMeanSumScaleInvariantCircumRadius(hds)
-//             Gibt [max, mean, sum] von  R_f / sqrt(total_texture_area)  zurück.
-//             Invariant unter uniformer Skalierung der Texturkoordinaten (Test mit
-//             homogenem Gewicht w: Position = (T[0]/w, T[1]/w)).
+//             Returns [max, mean, sum] of  R_f / sqrt(total_texture_area).
+//             Invariant under uniform scaling of texture coordinates (tested with
+//             homogeneous weight w: position = (T[0]/w, T[1]/w)).
 //
-//  Test 7     Genus-2 Homologie-Generatoren.
+//  Test 7     Genus-2 homology generators.
 //             Java: HomologyTest.testHomology (brezel2.obj)
-//             Erwartet: getGeneratorPaths(root).size() == 4  (2g = 4 für g = 2)
+//             Expected: getGeneratorPaths(root).size() == 4  (2g = 4 for g = 2)
 //             C++: compute_cut_graph(mesh).cut_edge_indices.size() == 4
 //             Mesh: code/data/obj/brezel2.obj (V=2622, F=5248, χ=−2, g=2)
-//             Pfad zur Compile-Zeit via CONFORMALLAB_DATA_DIR (CMakeLists.txt).
+//             Path set at compile time via CONFORMALLAB_DATA_DIR (CMakeLists.txt).
 //
-//  Tests 8–9  Layout-Kanten-Längenerhalt (tetraflat.obj).
+//  Tests 8–9  Layout edge-length preservation (tetraflat.obj).
 //             Java: EuclideanLayoutTest.testDoLayout
-//             Nach Layout mit u=0 müssen UV-Kantenlängen == 3D-Kantenlängen (±1e-10).
+//             After layout with u=0, UV edge lengths must equal 3D edge lengths (±1e-10).
 //
-//  Test 10    Euklidischer Newton auf cathead.obj — Konvergenz + Winkeldefekt.
-//             Java: EuclideanLayoutTest.testLayout02 (130-Werte-Array für cathead.heml)
-//             C++: Newton ab u=0, prüft Konvergenz + Σα_v ≈ 2π für alle inneren Knoten.
+//  Test 10    Euclidean Newton on cathead.obj — convergence + angle deficit.
+//             Java: EuclideanLayoutTest.testLayout02 (130-value array for cathead.heml)
+//             C++: Newton from u=0, checks convergence + Σα_v ≈ 2π for all interior nodes.
 //
-//  Test 11    Sphärischer Newton auf Oktaeder — Konvergenz + Winkeldefekt.
-//             Java: SphericalConvergenceTest.testSphericalConvergence (Oktaeder, zufällig
-//             störe Radien, seed=1). C++: konstruierter regulärer Oktaeder, prüft
-//             Konvergenz und dass Σα_v ≈ 2π (Target für Sphäre nach prepareInvariantData).
+//  Test 11    Spherical Newton on octahedron — convergence + angle deficit.
+//             Java: SphericalConvergenceTest.testSphericalConvergence (octahedron, randomly
+//             perturbed radii, seed=1). C++: constructed regular octahedron, checks
+//             convergence and that Σα_v ≈ 2π (target for sphere after prepareInvariantData).
 //
 // ─────────────────────────────────────────────────────────────────────────────────────
 
@@ -81,12 +81,12 @@
 using namespace conformallab;
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Lokale Geometrie-Hilfsfunktionen
-// (portiert aus Java CuttingUtility / ConvergenceUtility)
+// Local geometry helper functions
+// (ported from Java CuttingUtility / ConvergenceUtility)
 // ─────────────────────────────────────────────────────────────────────────────
 
-/// Punkt-in-Dreieck Test (2D, baryzentrische Vorzeichenmethode).
-/// Gibt true zurück wenn p strikt innerhalb oder auf dem Rand von v0-v1-v2 liegt.
+/// Point-in-triangle test (2D, barycentric sign method).
+/// Returns true if p lies strictly inside or on the boundary of v0-v1-v2.
 /// Java: CuttingUtility.isInConvexTextureFace
 static bool point_in_triangle_2d(
     Eigen::Vector2d p,
@@ -103,7 +103,7 @@ static bool point_in_triangle_2d(
     return !(has_neg && has_pos);
 }
 
-/// 2D Dreiecksfläche (halbes Kreuzprodukt).
+/// 2D triangle area (half cross product).
 /// Java: ConvergenceUtility.getTextureTriangleArea
 static double triangle_area_2d(
     Eigen::Vector2d A, Eigen::Vector2d B, Eigen::Vector2d C)
@@ -112,7 +112,7 @@ static double triangle_area_2d(
                   - (B - A).y() * (C - A).x()) * 0.5;
 }
 
-/// 2D Umkreisradius: R = (a·b·c) / (4·Area).
+/// 2D circumradius: R = (a·b·c) / (4·Area).
 /// Java: ConvergenceUtility.getTextureCircumCircleRadius
 static double circumradius_2d(
     Eigen::Vector2d A, Eigen::Vector2d B, Eigen::Vector2d C)
@@ -125,17 +125,17 @@ static double circumradius_2d(
     return (a * b * c) / (4.0 * area);
 }
 
-/// Skaleninvarianter Umkreisradius für ein Mesh:
+/// Scale-invariant circumradius for a mesh:
 ///   scale_R_f = R_f / sqrt(total_area)
-/// Gibt {max, mean, sum} über alle Flächen zurück.
+/// Returns {max, mean, sum} over all faces.
 /// Java: ConvergenceUtility.getMaxMeanSumScaleInvariantCircumRadius
 ///
-/// Homogene Koordinaten: Position = (x/w, y/w).
+/// Homogeneous coordinates: position = (x/w, y/w).
 static std::array<double, 3> scale_invariant_circumradius_stats(
     const std::vector<Eigen::Vector2d>& verts,
     const std::vector<std::array<int, 3>>& faces)
 {
-    // Gesamtfläche
+    // Total area
     double total_area = 0.0;
     for (auto& f : faces)
         total_area += triangle_area_2d(verts[f[0]], verts[f[1]], verts[f[2]]);
@@ -154,70 +154,70 @@ static std::array<double, 3> scale_invariant_circumradius_stats(
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Tests 1–2 — CuttingUtility: Punkt-in-konvexem-Dreieck (2D UV-Raum)
+// Tests 1–2 — CuttingUtility: point-in-convex-triangle (2D UV space)
 //             Java: CuttinUtilityTest.testIsInConvexTextureFace_False / _True
 // ════════════════════════════════════════════════════════════════════════════
 
-// Test 1: Punkt liegt weit außerhalb — exakte Java-Koordinaten
+// Test 1: point lies far outside — exact Java coordinates
 TEST(CuttingUtility, IsInConvexTextureFace_False)
 {
-    // Winziges Dreieck um (0.7488, 0.0629) — Java-Testkoordinaten (T[3]=1, w=1)
+    // Tiny triangle around (0.7488, 0.0629) — Java test coordinates (T[3]=1, w=1)
     Eigen::Vector2d v0(0.7488102998904661,  0.06293998610761144);
     Eigen::Vector2d v1(0.7487811940754379,  0.06289451051246124);
     Eigen::Vector2d v2(0.7487254625255592,  0.06291429499873116);
-    // Testpunkt weit entfernt bei (0.447, 0.000228)
+    // Test point far away at (0.447, 0.000228)
     Eigen::Vector2d pp(0.44661534423161037, 2.2808373704822393e-4);
 
     EXPECT_FALSE(point_in_triangle_2d(pp, v0, v1, v2));
 }
 
-// Test 2: Punkt liegt innerhalb
-// Hinweis: Das originale Java-Array p2 hat 5 Elemente mit w=0 (Tippfehler im
-// Java-Original). Hier werden äquivalente, wohlgeformte Koordinaten verwendet,
-// die dasselbe geometrische Szenario abbilden.
+// Test 2: point lies inside
+// Note: the original Java array p2 has 5 elements with w=0 (typo in the
+// Java original). Equivalent, well-formed coordinates are used here
+// that represent the same geometric scenario.
 TEST(CuttingUtility, IsInConvexTextureFace_True)
 {
-    // Dreieck: (0,0) — (1e-8, 0) — (0, 1e-8)
+    // Triangle: (0,0) — (1e-8, 0) — (0, 1e-8)
     Eigen::Vector2d v0(0.0,   0.0);
     Eigen::Vector2d v1(1e-8,  0.0);
     Eigen::Vector2d v2(0.0,   1e-8);
-    // Schwerpunkt des Dreiecks — liegt immer innen
+    // Centroid of the triangle — always lies inside
     Eigen::Vector2d pp(1e-8 / 3.0, 1e-8 / 3.0);
 
     EXPECT_TRUE(point_in_triangle_2d(pp, v0, v1, v2));
 }
 
-// Zusätzlich: einfaches Einheitsdreieck für Klarheit
+// Additional: simple unit triangle for clarity
 TEST(CuttingUtility, IsInConvexTextureFace_UnitTriangle_InAndOut)
 {
     Eigen::Vector2d v0(0.0, 0.0), v1(1.0, 0.0), v2(0.0, 1.0);
     EXPECT_TRUE( point_in_triangle_2d(Eigen::Vector2d(0.25, 0.25), v0, v1, v2));
     EXPECT_FALSE(point_in_triangle_2d(Eigen::Vector2d(2.0,  2.0),  v0, v1, v2));
-    EXPECT_FALSE(point_in_triangle_2d(Eigen::Vector2d(0.6,  0.6),  v0, v1, v2));  // jenseits Hypotenuse
+    EXPECT_FALSE(point_in_triangle_2d(Eigen::Vector2d(0.6,  0.6),  v0, v1, v2));  // beyond hypotenuse
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 3 — UnwrapUtility: Eckenwinkel = π für kollineare Vertices
+// Test 3 — UnwrapUtility: corner angle = π for collinear vertices
 //          Java: UnwrapUtilityTest.testGetAngleReturnsPI
 // ════════════════════════════════════════════════════════════════════════════
 
-// Java: v0=(-1,0,0), v1=(0,0,0), v2=(1,0,0) kollinear.
-// Kante e von v2 nach v1. getAngle(e) = Winkel bei v1 = π.
+// Java: v0=(-1,0,0), v1=(0,0,0), v2=(1,0,0) collinear.
+// Edge e from v2 to v1. getAngle(e) = angle at v1 = π.
 //
-// C++: Kosinussatz mit Kantenlängen a=|v0-v1|=1, b=|v1-v2|=1, c=|v0-v2|=2.
+// C++: law of cosines with edge lengths a=|v0-v1|=1, b=|v1-v2|=1, c=|v0-v2|=2.
 //   cos(γ_v1) = (a² + b² − c²) / (2ab) = (1 + 1 − 4) / 2 = −1  →  γ = π
 TEST(UnwrapUtility, GetAngle_CollinearVertices_ReturnsPI)
 {
     const double a = 1.0;   // |v0 − v1|
     const double b = 1.0;   // |v1 − v2|
-    const double c = 2.0;   // |v0 − v2|   (= a + b, entartet)
+    const double c = 2.0;   // |v0 − v2|   (= a + b, degenerate)
     double cos_angle = (a*a + b*b - c*c) / (2.0 * a * b);
-    cos_angle = std::max(-1.0, std::min(1.0, cos_angle));   // numerisches Clamp
+    cos_angle = std::max(-1.0, std::min(1.0, cos_angle));   // numeric clamp
     double angle = std::acos(cos_angle);
     EXPECT_NEAR(M_PI, angle, 1e-15);
 }
 
-// Gegenkontrolle: gleichseitiges Dreieck → Winkel = π/3
+// Counter-check: equilateral triangle → angle = π/3
 TEST(UnwrapUtility, GetAngle_EquilateralTriangle_ReturnsPiOver3)
 {
     const double s = 1.0;
@@ -227,57 +227,57 @@ TEST(UnwrapUtility, GetAngle_EquilateralTriangle_ReturnsPiOver3)
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 4 — ConvergenceUtility: 2D Umkreisradius
+// Test 4 — ConvergenceUtility: 2D circumradius
 //          Java: ConvergenceUtilityTests.testGetTextureCircumRadius
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(ConvergenceUtility, TextureCircumRadius_RightTriangle)
 {
-    // A=(0,0), B=(1,0), C=(0,1): rechtwinkliges gleichschenkliges Dreieck
-    // Seiten: 1, 1, √2.  R = √2 / (4 · 0.5) = √2/2
+    // A=(0,0), B=(1,0), C=(0,1): right isosceles triangle
+    // Sides: 1, 1, √2.  R = √2 / (4 · 0.5) = √2/2
     Eigen::Vector2d A(0.0, 0.0), B(1.0, 0.0), C(0.0, 1.0);
     EXPECT_NEAR(std::sqrt(2.0) / 2.0, circumradius_2d(A, B, C), 1e-10);
 }
 
 TEST(ConvergenceUtility, TextureCircumRadius_SmallerTriangle)
 {
-    // A=(0,0), B=(0.5,0.5), C=(0,1): Java-Variante mit B.T={0.5,0.5,0,1}
-    // Seiten: √0.5, √0.5, 1.  Area = 0.25.  R = (√0.5·√0.5·1)/(4·0.25) = 0.5
+    // A=(0,0), B=(0.5,0.5), C=(0,1): Java variant with B.T={0.5,0.5,0,1}
+    // Sides: √0.5, √0.5, 1.  Area = 0.25.  R = (√0.5·√0.5·1)/(4·0.25) = 0.5
     Eigen::Vector2d A(0.0, 0.0), B(0.5, 0.5), C(0.0, 1.0);
     EXPECT_NEAR(0.5, circumradius_2d(A, B, C), 1e-10);
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 5 — ConvergenceUtility: 2D Dreiecksfläche
+// Test 5 — ConvergenceUtility: 2D triangle area
 //          Java: ConvergenceUtilityTests.testGetTextureTriangleArea
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(ConvergenceUtility, TextureTriangleArea_RightTriangle)
 {
-    // A=(0,0), B=(1,0), C=(0,1) → Fläche = 0.5
+    // A=(0,0), B=(1,0), C=(0,1) → area = 0.5
     Eigen::Vector2d A(0.0, 0.0), B(1.0, 0.0), C(0.0, 1.0);
     EXPECT_NEAR(0.5, triangle_area_2d(A, B, C), 1e-10);
 }
 
 TEST(ConvergenceUtility, TextureTriangleArea_SmallerTriangle)
 {
-    // A=(0,0), B=(0.5,0.5), C=(0,1) → Fläche = 0.25
+    // A=(0,0), B=(0.5,0.5), C=(0,1) → area = 0.25
     Eigen::Vector2d A(0.0, 0.0), B(0.5, 0.5), C(0.0, 1.0);
     EXPECT_NEAR(0.25, triangle_area_2d(A, B, C), 1e-10);
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 6 — ConvergenceUtility: Skaleninvarianter Umkreisradius
+// Test 6 — ConvergenceUtility: scale-invariant circumradius
 //          Java: ConvergenceUtilityTests.testScaleInvariantCircumCircleRadius
 //
-// Mesh: 4 Vertices (v1..v4), 2 Flächen (f1: v1-v2-v3, f2: v1-v3-v4).
-// Skaleninvariante Größe: R_f / sqrt(total_area) — invariant unter
-// uniformer Skalierung (homogeneous weight w: pos = (x/w, y/w)).
+// Mesh: 4 vertices (v1..v4), 2 faces (f1: v1-v2-v3, f2: v1-v3-v4).
+// Scale-invariant quantity: R_f / sqrt(total_area) — invariant under
+// uniform scaling (homogeneous weight w: pos = (x/w, y/w)).
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(ConvergenceUtility, ScaleInvariantCircumRadius_BaseScale)
 {
-    // Positionen bei w=1 (T[3]=1): v1=(0,0), v2=(1,0), v3=(0,1), v4=(-1,0)
+    // Positions at w=1 (T[3]=1): v1=(0,0), v2=(1,0), v3=(0,1), v4=(-1,0)
     std::vector<Eigen::Vector2d> verts = {
         {0.0,  0.0},   // v1
         {1.0,  0.0},   // v2
@@ -287,13 +287,13 @@ TEST(ConvergenceUtility, ScaleInvariantCircumRadius_BaseScale)
     // f1: v1-v2-v3,  f2: v1-v3-v4
     std::vector<std::array<int, 3>> faces = { {0, 1, 2}, {0, 2, 3} };
 
-    // Einzelflächen-Prüfung (Java testGetTextureTriangleArea-Anforderung)
+    // Per-face check (Java testGetTextureTriangleArea requirement)
     EXPECT_NEAR(0.5, triangle_area_2d(verts[0], verts[1], verts[2]), 1e-10);
     EXPECT_NEAR(0.5, triangle_area_2d(verts[0], verts[2], verts[3]), 1e-10);
 
     auto [max_r, mean_r, sum_r] = scale_invariant_circumradius_stats(verts, faces);
 
-    // Erwartet: sin(π/4) = √2/2 für max und mean (beide Dreiecke identisch)
+    // Expected: sin(π/4) = √2/2 for max and mean (both triangles identical)
     EXPECT_NEAR(std::sin(M_PI / 4.0), max_r,  1e-10);
     EXPECT_NEAR(std::sin(M_PI / 4.0), mean_r, 1e-10);
     EXPECT_NEAR(2.0 * std::sin(M_PI / 4.0), sum_r, 1e-10);
@@ -301,7 +301,7 @@ TEST(ConvergenceUtility, ScaleInvariantCircumRadius_BaseScale)
 
 TEST(ConvergenceUtility, ScaleInvariantCircumRadius_HalvedByW2_SameResult)
 {
-    // Skalierung durch w=2: alle Positionen halbiert (homogene Koordinaten)
+    // Scaling by w=2: all positions halved (homogeneous coordinates)
     // pos_scaled = (T[0]/2, T[1]/2)
     std::vector<Eigen::Vector2d> verts = {
         {0.0,   0.0},   // v1/2
@@ -311,35 +311,35 @@ TEST(ConvergenceUtility, ScaleInvariantCircumRadius_HalvedByW2_SameResult)
     };
     std::vector<std::array<int, 3>> faces = { {0, 1, 2}, {0, 2, 3} };
 
-    // Flächen sind ein Viertel der ursprünglichen (Längen halbiert → Area / 4)
+    // Areas are one quarter of the original (lengths halved → Area / 4)
     EXPECT_NEAR(0.125, triangle_area_2d(verts[0], verts[1], verts[2]), 1e-10);
     EXPECT_NEAR(0.125, triangle_area_2d(verts[0], verts[2], verts[3]), 1e-10);
 
     auto [max_r, mean_r, sum_r] = scale_invariant_circumradius_stats(verts, faces);
 
-    // Skaleninvariante Größe muss identisch zu w=1 sein
+    // Scale-invariant quantity must be identical to the w=1 case
     EXPECT_NEAR(std::sin(M_PI / 4.0), max_r,  1e-10);
     EXPECT_NEAR(std::sin(M_PI / 4.0), mean_r, 1e-10);
     EXPECT_NEAR(2.0 * std::sin(M_PI / 4.0), sum_r, 1e-10);
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 7 — HomologyTest: Genus-2 Homologie-Generatoren
+// Test 7 — HomologyTest: genus-2 homology generators
 //          Java: HomologyTest.testHomology
 //
-// Java-Test:
-//   CoHDS hds = TestUtility.readOBJ("brezel2.obj");  // Genus-2-Brezel-Fläche
+// Java test:
+//   CoHDS hds = TestUtility.readOBJ("brezel2.obj");  // genus-2 pretzel surface
 //   List<Set<CoEdge>> paths = getGeneratorPaths(hds.getVertex(0), weightAdapter);
-//   Assert.assertEquals(4, paths.size());             // 2g = 4 für g = 2
+//   Assert.assertEquals(4, paths.size());             // 2g = 4 for g = 2
 //
-// C++-Äquivalent:
+// C++ equivalent:
 //   ConformalMesh mesh = load_mesh("code/data/obj/brezel2.obj");
 //   CutGraph cg = compute_cut_graph(mesh);
 //   EXPECT_EQ(4u, cg.cut_edge_indices.size());        // 2g = 4
 //   EXPECT_EQ(2,  cg.genus);
 //
 // Mesh: V=2622, F=5248, E=7872, χ=−2, genus=2.
-// Pfad via CONFORMALLAB_DATA_DIR (CMakeLists.txt: ${CMAKE_SOURCE_DIR}/data).
+// Path via CONFORMALLAB_DATA_DIR (CMakeLists.txt: ${CMAKE_SOURCE_DIR}/data).
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(HomologyGenerators, Genus2_FourCutEdges)
@@ -359,17 +359,17 @@ TEST(HomologyGenerators, Genus2_FourCutEdges)
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Tests 8–9 — EuclideanLayoutTest: Kantenlängenerhalt auf tetraflat.obj
+// Tests 8–9 — EuclideanLayoutTest: edge-length preservation on tetraflat.obj
 //             Java: EuclideanLayoutTest.testDoLayout
 //
-// Java-Test:
-//   Vector u = new SparseVector(n);   // u = 0 (kein konformer Faktor)
+// Java test:
+//   Vector u = new SparseVector(n);   // u = 0 (no conformal factor)
 //   EuclideanLayout.doLayout(hds, fun, u);
 //   for (CoEdge e : hds.getEdges())
 //       assertEquals(Pn.distanceBetween(s.P, t.P), Pn.distanceBetween(s.T, t.T), 1E-11);
 //
-// Bedeutung: Mit u=0 ist der konforme Faktor 0, also ℓ̃ = ℓ (keine Verformung).
-//            Das Layout muss die ursprünglichen 3D-Kantenlängen exakt reproduzieren.
+// Meaning: with u=0 the conformal factor is 0, so ℓ̃ = ℓ (no deformation).
+//          The layout must reproduce the original 3D edge lengths exactly.
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(EuclideanLayout, DoLayout_TetraFlat_EdgeLengthsPreserved)
@@ -414,18 +414,18 @@ TEST(EuclideanLayout, DoLayout_TetraFlat_EdgeLengthsPreserved)
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 10 — EuclideanCyclicConvergenceTest: Newton auf cathead.obj
-//           Java: EuclideanLayoutTest.testLayout02 (130-Werte-Regression auf cathead.heml)
+// Test 10 — EuclideanCyclicConvergenceTest: Newton on cathead.obj
+//           Java: EuclideanLayoutTest.testLayout02 (130-value regression on cathead.heml)
 //                 EuclideanCyclicConvergenceTest.testEuclideanConvergence
 //
-// Java-Test:
+// Java test:
 //   EuclideanLayout.doLayout(hdsCat, fun, uCat);
 //   for (CoVertex v : interior vertices)
 //       assertEquals(2*PI, calculateAngleSum(v), 1E-6);
 //   for (CoEdge e : positiveEdges)
 //       assertEquals(fun.getNewLength(e, u), tLength, 1E-6);
 //
-// C++-Äquivalent: Newton converges on cathead.obj; interior angle sums ≈ 2π.
+// C++ equivalent: Newton converges on cathead.obj; interior angle sums ≈ 2π.
 // The 130-value u-vector from the Java test is cathead-topology-specific and
 // depends on vertex ordering in the Java CoHDS — not portable directly.
 // Instead we verify the same mathematical invariant: convergence + angle sums.
@@ -468,18 +468,18 @@ TEST(EuclideanLayout, CatHead_NewtonConverges_AngleSumsTwoPi)
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Test 11 — SphericalConvergenceTest: Newton auf Oktaeder
+// Test 11 — SphericalConvergenceTest: Newton on octahedron
 //           Java: SphericalConvergenceTest.testSphericalConvergence
 //
-// Java-Test:
+// Java test:
 //   FunctionalTest.createOctahedron(hds, aSet);
 //   // randomly perturb vertex radii (seed=1)
 //   prepareInvariantDataHyperbolicAndSpherical(functional, hds, aSet, u);
 //   optimizer.minimize(u, opt);
 //   for (CoVertex v) assertEquals(2*PI, sum of angles at v, 1E-8);
 //
-// C++: regulärer Oktaeder (alle Knoten auf S², keine Störung), sphärischer Newton,
-// prüft Konvergenz + Restgradienten (≡ Winkeldefekt = 0 nach Konvergenz).
+// C++: regular octahedron (all vertices on S², no perturbation), spherical Newton,
+// checks convergence + residual gradients (≡ angle deficit = 0 after convergence).
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(SphericalLayout, SphericalTetrahedron_NewtonConverges_AngleSumsTwoPi)

code/tests/cgal/test_hyper_ideal_hessian.cpp

@@ -0,0 +1,337 @@
+// test_hyper_ideal_hessian.cpp
+//
+// Phase 9b — Hyper-ideal Hessian: block-FD vs full-FD cross-validation.
+//
+// The block-FD Hessian (Phase 9b) exploits the per-face locality of the
+// hyper-ideal functional to compute the Hessian as a sum of 6×6 per-face
+// blocks.  This file verifies:
+//
+//   1. Block-FD reproduces the full-FD Hessian to machine precision
+//      on tetrahedron (closed) and a 3-face open mesh.
+//   2. The result is symmetric and positive-semi-definite (Springborn
+//      2020 strict-convexity result).
+//   3. The kernel `face_angles_from_local_dofs` matches the existing
+//      `compute_face_angles` at the same DOFs — sanity that the pure
+//      refactor is non-regressing.
+//   4. Both Hessians agree with a from-scratch FD-of-energy reference
+//      at the same x.  (This is the highest-confidence cross-check.)
+
+#include "hyper_ideal_functional.hpp"
+#include "hyper_ideal_hessian.hpp"
+#include "mesh_builder.hpp"
+
+#include <Eigen/Eigenvalues>
+#include <gtest/gtest.h>
+#include <chrono>
+#include <iostream>
+#include <vector>
+
+using namespace conformallab;
+
+namespace {
+
+// Open 3-face mesh (tetrahedron minus one face) — exercises boundary edges.
+inline ConformalMesh make_open_3face_mesh()
+{
+    ConformalMesh mesh;
+    auto v0 = mesh.add_vertex(Point3( 1,  1,  1));
+    auto v1 = mesh.add_vertex(Point3( 1, -1, -1));
+    auto v2 = mesh.add_vertex(Point3(-1,  1, -1));
+    auto v3 = mesh.add_vertex(Point3(-1, -1,  1));
+    mesh.add_face(v0, v2, v1);
+    mesh.add_face(v0, v1, v3);
+    mesh.add_face(v0, v3, v2);
+    return mesh;
+}
+
+// Construct an x ≈ "natural" hyper-ideal initialisation:
+//   b_v  = 1 (positive log scale)
+//   a_e  = 0.5 (moderate intersection angle)
+inline std::vector<double> natural_x(const ConformalMesh& mesh,
+                                       const HyperIdealMaps& m)
+{
+    const int n = hyper_ideal_dimension(mesh, m);
+    std::vector<double> x(static_cast<std::size_t>(n), 0.0);
+    for (auto v : mesh.vertices()) {
+        int i = m.v_idx[v];
+        if (i >= 0) x[static_cast<std::size_t>(i)] = 1.0;
+    }
+    for (auto e : mesh.edges()) {
+        int i = m.e_idx[e];
+        if (i >= 0) x[static_cast<std::size_t>(i)] = 0.5;
+    }
+    return x;
+}
+
+} // anonymous namespace
+
+// ════════════════════════════════════════════════════════════════════════════
+// 1.  Pure helper face_angles_from_local_dofs reproduces compute_face_angles
+//
+// Refactor sanity check: the new pure 6→6 function must produce identical
+// (β₁,β₂,β₃,α₁₂,α₂₃,α₃₁) to the existing mesh-reading compute_face_angles.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(HyperIdealHessian, PureHelperMatchesMeshHelper)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_hyper_ideal_maps(mesh);
+    const int n = assign_all_dof_indices(mesh, m);
+    auto x = natural_x(mesh, m);
+
+    for (auto f : mesh.faces()) {
+        FaceAngles fa = compute_face_angles(mesh, f, x, m);
+
+        // Read the 6 local DOFs the same way Block-FD does.
+        Halfedge_index h0 = mesh.halfedge(f);
+        Halfedge_index h1 = mesh.next(h0);
+        Halfedge_index h2 = mesh.next(h1);
+        Vertex_index v1 = mesh.source(h0);
+        Vertex_index v2 = mesh.source(h1);
+        Vertex_index v3 = mesh.source(h2);
+        Edge_index e12 = mesh.edge(h0);
+        Edge_index e23 = mesh.edge(h1);
+        Edge_index e31 = mesh.edge(h2);
+
+        FaceAngleOutputs o = face_angles_from_local_dofs(
+            dof_val(m.v_idx[v1], x), dof_val(m.v_idx[v2], x), dof_val(m.v_idx[v3], x),
+            dof_val(m.e_idx[e12], x), dof_val(m.e_idx[e23], x), dof_val(m.e_idx[e31], x),
+            m.v_idx[v1] >= 0, m.v_idx[v2] >= 0, m.v_idx[v3] >= 0);
+
+        EXPECT_NEAR(o.beta1, fa.beta1, 1e-14);
+        EXPECT_NEAR(o.beta2, fa.beta2, 1e-14);
+        EXPECT_NEAR(o.beta3, fa.beta3, 1e-14);
+        EXPECT_NEAR(o.alpha12, fa.alpha12, 1e-14);
+        EXPECT_NEAR(o.alpha23, fa.alpha23, 1e-14);
+        EXPECT_NEAR(o.alpha31, fa.alpha31, 1e-14);
+    }
+    (void)n;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 2.  Block-FD ≡ Full-FD  on closed tetrahedron
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(HyperIdealHessian, BlockFD_MatchesFullFD_ClosedTetrahedron)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_hyper_ideal_maps(mesh);
+    const int n = assign_all_dof_indices(mesh, m);
+    auto x = natural_x(mesh, m);
+
+    auto H_full  = hyper_ideal_hessian_sym         (mesh, x, m);
+    auto H_block = hyper_ideal_hessian_block_fd_sym(mesh, x, m);
+
+    Eigen::MatrixXd Df(H_full), Db(H_block);
+    const double diff = (Df - Db).cwiseAbs().maxCoeff();
+    EXPECT_LT(diff, 1e-8)
+        << "Block-FD diverges from Full-FD by " << diff << " on tetrahedron";
+
+    (void)n;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 3.  Block-FD ≡ Full-FD  on open 3-face mesh  (boundary code path)
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(HyperIdealHessian, BlockFD_MatchesFullFD_Open3FaceMesh)
+{
+    auto mesh = make_open_3face_mesh();
+    auto m    = setup_hyper_ideal_maps(mesh);
+    const int n = assign_all_dof_indices(mesh, m);
+    auto x = natural_x(mesh, m);
+
+    auto H_full  = hyper_ideal_hessian_sym         (mesh, x, m);
+    auto H_block = hyper_ideal_hessian_block_fd_sym(mesh, x, m);
+
+    Eigen::MatrixXd Df(H_full), Db(H_block);
+    const double diff = (Df - Db).cwiseAbs().maxCoeff();
+    EXPECT_LT(diff, 1e-8)
+        << "Block-FD diverges from Full-FD by " << diff << " on open 3-face mesh";
+
+    (void)n;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 4.  Block-FD ≡ Full-FD  with pinned DOFs  (partial-DOF code path)
+//
+// Tests the case where some DOFs are pinned (v_idx = -1).  Block-FD must
+// skip pinned columns/rows just like Full-FD does.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(HyperIdealHessian, BlockFD_MatchesFullFD_PinnedDOFs)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_hyper_ideal_maps(mesh);
+
+    // Assign vertex DOFs only; leave edges pinned (a_e fixed at 0).
+    int idx = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = idx++;
+    for (auto e : mesh.edges())    m.e_idx[e] = -1;
+    const int n = hyper_ideal_dimension(mesh, m);
+    ASSERT_EQ(n, 4);   // tetrahedron: 4 vertex DOFs, 0 edge DOFs
+
+    std::vector<double> x(static_cast<std::size_t>(n), 1.0);
+
+    auto H_full  = hyper_ideal_hessian_sym         (mesh, x, m);
+    auto H_block = hyper_ideal_hessian_block_fd_sym(mesh, x, m);
+
+    Eigen::MatrixXd Df(H_full), Db(H_block);
+    const double diff = (Df - Db).cwiseAbs().maxCoeff();
+    EXPECT_LT(diff, 1e-8) << "Block-FD diverges by " << diff << " with pinned edges";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 5.  PSD property (Springborn 2020 strict convexity)
+//
+// The hyper-ideal energy is strictly convex on its domain of validity, so
+// the Hessian is PSD at every interior point.  Both block-FD and full-FD
+// must report this consistently.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(HyperIdealHessian, BlockFD_IsPSD)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_hyper_ideal_maps(mesh);
+    const int n = assign_all_dof_indices(mesh, m);
+    auto x = natural_x(mesh, m);
+
+    auto H = hyper_ideal_hessian_block_fd_sym(mesh, x, m);
+    Eigen::MatrixXd Hd(H);
+
+    // Symmetry to FD rounding tolerance.
+    EXPECT_LT((Hd - Hd.transpose()).cwiseAbs().maxCoeff(), 1e-10)
+        << "Block-FD Hessian should be symmetric after _sym normalisation";
+
+    // PSD via smallest eigenvalue.
+    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es(Hd);
+    EXPECT_GE(es.eigenvalues().minCoeff(), -1e-8)
+        << "Hyper-ideal Hessian must be PSD (Springborn 2020)";
+
+    (void)n;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 6.  Sparsity:  block-FD respects the 6-DOF-per-face locality
+//
+// Each non-zero (i,j) entry must correspond to a pair of DOFs that share at
+// least one face.  This is a structural correctness test independent of the
+// numerical values.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(HyperIdealHessian, BlockFD_SparsityMatchesFaceAdjacency)
+{
+    auto mesh = make_open_3face_mesh();
+    auto m    = setup_hyper_ideal_maps(mesh);
+    const int n = assign_all_dof_indices(mesh, m);
+    auto x = natural_x(mesh, m);
+
+    auto H = hyper_ideal_hessian_block_fd(mesh, x, m);
+
+    // Build the "should-be-nonzero" mask from face adjacency.
+    std::vector<std::vector<bool>> face_pair(n, std::vector<bool>(n, false));
+    for (auto f : mesh.faces()) {
+        auto h0 = mesh.halfedge(f);
+        auto h1 = mesh.next(h0);
+        auto h2 = mesh.next(h1);
+        int idx[6] = {
+            m.v_idx[mesh.source(h0)],
+            m.v_idx[mesh.source(h1)],
+            m.v_idx[mesh.source(h2)],
+            m.e_idx[mesh.edge(h0)],
+            m.e_idx[mesh.edge(h1)],
+            m.e_idx[mesh.edge(h2)],
+        };
+        for (int i = 0; i < 6; ++i) {
+            if (idx[i] < 0) continue;
+            for (int j = 0; j < 6; ++j) {
+                if (idx[j] < 0) continue;
+                face_pair[idx[i]][idx[j]] = true;
+            }
+        }
+    }
+
+    // Every non-zero entry must come from a face-adjacent pair.
+    for (int k = 0; k < H.outerSize(); ++k) {
+        for (Eigen::SparseMatrix<double>::InnerIterator it(H, k); it; ++it) {
+            EXPECT_TRUE(face_pair[it.row()][it.col()])
+                << "Hessian nonzero at (" << it.row() << "," << it.col()
+                << ") between DOFs that share no face";
+        }
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 7.  Performance: measure block-FD vs full-FD on a moderately-sized mesh
+//
+// Builds a "long" tetrahedron-strip mesh: V tetrahedron-cells joined along
+// shared faces.  Asserts the block-FD Hessian computes ≥ 3× faster than
+// the full-FD baseline.  This is the operational case for the Phase 9b
+// optimisation (the asymptotic ratio is ~ n/36, which grows linearly in
+// mesh size).  Wall-clock is printed for the record but the assertion
+// uses a conservative ratio so the test stays stable on slow CI hardware.
+// ════════════════════════════════════════════════════════════════════════════
+
+namespace {
+
+// Build a strip of `n_cells` connected tetrahedra (subdivision-like).
+// The resulting mesh has ~ 2*n_cells + 2 vertices, 4*n_cells faces.
+// (Approximation; the exact count depends on shared-vertex handling.)
+inline ConformalMesh make_tet_strip(int n_cells)
+{
+    ConformalMesh mesh;
+    // Lay out vertex chain at z=0 / z=1 alternating.
+    std::vector<Vertex_index> top, bot;
+    for (int i = 0; i <= n_cells; ++i) {
+        top.push_back(mesh.add_vertex(Point3(i,   0, 0)));
+        bot.push_back(mesh.add_vertex(Point3(i, 0.7, 0.5 * std::sin(0.3*i))));
+    }
+    // Add two triangles per cell (one row of "zig-zag" triangles).
+    for (int i = 0; i < n_cells; ++i) {
+        mesh.add_face(top[i],   bot[i],   top[i+1]);
+        mesh.add_face(bot[i],   bot[i+1], top[i+1]);
+    }
+    return mesh;
+}
+
+} // anonymous namespace
+
+TEST(HyperIdealHessian, BlockFD_FasterThanFullFD)
+{
+    // 100 cells → ~200 faces, ~200 vertex DOFs + ~300 edge DOFs ≈ 500 DOFs.
+    // Full-FD: 500 × 200 ≈ 100 k face evaluations
+    // Block-FD: 200 × 12 ≈ 2.4 k face evaluations
+    // Theoretical ratio: ~42×.  We assert ≥ 3× to leave wide CI tolerance.
+    auto mesh = make_tet_strip(100);
+    auto m    = setup_hyper_ideal_maps(mesh);
+    const int n = assign_all_dof_indices(mesh, m);
+    auto x = natural_x(mesh, m);
+
+    using clk = std::chrono::steady_clock;
+
+    auto t1 = clk::now();
+    auto H_full  = hyper_ideal_hessian         (mesh, x, m);
+    auto t2 = clk::now();
+    auto H_block = hyper_ideal_hessian_block_fd(mesh, x, m);
+    auto t3 = clk::now();
+
+    auto ms_full  = std::chrono::duration_cast<std::chrono::microseconds>(t2-t1).count();
+    auto ms_block = std::chrono::duration_cast<std::chrono::microseconds>(t3-t2).count();
+
+    std::cerr << "[HyperIdealHessian.BlockFD_FasterThanFullFD]"
+              << "  V=" << mesh.number_of_vertices()
+              << "  F=" << mesh.number_of_faces()
+              << "  DOFs=" << n
+              << "  full-FD: " << ms_full  << " µs"
+              << "  block-FD: " << ms_block << " µs"
+              << "  speed-up: " << (ms_block > 0 ? (double)ms_full / (double)ms_block : 0.0)
+              << "×\n";
+
+    // Both must report identical Hessians (within FD rounding).
+    Eigen::MatrixXd Df(H_full), Db(H_block);
+    EXPECT_LT((Df - Db).cwiseAbs().maxCoeff(), 1e-8);
+
+    // Conservative speed-up assertion — typically observe ~30×, accept ≥ 3×.
+    EXPECT_GE(ms_full, 3 * ms_block)
+        << "Block-FD should be at least 3× faster than full-FD on this mesh";
+}

code/tests/cgal/test_inversive_distance_functional.cpp

@@ -0,0 +1,262 @@
+// test_inversive_distance_functional.cpp
+//
+// Phase 9a.2 — Inversive-distance functional (Luo 2004) tests.
+//
+// Validation against three mathematical references:
+//
+//   [Luo 2004]        ℓ_ij² = exp(2u_i) + exp(2u_j) + 2 I_ij exp(u_i+u_j)
+//                     ∂E/∂u_v = Θ_v − Σ α_v   (Lemma 3.1)
+//
+//   [BS 2004]         I_ij = (ℓ² − r_i² − r_j²) / (2 r_i r_j)
+//                     I = 1 ⇒ tangential circles
+//                     I = 0 ⇒ orthogonal circles
+//
+//   [Glickenstein 2011 §5]
+//                     correspondence to BPS-2010 face-based CP:
+//                     I_ij = cos θ_e on the face-dual mesh
+//
+// No Java reference exists for this functional in
+// de.varylab.discreteconformal.  Cross-validation is done via:
+//   1. FD-vs-analytic gradient check (numerical),
+//   2. Luo's edge-length identity check (mathematical),
+//   3. Tangential-limit identity I=1 ⇒ ℓ = r_i+r_j (geometric).
+
+#include "inversive_distance_functional.hpp"
+#include "euclidean_functional.hpp"
+#include "mesh_builder.hpp"
+#include "conformal_mesh.hpp"
+
+#include <gtest/gtest.h>
+#include <vector>
+#include <random>
+#include <cmath>
+
+using namespace conformallab;
+
+// ════════════════════════════════════════════════════════════════════════════
+// 1.  Edge-length formula  (Luo 2004 §3)
+//
+//   ℓ² = exp(2u_i) + exp(2u_j) + 2 I exp(u_i+u_j)
+//      = r_i² + r_j² + 2 I r_i r_j
+//
+// Special cases:
+//   I = 1  ⇒ ℓ² = (r_i + r_j)²  ⇒  ℓ = r_i + r_j     (tangential)
+//   I = 0  ⇒ ℓ² = r_i² + r_j²    (orthogonal — circles meet at 90°)
+//   I = −1 ⇒ ℓ² = (r_i − r_j)²  ⇒  ℓ = |r_i − r_j|  (inside-tangent)
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(InversiveDistanceFunctional, EdgeLengthFormula_TangentialLimit)
+{
+    // ui = 0 ⇒ ri = 1;  uj = log(2) ⇒ rj = 2;  I = 1 (tangential):
+    //   ℓ² = 1 + 4 + 2·1·1·2 = 9 ⇒ ℓ = 3 = r_i + r_j ✓
+    double l2 = id_detail::edge_length_squared(0.0, std::log(2.0), 1.0);
+    EXPECT_NEAR(std::sqrt(l2), 3.0, 1e-12);
+}
+
+TEST(InversiveDistanceFunctional, EdgeLengthFormula_OrthogonalLimit)
+{
+    // r_i = 3, r_j = 4, I = 0:  ℓ² = 9 + 16 = 25 ⇒ ℓ = 5  (Pythagorean)
+    double l2 = id_detail::edge_length_squared(std::log(3.0), std::log(4.0), 0.0);
+    EXPECT_NEAR(std::sqrt(l2), 5.0, 1e-12);
+}
+
+TEST(InversiveDistanceFunctional, EdgeLengthFormula_InsideTangentLimit)
+{
+    // r_i = 2, r_j = 5, I = −1:  ℓ² = (5 − 2)² = 9 ⇒ ℓ = 3
+    double l2 = id_detail::edge_length_squared(std::log(2.0), std::log(5.0), -1.0);
+    EXPECT_NEAR(std::sqrt(l2), 3.0, 1e-12);
+}
+
+TEST(InversiveDistanceFunctional, EdgeLengthFormula_DegenerateReturnsMinusOne)
+{
+    // r_i = r_j = 1, I = −2:  ℓ² = 1 + 1 − 4 = −2  (impossible packing)
+    double l2 = id_detail::edge_length_squared(0.0, 0.0, -2.0);
+    EXPECT_EQ(l2, -1.0) << "should signal degenerate packing";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 2.  Bowers-Stephenson identity round-trip
+//
+//   Given (ℓ, r_i, r_j), the I_ij that compute_init produces must satisfy
+//   Luo's edge-length formula exactly: ℓ²(I_ij, r_i, r_j) = ℓ².
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(InversiveDistanceFunctional, BowersStephensonRoundTrip)
+{
+    auto mesh = make_triangle();   // (0,0,0)-(1,0,0)-(0,1,0)
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    // At u = 0, exp(u) = r0.  Reconstruct ℓ from (r_i, r_j, I_ij) and compare
+    // to the 3-D Euclidean edge length from the mesh.
+    for (auto e : mesh.edges()) {
+        auto h = mesh.halfedge(e);
+        auto p1 = mesh.point(mesh.source(h));
+        auto p2 = mesh.point(mesh.target(h));
+        double dx = p1.x() - p2.x();
+        double dy = p1.y() - p2.y();
+        double dz = p1.z() - p2.z();
+        double l_3d = std::sqrt(dx*dx + dy*dy + dz*dz);
+
+        double ri = m.r0[mesh.source(h)];
+        double rj = m.r0[mesh.target(h)];
+        double l2_reconstructed = ri*ri + rj*rj + 2.0 * m.I_e[e] * ri * rj;
+        EXPECT_NEAR(std::sqrt(l2_reconstructed), l_3d, 1e-12)
+            << "Bowers-Stephenson round-trip failed for an edge";
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 3.  Properties of the init step
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(InversiveDistanceFunctional, InitProducesValidPositiveRadii)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    for (auto v : mesh.vertices()) {
+        EXPECT_GT(m.r0[v], 0.0) << "init radius must be positive";
+        EXPECT_TRUE(std::isfinite(m.r0[v]));
+    }
+    for (auto e : mesh.edges()) {
+        EXPECT_TRUE(std::isfinite(m.I_e[e]));
+        // I > −1 is required for any valid inversive-distance packing.
+        EXPECT_GT(m.I_e[e], -1.0);
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 4.  Gradient at the "natural equilibrium" is zero by construction
+//
+// Same trick as in test_euclidean_functional.cpp:
+//   • Set u = 0  ⇒  r = r0  ⇒  ℓ = ℓ_3d  (Bowers-Stephenson round-trip)
+//   • Compute G(0) — that's the angle defect Θ − Σ_actual.
+//   • Subtract G(0) from Θ → new G(0) is zero.
+// This means u = 0 is now the Newton equilibrium of the functional, just
+// like in the euclidean functional natural-theta trick.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(InversiveDistanceFunctional, NaturalThetaGivesZeroGradientAtU0)
+{
+    auto mesh = make_triangle();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    // Assign DOFs to all vertices.
+    int n = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = n++;
+    std::vector<double> x(static_cast<std::size_t>(n), 0.0);
+
+    auto G0 = inversive_distance_gradient(mesh, x, m);
+    for (auto v : mesh.vertices()) {
+        int i = m.v_idx[v];
+        m.theta_v[v] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    auto G_eq = inversive_distance_gradient(mesh, x, m);
+    for (double g : G_eq) EXPECT_NEAR(g, 0.0, 1e-13);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 5.  FD-vs-analytic gradient check (the main acceptance test for the port)
+//
+// Pattern: identical to test_euclidean_functional.cpp's
+// GradientCheck_TriangleVertex (lines 137-149).  The energy is the path
+// integral of the gradient (by construction); a consistent FD-vs-analytic
+// match validates both energy and gradient implementations together.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(InversiveDistanceFunctional, FDGradientCheck_Triangle)
+{
+    auto mesh = make_triangle();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    int n = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = n++;
+
+    // Small perturbation u_v ≈ −0.1 keeps every triangle valid.
+    std::vector<double> x(static_cast<std::size_t>(n), -0.1);
+    EXPECT_TRUE(gradient_check_inversive_distance(mesh, x, m))
+        << "FD gradient mismatch on single triangle (u = −0.1)";
+}
+
+TEST(InversiveDistanceFunctional, FDGradientCheck_QuadStrip)
+{
+    auto mesh = make_quad_strip();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    int n = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = n++;
+
+    std::vector<double> x(static_cast<std::size_t>(n), -0.15);
+    EXPECT_TRUE(gradient_check_inversive_distance(mesh, x, m))
+        << "FD gradient mismatch on quad strip";
+}
+
+TEST(InversiveDistanceFunctional, FDGradientCheck_Tetrahedron)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    int n = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = n++;
+
+    std::vector<double> x(static_cast<std::size_t>(n), -0.2);
+    EXPECT_TRUE(gradient_check_inversive_distance(mesh, x, m))
+        << "FD gradient mismatch on regular tetrahedron";
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 6.  Cross-validation with euclidean_functional.hpp
+//
+// The two functionals are DIFFERENT geometric models.  At u = 0 with their
+// natural inits both produce a valid triangulation, but the per-edge length
+// is different:
+//   • Euclidean:           ℓ = ℓ_3d                  (exact, by lambda0 init)
+//   • Inversive distance:  ℓ = ℓ_3d                  (exact, by BS round-trip)
+//
+// HOWEVER the GRADIENT at u = 0 differs because the chain rule ∂ℓ/∂u is
+// different.  Specifically:
+//   • Euclidean:           ∂(2 log ℓ)/∂u_i = 1
+//   • Inversive distance:  ∂(2 log ℓ)/∂u_i = (r_i² + I r_i r_j) / ℓ²
+//
+// This test pins one quantitative consequence: at u = 0 both gradients have
+// the SAME angle-defect structure Θ − Σ_actual.  After applying the natural-
+// theta trick on each, both must be at equilibrium with G(0) = 0.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(InversiveDistanceFunctional, AngleDefectAtU0_AgreesWithEuclideanAtU0)
+{
+    auto mesh = make_quad_strip();
+
+    // ── Inversive distance side ────────────────────────────────────────────
+    auto m_id = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m_id);
+    int n_id = 0;
+    for (auto v : mesh.vertices()) m_id.v_idx[v] = n_id++;
+    std::vector<double> x_id(static_cast<std::size_t>(n_id), 0.0);
+    auto G_id = inversive_distance_gradient(mesh, x_id, m_id);
+
+    // ── Euclidean side (same mesh, same DOF order) ─────────────────────────
+    auto m_eu = setup_euclidean_maps(mesh);
+    compute_euclidean_lambda0_from_mesh(mesh, m_eu);
+    int n_eu = 0;
+    for (auto v : mesh.vertices()) m_eu.v_idx[v] = n_eu++;
+    std::vector<double> x_eu(static_cast<std::size_t>(n_eu), 0.0);
+    auto G_eu = euclidean_gradient(const_cast<ConformalMesh&>(mesh), x_eu, m_eu);
+
+    // Both should report the same actual angle sum per vertex at u = 0
+    // (since both reproduce ℓ = ℓ_3d at u = 0).  Therefore  Θ − Σ_actual
+    // is identical for the two functionals (Θ default 2π in both).
+    ASSERT_EQ(G_id.size(), G_eu.size());
+    for (std::size_t i = 0; i < G_id.size(); ++i) {
+        EXPECT_NEAR(G_id[i], G_eu[i], 1e-10)
+            << "angle-defect mismatch at u=0, DOF " << i
+            << ": id=" << G_id[i] << "  eu=" << G_eu[i];
+    }
+}

code/tests/cgal/test_newton_phase9a.cpp

@@ -0,0 +1,264 @@
+// test_newton_phase9a.cpp
+//
+// Phase 9a Newton solvers — convergence tests for the two new
+// circle-packing functionals.
+//
+// Validates that:
+//   • newton_cp_euclidean()        — face-based BPS-2010 functional.
+//   • newton_inversive_distance()  — vertex-based Luo-2004 functional.
+// both reach a Newton equilibrium (‖G‖∞ < 1e-8) in < 30 iterations
+// on a range of test meshes, and that the converged solution satisfies
+// the relevant geometric invariants.
+
+#include "newton_solver.hpp"
+#include "cp_euclidean_functional.hpp"
+#include "inversive_distance_functional.hpp"
+#include "mesh_builder.hpp"
+#include "conformal_mesh.hpp"
+
+#include <gtest/gtest.h>
+#include <vector>
+
+using namespace conformallab;
+
+namespace {
+
+// Open 3-face mesh (tetrahedron minus one face) — exercises boundary edges.
+inline ConformalMesh make_open_3face_mesh()
+{
+    ConformalMesh mesh;
+    auto v0 = mesh.add_vertex(Point3( 1,  1,  1));
+    auto v1 = mesh.add_vertex(Point3( 1, -1, -1));
+    auto v2 = mesh.add_vertex(Point3(-1,  1, -1));
+    auto v3 = mesh.add_vertex(Point3(-1, -1,  1));
+    mesh.add_face(v0, v2, v1);
+    mesh.add_face(v0, v1, v3);
+    mesh.add_face(v0, v3, v2);
+    return mesh;
+}
+
+} // anonymous
+
+// ════════════════════════════════════════════════════════════════════════════
+// 1. CP-Euclidean Newton — orthogonal circle packing
+//
+// Setup matches CPEuclideanFunctionalTest.java (Java parity at the
+// solver level): θ_e = π/2 everywhere, φ_f = 2π for all faces.  Use
+// the "natural-phi" trick (analog of natural-theta in Euclidean):
+// adjust φ so that ρ = 0 is the natural equilibrium → Newton must
+// converge in zero iterations.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, CPEuclidean_NaturalPhi_ClosedTetrahedron_ConvergesInZeroIterations)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+    ASSERT_EQ(n, 3);
+
+    // Natural-phi: shift φ_f so the gradient at ρ = 0 is zero.
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = cp_euclidean_gradient(mesh, x0, m);
+    for (auto f : mesh.faces()) {
+        int i = m.f_idx[f];
+        if (i < 0) continue;
+        m.phi_f[f] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    auto res = newton_cp_euclidean(mesh, x0, m);
+    EXPECT_TRUE(res.converged);
+    EXPECT_EQ(res.iterations, 0)
+        << "natural-phi pre-shift should make x=0 the equilibrium";
+    EXPECT_LT(res.grad_inf_norm, 1e-10);
+    for (double r : res.x) EXPECT_NEAR(r, 0.0, 1e-12);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 2. CP-Euclidean Newton — perturbed equilibrium converges back to 0
+//
+// Same setup as test 1, but start from a small perturbation.  The
+// strictly-convex BPS-2010 energy means Newton must converge back
+// to the natural-phi equilibrium ρ = 0.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, CPEuclidean_PerturbedStart_ConvergesBackToEquilibrium)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    // Apply natural-phi (equilibrium at ρ=0).
+    std::vector<double> x0_zero(static_cast<std::size_t>(n), 0.0);
+    auto G0 = cp_euclidean_gradient(mesh, x0_zero, m);
+    for (auto f : mesh.faces()) {
+        int i = m.f_idx[f];
+        if (i < 0) continue;
+        m.phi_f[f] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    // Start from a perturbation.
+    std::vector<double> x0 = {0.1, -0.2, 0.15};
+    auto res = newton_cp_euclidean(mesh, x0, m);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.iterations, 30);
+    EXPECT_LT(res.grad_inf_norm, 1e-8);
+    // Strictly-convex unique minimum → converges back to ρ=0.
+    for (double r : res.x) EXPECT_NEAR(r, 0.0, 1e-6);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 3. CP-Euclidean Newton — open mesh (boundary edges)
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, CPEuclidean_OpenTetrahedron_NaturalPhi_Converges)
+{
+    auto mesh = make_open_3face_mesh();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+    ASSERT_EQ(n, 2);
+
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = cp_euclidean_gradient(mesh, x0, m);
+    for (auto f : mesh.faces()) {
+        int i = m.f_idx[f];
+        if (i < 0) continue;
+        m.phi_f[f] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    auto res = newton_cp_euclidean(mesh, x0, m);
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.iterations, 30);
+    EXPECT_LT(res.grad_inf_norm, 1e-8);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 4. Inversive-Distance Newton — natural-theta on triangle
+//
+// At u = 0, Bowers-Stephenson init reproduces the input edge lengths
+// exactly.  Natural-theta then shifts Θ so the gradient is zero, making
+// u = 0 the equilibrium.  Newton must converge in zero iterations.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, InversiveDistance_NaturalTheta_Triangle_ConvergesInZero)
+{
+    auto mesh = make_triangle();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    int n = 0;
+    for (auto v : mesh.vertices()) m.v_idx[v] = n++;
+
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = inversive_distance_gradient(mesh, x0, m);
+    for (auto v : mesh.vertices()) {
+        int i = m.v_idx[v];
+        m.theta_v[v] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    auto res = newton_inversive_distance(mesh, x0, m);
+    EXPECT_TRUE(res.converged);
+    EXPECT_EQ(res.iterations, 0);
+    EXPECT_LT(res.grad_inf_norm, 1e-10);
+    for (double u : res.x) EXPECT_NEAR(u, 0.0, 1e-12);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 5. Inversive-Distance Newton — perturbed start on quad strip
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, InversiveDistance_PerturbedQuadStrip_Converges)
+{
+    auto mesh = make_quad_strip();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    // Pin vertex 0; index the rest.
+    auto vit = mesh.vertices().begin();
+    m.v_idx[*vit++] = -1;
+    int n = 0;
+    for (; vit != mesh.vertices().end(); ++vit) m.v_idx[*vit] = n++;
+
+    // Natural-theta with the pin in place.
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = inversive_distance_gradient(mesh, x0, m);
+    for (auto v : mesh.vertices()) {
+        int i = m.v_idx[v];
+        if (i >= 0) m.theta_v[v] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    // Perturb away from the equilibrium and watch it return.
+    std::vector<double> x_pert(static_cast<std::size_t>(n), -0.05);
+    auto res = newton_inversive_distance(mesh, x_pert, m);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.iterations, 30);
+    EXPECT_LT(res.grad_inf_norm, 1e-8);
+    // Strictly-convex unique minimum on the open domain → back to 0.
+    for (double u : res.x) EXPECT_NEAR(u, 0.0, 1e-6);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 6. Inversive-Distance Newton — tetrahedron (closed mesh)
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, InversiveDistance_PerturbedTetrahedron_Converges)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    // Closed mesh — pin one vertex to remove the gauge mode.
+    auto vit = mesh.vertices().begin();
+    m.v_idx[*vit++] = -1;
+    int n = 0;
+    for (; vit != mesh.vertices().end(); ++vit) m.v_idx[*vit] = n++;
+
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = inversive_distance_gradient(mesh, x0, m);
+    for (auto v : mesh.vertices()) {
+        int i = m.v_idx[v];
+        if (i >= 0) m.theta_v[v] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    std::vector<double> x_pert(static_cast<std::size_t>(n), -0.1);
+    auto res = newton_inversive_distance(mesh, x_pert, m);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LT(res.iterations, 30);
+    EXPECT_LT(res.grad_inf_norm, 1e-8);
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// 7. CP-Euclidean Newton — uses analytic Hessian (NOT FD)
+//
+// Regression guard: verify the solver actually calls cp_euclidean_hessian
+// (the analytic 2×2-per-edge formula) rather than degenerating to a
+// per-iteration FD pass.  If iteration count exceeds a tight upper bound
+// for a tiny mesh, that would suggest a slow inner Hessian computation
+// or a wrong-sign mistake.
+// ════════════════════════════════════════════════════════════════════════════
+
+TEST(NewtonPhase9a, CPEuclidean_UsesAnalyticHessian)
+{
+    auto mesh = make_tetrahedron();
+    auto m    = setup_cp_euclidean_maps(mesh);
+    const int n = assign_cp_euclidean_face_dof_indices(mesh, m);
+
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = cp_euclidean_gradient(mesh, x0, m);
+    for (auto f : mesh.faces()) {
+        int i = m.f_idx[f];
+        if (i < 0) continue;
+        m.phi_f[f] -= G0[static_cast<std::size_t>(i)];
+    }
+
+    // Strong perturbation — quadratic Newton with analytic Hessian
+    // should still converge in a handful of iterations.
+    std::vector<double> x_pert = {0.5, -0.4, 0.3};
+    auto res = newton_cp_euclidean(mesh, x_pert, m);
+
+    EXPECT_TRUE(res.converged);
+    EXPECT_LE(res.iterations, 10)
+        << "analytic Hessian: expect very fast convergence on a 3-DOF problem";
+}

code/tests/cgal/test_scalability_smoke.cpp

@@ -0,0 +1,201 @@
+// test_scalability_smoke.cpp
+//
+// Scalability smoke tests — convergence on large real-world meshes.
+//
+// PURPOSE
+//   These tests verify that the Newton solver converges correctly on meshes
+//   significantly larger than the unit tests (which use tiny synthetic meshes).
+//   They do NOT assert on wall-clock time — timing is printed for information
+//   only, so the tests remain stable on slow CI hardware (Raspberry Pi ARM64).
+//
+//   If Newton fails to converge here, it is a correctness regression, not a
+//   performance regression.  See doc/math/complexity.md for timing context.
+//
+// MESHES USED
+//   cathead.obj   V=131,  F=248,  genus=0, open  — small, sanity check
+//   brezel.obj    V=6910, F=13824, genus=2, closed — large genus-2 mesh (χ=−2)
+//   brezel2.obj   V=2622, F=5248,  genus=2, closed — smaller genus-2 mesh (χ=−2)
+//
+// NOTE: both brezel meshes are genus-2. The naming follows the Java original
+// where "brezel2" is a different triangulation, not a different genus.
+//
+// EXPECTED RESULTS
+//   Newton converges in < 30 iterations for all Euclidean meshes (strictly
+//   convex energy, quadratic convergence from u=0).
+//   Cut graph produces 2g seam edges: 2 for brezel, 4 for brezel2.
+//
+// Tests:
+//   1. SmokeEuclidean.CatHead_SmallOpen
+//   2. SmokeEuclidean.Brezel_LargeGenus2
+//   3. SmokeEuclidean.Brezel2_Genus2_CutGraph
+
+#include "conformal_mesh.hpp"
+#include "mesh_io.hpp"
+#include "euclidean_functional.hpp"
+#include "gauss_bonnet.hpp"
+#include "newton_solver.hpp"
+#include "cut_graph.hpp"
+#include <gtest/gtest.h>
+#include <chrono>
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <string>
+
+using namespace conformallab;
+using Clock = std::chrono::steady_clock;
+using Ms    = std::chrono::milliseconds;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+static int setup_open_mesh_dofs(ConformalMesh& mesh, EuclideanMaps& maps)
+{
+    int idx = 0;
+    for (auto v : mesh.vertices())
+        maps.v_idx[v] = mesh.is_border(v) ? -1 : idx++;
+    return idx;
+}
+
+static int setup_closed_mesh_dofs(ConformalMesh& mesh, EuclideanMaps& maps)
+{
+    auto vit = mesh.vertices().begin();
+    maps.v_idx[*vit++] = -1;
+    int idx = 0;
+    for (; vit != mesh.vertices().end(); ++vit)
+        maps.v_idx[*vit] = idx++;
+    return idx;
+}
+
+static void apply_natural_theta(ConformalMesh& mesh, EuclideanMaps& maps, int n)
+{
+    std::vector<double> x0(static_cast<std::size_t>(n), 0.0);
+    auto G0 = euclidean_gradient(mesh, x0, maps);
+    for (auto v : mesh.vertices()) {
+        int iv = maps.v_idx[v];
+        if (iv >= 0) maps.theta_v[v] -= G0[static_cast<std::size_t>(iv)];
+    }
+}
+
+// ── Test 1 — cathead.obj (V=131, F=248, open) ────────────────────────────────
+
+TEST(SmokeEuclidean, CatHead_SmallOpen)
+{
+    const std::string path = std::string(CONFORMALLAB_DATA_DIR) + "/obj/cathead.obj";
+    ConformalMesh mesh;
+    ASSERT_NO_THROW(mesh = load_mesh(path)) << "cathead.obj not found: " << path;
+
+    EXPECT_EQ(131u, mesh.number_of_vertices());
+    EXPECT_EQ(248u, mesh.number_of_faces());
+
+    auto maps = setup_euclidean_maps(mesh);
+    compute_euclidean_lambda0_from_mesh(mesh, maps);
+    const int n = setup_open_mesh_dofs(mesh, maps);
+    apply_natural_theta(mesh, maps, n);
+
+    // Start from a small perturbation so Newton actually iterates.
+    std::vector<double> x0(static_cast<std::size_t>(n), -0.05);
+
+    auto t0 = Clock::now();
+    auto res = newton_euclidean(mesh, x0, maps, 1e-9, 200);
+    auto dt  = std::chrono::duration_cast<Ms>(Clock::now() - t0).count();
+
+    std::cout << "[SmokeEuclidean.CatHead] V=" << mesh.number_of_vertices()
+              << " F=" << mesh.number_of_faces()
+              << " iter=" << res.iterations
+              << " ||G||=" << res.grad_inf_norm
+              << " time=" << dt << "ms\n";
+
+    EXPECT_TRUE(res.converged)   << "Newton did not converge on cathead.obj";
+    EXPECT_LT(res.iterations, 30) << "Newton took ≥ 30 iterations — unexpected";
+    EXPECT_LT(res.grad_inf_norm, 1e-8);
+}
+
+// ── Test 2 — brezel.obj (V=6910, F=13824, genus=2) ───────────────────────────
+// Primary scalability target: largest mesh in the test suite.
+// Newton is started from a small perturbation (x0 = −0.05) so it must
+// actually iterate rather than exit immediately from the trivial equilibrium.
+
+TEST(SmokeEuclidean, Brezel_LargeGenus2)
+{
+    const std::string path = std::string(CONFORMALLAB_DATA_DIR) + "/obj/brezel.obj";
+    ConformalMesh mesh;
+    ASSERT_NO_THROW(mesh = load_mesh(path)) << "brezel.obj not found: " << path;
+
+    EXPECT_EQ(6910u,  mesh.number_of_vertices());
+    EXPECT_EQ(13824u, mesh.number_of_faces());
+
+    // Euler characteristic: V - E + F = −2 for genus-2 closed surface
+    const int chi = static_cast<int>(mesh.number_of_vertices())
+                  - static_cast<int>(mesh.number_of_edges())
+                  + static_cast<int>(mesh.number_of_faces());
+    EXPECT_EQ(-2, chi) << "brezel.obj must be genus-2 (χ=−2)";
+
+    auto maps = setup_euclidean_maps(mesh);
+    compute_euclidean_lambda0_from_mesh(mesh, maps);
+
+    const int n = setup_closed_mesh_dofs(mesh, maps);
+    enforce_gauss_bonnet(mesh, maps);
+    apply_natural_theta(mesh, maps, n);
+
+    // Start from a small perturbation so Newton actually iterates.
+    std::vector<double> x0(static_cast<std::size_t>(n), -0.05);
+
+    // Newton solve
+    auto t0  = Clock::now();
+    auto res = newton_euclidean(mesh, x0, maps, 1e-9, 200);
+    auto dt_newton = std::chrono::duration_cast<Ms>(Clock::now() - t0).count();
+
+    // Cut graph
+    auto t1  = Clock::now();
+    CutGraph cg = compute_cut_graph(mesh);
+    auto dt_cut = std::chrono::duration_cast<Ms>(Clock::now() - t1).count();
+
+    std::cout << "[SmokeEuclidean.Brezel] V=" << mesh.number_of_vertices()
+              << " F=" << mesh.number_of_faces()
+              << " iter=" << res.iterations
+              << " ||G||=" << res.grad_inf_norm
+              << " newton=" << dt_newton << "ms"
+              << " cut=" << dt_cut << "ms\n";
+
+    EXPECT_TRUE(res.converged)    << "Newton did not converge on brezel.obj";
+    EXPECT_LT(res.iterations, 30) << "Newton took ≥ 30 iterations";
+    EXPECT_LT(res.grad_inf_norm, 1e-8);
+
+    // Genus-2: 2g = 4 seam edges
+    EXPECT_EQ(4u, cg.cut_edge_indices.size())
+        << "brezel.obj (genus 2) must yield 2g=4 cut edges";
+    EXPECT_EQ(2, cg.genus);
+}
+
+// ── Test 3 — brezel2.obj (V=2622, F=5248, genus=2) ───────────────────────────
+
+TEST(SmokeEuclidean, Brezel2_Genus2_CutGraph)
+{
+    const std::string path = std::string(CONFORMALLAB_DATA_DIR) + "/obj/brezel2.obj";
+    ConformalMesh mesh;
+    ASSERT_NO_THROW(mesh = load_mesh(path)) << "brezel2.obj not found: " << path;
+
+    EXPECT_EQ(2622u, mesh.number_of_vertices());
+    EXPECT_EQ(5248u, mesh.number_of_faces());
+
+    const int chi = static_cast<int>(mesh.number_of_vertices())
+                  - static_cast<int>(mesh.number_of_edges())
+                  + static_cast<int>(mesh.number_of_faces());
+    EXPECT_EQ(-2, chi) << "brezel2.obj must be genus-2 (χ=−2)";
+
+    // Cut graph only — Newton on genus-2 requires full DOF setup
+    // (tested separately in test_geometry_utils.cpp HomologyGenerators suite)
+    auto t0  = Clock::now();
+    CutGraph cg = compute_cut_graph(mesh);
+    auto dt_cut = std::chrono::duration_cast<Ms>(Clock::now() - t0).count();
+
+    std::cout << "[SmokeEuclidean.Brezel2] V=" << mesh.number_of_vertices()
+              << " F=" << mesh.number_of_faces()
+              << " cut=" << dt_cut << "ms"
+              << " seams=" << cg.cut_edge_indices.size() << "\n";
+
+    // Genus-2: 2g = 4 seam edges
+    EXPECT_EQ(4u, cg.cut_edge_indices.size())
+        << "brezel2.obj (genus 2) must yield 2g=4 cut edges";
+    EXPECT_EQ(2, cg.genus);
+}

code/tests/cgal/test_spherical_functional.cpp

@@ -6,7 +6,7 @@
 //
 // Test map (Java → C++)
 // ──────────────────────
-//   testHessian (Ignored)         → GradientCheck_Hessian     (SKIPPED)
+//   testHessian (Ignored)         → GradientCheck_Hessian     (ported)
 //   testGradientWithHyperIdeal…   → GradientCheck_OctaFaceVertex   (ported)
 //   testGradientInExtendedDomain  → GradientCheck_SpherTetVertex    (ported)
 //   testGradientWithHyperelliptic → GradientCheck_SpherTetAllDofs   (ported)
@@ -23,6 +23,7 @@
 #include "conformal_mesh.hpp"
 #include "mesh_builder.hpp"
 #include "spherical_functional.hpp"
+#include "spherical_hessian.hpp"
 #include <gtest/gtest.h>
 #include <cmath>
 #include <vector>
@@ -30,12 +31,29 @@
 using namespace conformallab;
 
 // ════════════════════════════════════════════════════════════════════════════
-// @Ignore in Java: no Hessian implemented
+// Cross-module Hessian check: spherical_gradient() ↔ spherical_hessian()
+//
+// Java @Ignore reason: "no Hessian implemented" — the Java functional test
+// was written before the Hessian existed.  In C++ the analytic spherical
+// Hessian (spherical_hessian.hpp, Phase 3f) is complete.
+//
+// This test verifies cross-module consistency between the functional and
+// the Hessian module.  The spherical Hessian is NSD (negative semi-definite)
+// because the spherical energy is concave — hessian_check_spherical() uses
+// the sign-corrected FD check appropriate for the spherical case.
 // ════════════════════════════════════════════════════════════════════════════
 
 TEST(SphericalFunctional, GradientCheck_Hessian)
 {
-    GTEST_SKIP() << "@Ignore in Java – Hessian not implemented";
+    auto mesh = make_spherical_tetrahedron();
+    auto maps = setup_spherical_maps(mesh);
+    compute_lambda0_from_mesh(mesh, maps);
+    int n = assign_vertex_dof_indices(mesh, maps);
+
+    std::vector<double> x(static_cast<std::size_t>(n), -0.2);
+
+    EXPECT_TRUE(hessian_check_spherical(mesh, x, maps))
+        << "Cross-module: spherical_gradient() and spherical_hessian() are inconsistent";
 }
 
 // ════════════════════════════════════════════════════════════════════════════

code/tests/test_hyper_ideal_functional.cpp

@@ -1,37 +0,0 @@
-// Stub for de.varylab.discreteconformal.functional.HyperIdealFunctionalTest (Java/JUnit).
-//
-// STATUS: BLOCKED – requires HDS port (Phase 4).
-//
-// These tests evaluate gradient and Hessian of the HyperIdealFunctional on
-// actual mesh data (CoHDS + HyperIdealGenerator).  They cannot be ported
-// until the HalfEdge data structure (CoHDS), the functional evaluation
-// framework, and the mesh generators are available in C++.
-//
-// Java tests and their status:
-//   testHessian()                           – @Ignore in Java (skipped here too)
-//   testGradientWithHyperIdealAndIdealPoints – blocked: needs HDS
-//   testGradientInTheExtendedDomain          – blocked: needs HDS
-//   testGradientWithHyperellipticCurve       – blocked: needs HDS
-//   testFunctionalAtNaNValue                 – blocked: needs HDS
-
-#include <gtest/gtest.h>
-
-TEST(HyperIdealFunctionalTest, TestHessian_IgnoredInJava) {
-    GTEST_SKIP() << "@Ignore in Java – skipped here too";
-}
-
-TEST(HyperIdealFunctionalTest, GradientWithHyperIdealAndIdealPoints) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HyperIdealFunctional)";
-}
-
-TEST(HyperIdealFunctionalTest, GradientInTheExtendedDomain) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HyperIdealFunctional)";
-}
-
-TEST(HyperIdealFunctionalTest, GradientWithHyperellipticCurve) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HyperIdealFunctional)";
-}
-
-TEST(HyperIdealFunctionalTest, FunctionalAtNaNValue) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HyperIdealFunctional)";
-}

code/tests/test_hyper_ideal_hyperelliptic_utility.cpp

@@ -1,26 +0,0 @@
-// Stub for de.varylab.discreteconformal.functional.HyperIdealHyperellipticUtilityTest.
-//
-// STATUS: BLOCKED – requires HDS port (Phase 4).
-//
-// Tests compute intersection angles of circles associated with hyper-ideal
-// vertices using CoHDS + HalfEdgeUtils.  All three tests operate on mesh
-// data structures that are not yet available in C++.
-//
-// Java tests and their status:
-//   testCalculateCircleIntersections         – blocked: needs CoHDS + HalfEdgeUtils
-//   testCalculateCircleIntersectionsInfinite – blocked: needs CoHDS + HalfEdgeUtils
-//   testLawsonHyperellipticAngles            – blocked: needs CoHDS + HyperIdealGenerator
-
-#include <gtest/gtest.h>
-
-TEST(HyperIdealHyperellipticUtilityTest, CalculateCircleIntersections) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HalfEdgeUtils)";
-}
-
-TEST(HyperIdealHyperellipticUtilityTest, CalculateCircleIntersectionsInfinite) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HalfEdgeUtils)";
-}
-
-TEST(HyperIdealHyperellipticUtilityTest, LawsonHyperellipticAngles) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + HyperIdealGenerator)";
-}

code/tests/test_spherical_functional.cpp

@@ -1,37 +0,0 @@
-// Stub for de.varylab.discreteconformal.functional.SphericalFunctionalTest (Java/JUnit).
-//
-// STATUS: BLOCKED – requires HDS port (Phase 4).
-//
-// Tests evaluate gradient and Hessian of the SphericalFunctional on meshes
-// built via CoHDS + ConvexHull, and check that a regular spherical metric
-// is a critical point of the functional.  All tests require the HalfEdge
-// data structure and the functional evaluation framework in C++.
-//
-// Java tests and their status:
-//   testReducedGradient   – blocked: needs CoHDS + SphericalFunctional
-//   testReducedHessian    – blocked: needs CoHDS + SphericalFunctional
-//   testGradient          – blocked: needs CoHDS + SphericalFunctional
-//   testHessian           – blocked: needs CoHDS + SphericalFunctional
-//   testCriticalPoint     – blocked: needs CoHDS + ConvexHull + SphericalFunctional
-
-#include <gtest/gtest.h>
-
-TEST(SphericalFunctionalTest, ReducedGradient) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + SphericalFunctional)";
-}
-
-TEST(SphericalFunctionalTest, ReducedHessian) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + SphericalFunctional)";
-}
-
-TEST(SphericalFunctionalTest, Gradient) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + SphericalFunctional)";
-}
-
-TEST(SphericalFunctionalTest, Hessian) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + SphericalFunctional)";
-}
-
-TEST(SphericalFunctionalTest, CriticalPoint) {
-    GTEST_SKIP() << "Blocked: requires HDS port (CoHDS + ConvexHull + SphericalFunctional)";
-}

doc/api/cgal-package.md

@@ -1,77 +1,211 @@
 # Phase 8 — CGAL Package Design
 
-> **Status: planned.** This document describes the target architecture for Phase 8.
-> No code has been written yet. The design is informed by the CGAL package submission
-> guidelines at https://www.cgal.org/developers.html
+> **Status: design frozen, implementation planned.**
+> This document captures the strategic decisions taken before the first
+> line of Phase 8 code is written.  The decisions were taken on 2026-05-19
+> after the docstring/architecture audit at the end of Phase 7.
+>
+> The design is informed by the CGAL package submission guidelines at
+> https://www.cgal.org/developers.html and by reading the existing
+> `Polygon_mesh_processing` and `Surface_mesh_parameterization` packages.
 
 ---
 
-## Goal
+## Strategic position
 
-Integrate conformallab++ into the CGAL library as a proper CGAL package:
-`Discrete_conformal_map`. The package must satisfy all CGAL submission requirements:
-traits-class design, Doxygen documentation, CGAL-format test suite, and coverage of
-the CGAL coding conventions.
+| Question | Decision | Rationale |
+|---|---|---|
+| Submission to CGAL? | **Pre-submission-ready, not submission-bound.** 12+ months horizon, optional. | Keep design freedom, no editor-review pressure. Structure is valuable on its own. |
+| License | **MIT preserved.** | CGAL submission would require LGPL — deferred. Current users (academic + industrial) profit from MIT. |
+| Mesh-type flexibility | **Generic `FaceGraph + HalfedgeGraph`.** | Maximum CGAL value: works with `Surface_mesh`, `Polyhedron_3`, OpenMesh-adapter, pmp. |
+| Parameter style | **Named Parameters** (`CGAL::parameters::vertex_curvature_map(...).max_iterations(50)`). | CGAL standard; identical UX to `PMP::triangulate_*`. |
+| Default kernel | **`CGAL::Simple_cartesian<double>`.** | Status quo. Conformal geometry does not require exact predicates. |
+| Backward compatibility | **Dual-layer wrapper.** `code/include/*.hpp` stays as implementation; `include/CGAL/*.h` is thin wrapper. | Existing 176 + 36 tests unchanged. New API gets new tests. |
+| Algorithm code | **No duplication.** New CGAL headers delegate to existing code via property-map adapters. | Single source of truth; no parallel maintenance. |
+
+---
+
+## Architecture
+
+### Three-layer model
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  Layer 3: Public CGAL API           include/CGAL/*.h              │
+│  ─────────────────────────                                         │
+│  • Conformal_map_traits.h           ← concept + default model     │
+│  • Discrete_conformal_map.h         ← user-facing entry           │
+│  • Conformal_layout.h, ...                                         │
+│  Named parameters, generic over FaceGraph, Doxygen-documented.     │
+└──────────────────────────────────────────────────────────────────┘
+                              ▲
+                              │ thin wrapper, no algorithm code
+                              │
+┌──────────────────────────────────────────────────────────────────┐
+│  Layer 2: Adapter / Traits          include/CGAL/Conformal_map/   │
+│  ─────────────────────────                                         │
+│  • Default_traits.h                 ← maps generic FaceGraph to   │
+│                                       Surface_mesh property maps  │
+│  • Property_map_adapter.h           ← read/write u, θ, α via      │
+│                                       boost::property_map traits  │
+└──────────────────────────────────────────────────────────────────┘
+                              ▲
+                              │ uses existing algorithms as-is
+                              │
+┌──────────────────────────────────────────────────────────────────┐
+│  Layer 1: Implementation            code/include/*.hpp            │
+│  ─────────────────────────                                         │
+│  euclidean_functional.hpp, layout.hpp, newton_solver.hpp, ...     │
+│  Hardcoded to Surface_mesh + Simple_cartesian — unchanged.        │
+└──────────────────────────────────────────────────────────────────┘
+```
 
 ---
 
 ## 8a — Traits class & concepts
 
-The current code is tightly coupled to `CGAL::Surface_mesh<Point3>`. Phase 8a introduces
-a traits class that separates the mesh type from the algorithm:
+### `ConformalMapTraits` concept
+
+The concept lists the types and operations every Traits model must provide.
 
 ```cpp
-// TODO(Phase 8a): implement this header
-// include/CGAL/Conformal_map_traits.h
+namespace CGAL {
 
-template<
-    typename MeshType,      // any CGAL halfedge mesh
-    typename KernelType,    // CGAL kernel
-    typename ScalarType = double
->
-struct Conformal_map_traits {
-    using Mesh   = MeshType;
-    using Kernel = KernelType;
-    using FT     = ScalarType;
-    // ... vertex/edge/face descriptor types
-    // ... property map access
+// Concept (documentation only; no code):
+struct ConformalMapTraits {
+    // Types
+    using Triangle_mesh = ...;            // model of FaceGraph + HalfedgeGraph
+    using FT            = ...;            // typically double
+    using Vertex_descriptor = boost::graph_traits<Triangle_mesh>::vertex_descriptor;
+    using Halfedge_descriptor = ...;
+    using Face_descriptor    = ...;
+
+    // Read access (input geometry)
+    using Vertex_point_map = ...;         // model of ReadablePropertyMap
+                                           //   key:   Vertex_descriptor
+                                           //   value: K::Point_3
+
+    // Read/write access (conformal data)
+    using Lambda_pmap       = ...;        // u_v   (scale factor)         RW
+    using Theta_pmap        = ...;        // Θ_v   (target curvature)     R
+    using Vertex_index_pmap = ...;        // DOF index (−1 = pinned)      RW
+    using Edge_alpha_pmap   = ...;        // α_e   (hyperbolic only)      RW
+    using Face_type_pmap    = ...;        // geometry tag per face        R
+
+    // Optional output
+    using UV_pmap           = ...;        // halfedge → (u, v) ∈ ℝ²       W
+    using Holonomy_pmap     = ...;        // seam edge → ω ∈ ℂ            W
+};
+
+}
+```
+
+### `Default_conformal_map_traits<TM>`
+
+The default model wraps `Surface_mesh` property maps so existing code keeps
+working through the new public API.
+
+```cpp
+template <class TriangleMesh,
+          class K = CGAL::Simple_cartesian<double>>
+struct Default_conformal_map_traits;
+
+// Specialisation for Surface_mesh:
+template <class K>
+struct Default_conformal_map_traits<CGAL::Surface_mesh<typename K::Point_3>, K> {
+    using Triangle_mesh    = CGAL::Surface_mesh<typename K::Point_3>;
+    using FT               = typename K::FT;
+    using Vertex_point_map = typename Triangle_mesh::Point_property_map;
+    using Lambda_pmap      = typename Triangle_mesh::template Property_map<vertex_descriptor, FT>;
+    // ... etc, using "conformal:lambda" property names
+};
+
+// Generic specialisation for other FaceGraph models will be added in 8a.2.
+```
+
+### Concept-checks
+
+```cpp
+// include/CGAL/Conformal_map_concept_checks.h
+template <class Traits>
+struct Conformal_map_traits_check {
+    static_assert(boost::is_same<...>::value, "Traits::FT must be a floating-point type");
+    static_assert(is_face_graph<Traits::Triangle_mesh>::value);
+    // ...
 };
 ```
 
-Concept checks will ensure any user-provided mesh satisfies the halfedge mesh concept.
-
 ---
 
-## 8b — Public header hierarchy
+## 8b — Public CGAL header hierarchy
 
-A clean public API separate from the internal implementation:
+### User-facing entry
+
+```cpp
+// include/CGAL/Discrete_conformal_map.h
+namespace CGAL {
+
+template <class TriangleMesh, class NamedParameters = parameters::Default_named_parameters>
+bool discrete_conformal_map_euclidean(TriangleMesh& mesh,
+                                       const NamedParameters& np = parameters::default_values());
+
+template <class TriangleMesh, class NamedParameters = ...>
+bool discrete_conformal_map_spherical(TriangleMesh& mesh,
+                                       const NamedParameters& np = ...);
+
+template <class TriangleMesh, class NamedParameters = ...>
+bool discrete_conformal_map_hyperbolic(TriangleMesh& mesh,
+                                        const NamedParameters& np = ...);
+
+} // namespace CGAL
+```
+
+### Named parameter vocabulary
+
+| Parameter | Type | Default | Meaning |
+|---|---|---|---|
+| `vertex_curvature_map(pmap)` | ReadablePropertyMap | `2π` at interior, `π` at boundary | Θᵥ values |
+| `fixed_vertex_pmap(pmap)` | ReadablePropertyMap<bool> | First vertex pinned | Which vertices are pinned (gauge) |
+| `max_iterations(n)` | int | 200 | Newton iteration limit |
+| `gradient_tolerance(eps)` | FT | 1e-10 | `‖G‖∞` threshold |
+| `vertex_index_map(pmap)` | LvaluePropertyMap | DOF auto-assigned | Allows user to override DOF assignment |
+| `output_uv_map(pmap)` | WritablePropertyMap | none | If set, writes UV layout into pmap |
+| `cut_graph(cg)` | `Conformal_cut_graph` | auto-computed | Pre-computed seam edges (mandatory for closed surfaces) |
+| `geom_traits(t)` | model of ConformalMapTraits | `Default_*` | Custom traits |
+
+### Modular headers
 
 ```
 include/CGAL/
-  Discrete_conformal_map.h        ← single user-facing include
-  Conformal_map_traits.h
-  Conformal_newton_solver.h
-  Conformal_layout.h
-  Conformal_cut_graph.h
-  conformal_map_package.h         ← PackageDescription
+├── Discrete_conformal_map.h          ← user-facing entry (1 include for casual use)
+├── Conformal_map_traits.h            ← concept + Default_conformal_map_traits
+├── Conformal_map_concept_checks.h
+├── Conformal_newton_solver.h         ← standalone Newton (advanced users)
+├── Conformal_layout.h                ← layout + holonomy
+├── Conformal_cut_graph.h             ← orthogonal algorithm
+├── Conformal_period_matrix.h         ← genus-1 τ (conformallab++ unique)
+├── Conformal_holonomy.h              ← Möbius holonomy (conformallab++ unique)
+└── Conformal_map/                    ← CGAL convention: implementation details
+    ├── Default_traits.h
+    ├── Property_map_adapter.h
+    ├── Newton_iteration.h
+    └── Internal_helpers.h
 ```
 
-All existing `include/*.hpp` headers remain as internal implementation details,
-not part of the public CGAL API.
-
 ---
 
 ## 8c — CGAL-style documentation
 
 ```
 doc/Conformal_map/
-  PackageDescription.txt
-  User_manual.md
-  Reference_manual.md
-  fig/                            ← pipeline diagrams, mathematical figures
+├── PackageDescription.txt            ← CGAL Doxygen package file
+├── Conformal_map.txt                 ← Doxygen User_manual
+├── examples.txt                      ← linkable example code
+├── dependencies                       ← textual list
+└── fig/                              ← pipeline diagrams, math figures
 ```
 
-All public functions and concepts require Doxygen comments following the CGAL style.
+All public functions, concepts, and types require Doxygen.  See **Phase 7.5** (below).
 
 ---
 
@@ -79,88 +213,191 @@ All public functions and concepts require Doxygen comments following the CGAL st
 
 ```
 test/Conformal_map/
-  CMakeLists.txt                  ← CGAL-format, uses find_package(CGAL)
-  test_euclidean_functional.cpp
-  test_newton_solver.cpp
-  ...
+├── CMakeLists.txt                    ← CGAL-format, uses find_package(CGAL)
+├── test_euclidean_traits.cpp         ← traits concept checks
+├── test_polyhedron_3_backend.cpp     ← tests with Polyhedron_3 as mesh
+├── test_named_parameters.cpp
+└── data/                             ← test meshes
 ```
 
-The existing GTest suite remains. CGAL-format tests are added alongside as a separate
-target, following the CGAL test infrastructure conventions.
+The existing GTest suite at `code/tests/cgal/` remains; CGAL-format tests are
+added alongside as a separate target.  CI runs both.
 
 ---
 
 ## 8e — Declarative YAML pipeline
 
-A lightweight YAML format for reproducible experiments. The CLI accepts
+A lightweight YAML format for reproducible experiments.  CLI accepts
 `--pipeline experiment.yml`; the validator checks `require`/`provide` tokens
 before execution.
 
-**Full concept & design specification:** [doc/concepts/declarative-pipeline.md](../concepts/declarative-pipeline.md)
-— token vocabulary, validation algorithm, 5 complete examples, implementation plan.
-
-Abbreviated example:
+**Full spec:** [doc/concepts/declarative-pipeline.md](../concepts/declarative-pipeline.md)
+— token vocabulary, validation algorithm, 5 complete examples.
 
 ```yaml
 pipeline:
   name: flat_torus_period
   geometry: euclidean
-
-  input:
-    source: data/torus.off
-
+  input:  { source: data/torus.off }
   steps:
-    - id: setup
-      unit: setup_euclidean_maps
-      provide: [maps_initialised]
-
-    - id: gauss_bonnet
-      unit: enforce_gauss_bonnet
-      require: [maps_initialised]
-      provide: [gauss_bonnet_satisfied]
-
-    - id: solve
-      unit: newton_euclidean
-      require: [gauss_bonnet_satisfied]
-      params:
-        tol: 1.0e-10
-        max_iter: 200
-      provide: [x_converged]
-
-    - id: cut
-      unit: compute_cut_graph
-      require: [mesh_closed]
-      provide: [cut_graph]
-
-    - id: layout
-      unit: euclidean_layout
-      require: [x_converged, cut_graph]
-      params:
-        normalise: true
-      provide: [layout_uv, holonomy]
-
-    - id: period
-      unit: compute_period_matrix
-      require: [holonomy]
-      provide: [tau]
-
+    - { id: setup,  unit: setup_euclidean_maps,        provide: [maps_initialised] }
+    - { id: gb,     unit: enforce_gauss_bonnet,        require: [maps_initialised], provide: [gauss_bonnet_satisfied] }
+    - { id: solve,  unit: newton_euclidean,            require: [gauss_bonnet_satisfied], provide: [x_converged] }
+    - { id: cut,    unit: compute_cut_graph,           require: [mesh_closed],            provide: [cut_graph] }
+    - { id: layout, unit: euclidean_layout,            require: [x_converged, cut_graph], provide: [layout_uv, holonomy] }
+    - { id: period, unit: compute_period_matrix,       require: [holonomy],               provide: [tau] }
   output:
     layout: out/torus_layout.off
     json:   out/torus_result.json
-    tau:    out/torus_tau.txt
 ```
 
-The contract table in [contracts.md](contracts.md) defines the valid `require`/`provide`
-token vocabulary.
-
 ---
 
-## TODO
+## Phase 7.5 — Doxygen infrastructure (prerequisite)
 
-- [ ] Design `Conformal_map_traits.h` interface (8a)
-- [ ] Define concept requirements for `MeshType` (8a)
-- [ ] Create `include/CGAL/` header skeleton (8b)
-- [ ] Write `PackageDescription.txt` (8c)
-- [ ] Port GTest tests to CGAL format (8d)
-- [ ] Implement YAML validator (8e)
-- [ ] CLI: `--pipeline` flag (8e)
+Before any Phase 8 code, the existing API surface must be extractable.
+This is the prerequisite that bridges Phase 7 → Phase 8.
+
+```
+Phase 7.5 — Doxygen infrastructure
+──────────────────────────────────
+  • Doxyfile (CGAL-conform: INPUT=code/include + include/CGAL,
+    EXCLUDE_PATTERNS="* 2.hpp")
+  • doxygen-awesome-css as theme (matches CGAL house style)
+  • CMake target:  cmake --build build --target doc
+  • CI job:  doc-build → publishes to Codeberg Pages or gitea-pages
+  • Extract baseline once → snapshot what is actually exported today
+  • Top-5 central headers (3 functional + conformal_mesh + layout)
+    upgraded to Doxygen comments; the rest follows during Phase 8 implementation
+```
+
+The baseline snapshot doubles as the API-design review tool: before designing
+the public CGAL wrapper, we see exactly which functions, classes and free
+operators exist and need to be wrapped or hidden.
+
+---
+
+## Validation criteria
+
+Phase 8a is "done" when:
+
+1. `cgal.ConformalTraits.Polyhedron_3_works` passes.
+2. `cgal.ConformalTraits.Surface_mesh_default_works` passes — identical results to the legacy API.
+3. The Inversive-Distance functional (Phase 9a) is implementable as the *first* new client of the traits API without architectural changes — no breaking changes to the trait concept.
+4. A user can write `#include <CGAL/Discrete_conformal_map.h>` and call `discrete_conformal_map_euclidean(mesh, parameters::vertex_curvature_map(theta))` against a `Polyhedron_3` and get a valid layout.
+
+If any of these fail, the design is iterated before continuing.
+
+---
+
+## Implementation strategy — "Hybrid MVP" (decided 2026-05-19)
+
+After cost/benefit re-evaluation, the plan is **not** to build Phase 8 in full
+before resuming the port.  Instead:
+
+```
+┌────────────────────────────────────────────────────────────────────┐
+│  PHASE 8 MVP (3–5 days)                                            │
+│  ─────────────────────                                              │
+│  Just enough CGAL-style architecture for Phase 9a to validate it.  │
+│                                                                     │
+│  • Conformal_map_traits.h        concept + Default<Surface_mesh,K> │
+│  • Discrete_conformal_map.h      ONE entry: _euclidean()           │
+│  • 4 named parameters            Θ-map, max_iter, tol, pin         │
+│  • Concept-check header                                             │
+│  • Doxygen on these 3 headers                                       │
+└────────────────────────────────────────────────────────────────────┘
+                                ▼
+┌────────────────────────────────────────────────────────────────────┐
+│  PHASE 9a — Inversive-Distance (3–5 days)                          │
+│  ──────────────────────────────────                                 │
+│  Built directly against the new traits API.  This is the           │
+│  acceptance test for the MVP.                                       │
+│                                                                     │
+│  If painless  → MVP design is sound, continue with Phase 9b/9c     │
+│  If painful   → iterate the traits design before going further     │
+└────────────────────────────────────────────────────────────────────┘
+                                ▼
+┌────────────────────────────────────────────────────────────────────┐
+│  PHASE 9b — Analytic HyperIdeal Hessian (1 week)                   │
+│  PHASE 9c — 4g-polygon fundamental domain (1 week)                  │
+│  ────────────────────────────────────────                           │
+│  Port really finished. v0.9.0 release possible.                     │
+└────────────────────────────────────────────────────────────────────┘
+                                ▼
+┌────────────────────────────────────────────────────────────────────┐
+│  PHASE 8 EXTENSIONS — only on demand                                │
+│  ─────────────────────────────────                                   │
+│  • 8a.2 generic FaceGraph specialisation     when Polyhedron_3 user │
+│  • 8b extend to spherical + hyperbolic       when 9a pattern proven │
+│  • 8c full User_manual + Reference_manual    when submission planned│
+│  • 8d CGAL-format test directory             when submission planned│
+│  • 8e YAML pipeline + CLI flag               orthogonal, any time   │
+│                                                                     │
+│  Each extension only when there is a concrete trigger.  No          │
+│  speculative architecture for a hypothetical CGAL submission.       │
+└────────────────────────────────────────────────────────────────────┘
+```
+
+**Why this order?**
+
+- Port-completion (Phase 9) is the higher-confidence value: well-defined,
+  ~3 weeks of work, finishes Goal A.
+- Full Phase 8 (3–4 weeks) speculative — only pays off if CGAL submission
+  actually happens, which is uncertain.
+- Phase 8 MVP captures the architectural insight (traits + named params)
+  without the long tail.  If the rest of Phase 8 is ever wanted, it's
+  additive — nothing built in the MVP needs to be thrown away.
+
+**Total committed budget: 2 weeks (MVP + 9a) + 2 weeks (9b + 9c) = ~4 weeks
+net work, 6–8 weeks calendar.**  After that, the port is finished.
+
+## Phase 8 MVP scope — what is and isn't in the first cut
+
+| Item | MVP | Later | Reason |
+|---|:---:|:---:|---|
+| `Conformal_map_traits.h` concept | ✅ | — | Core abstraction |
+| `Default_conformal_map_traits<Surface_mesh, K>` | ✅ | — | Status-quo wrapper |
+| Generic `FaceGraph` specialisation | — | ✅ 8a.2 | Speculative until asked |
+| `Discrete_conformal_map.h` — `_euclidean()` | ✅ | — | First entry function |
+| `Discrete_conformal_map.h` — `_spherical()`, `_hyperbolic()` | — | ✅ 8b.2 | Pattern-replicates once 9a works |
+| Named parameters: `vertex_curvature_map`, `max_iterations`, `gradient_tolerance`, `fixed_vertex_pmap` | ✅ | — | Essential 4 |
+| Named parameters: rest (`output_uv_map`, `cut_graph`, …) | — | ✅ 8b.2 | Additive |
+| Doxygen on MVP headers | ✅ | — | Same time anyway |
+| Doxygen on legacy `code/include/*` | partial | ✅ 8c | Bulk later |
+| `PackageDescription.txt` | — | ✅ 8c | Only if submitting |
+| User_manual.md | — | ✅ 8c | Only if submitting |
+| `test/Conformal_map/` CGAL-style | — | ✅ 8d | Only if submitting |
+| YAML pipeline + CLI flag | — | ✅ 8e | Orthogonal, any time |
+
+---
+
+## TODO checklist
+
+### MVP track (committed work, ~4 weeks)
+- [x] Phase 7.5: Doxyfile + CMake doc target + duplicate cleanup
+- [ ] **Phase 8 MVP — Traits + one wrapper**
+  - [ ] `Conformal_map_traits.h` — concept documentation
+  - [ ] `Default_conformal_map_traits<Surface_mesh, K>`
+  - [ ] `Conformal_map_concept_checks.h`
+  - [ ] `Discrete_conformal_map.h` with `_euclidean()` only
+  - [ ] 4 named parameters: Θ-map, max_iter, tol, pin
+  - [ ] Test: `cgal.ConformalTraits.Surface_mesh_default_works`
+- [ ] **Phase 9a — Inversive-Distance (acceptance test for MVP)**
+  - [ ] `inversive_distance_functional.hpp` against new traits
+  - [ ] Gradient check + Newton convergence tests
+  - [ ] Doxygen on new headers
+- [ ] **Phase 9b — Analytic HyperIdeal Hessian**
+  - [ ] Replace FD in `hyper_ideal_hessian.hpp`
+  - [ ] Symmetry + PSD checks unchanged
+- [ ] **Phase 9c — 4g-polygon for genus g > 1**
+  - [ ] Extend `compute_fundamental_domain()` beyond genus 1
+
+### On-demand track (only with concrete trigger)
+- [ ] 8a.2: Generic `FaceGraph` specialisation (trigger: Polyhedron_3 user)
+- [ ] 8b.2: `_spherical()` + `_hyperbolic()` entry functions (trigger: pattern proven)
+- [ ] 8b.2: `Conformal_layout.h`, `Conformal_cut_graph.h` wrappers
+- [ ] 8c: `doc/Conformal_map/PackageDescription.txt` (trigger: submission planned)
+- [ ] 8c: User_manual + Reference_manual (trigger: submission planned)
+- [ ] 8d: `test/Conformal_map/` CGAL-style tests (trigger: submission planned)
+- [ ] 8e: YAML validator + CLI `--pipeline` flag (orthogonal, any time)

doc/api/tests.md

@@ -14,7 +14,7 @@ Pure-math tests, only Eigen required. Covers Java utilities ported in Phase 1–
 | `test_p2_utility.cpp` | P2 projective utilities |
 | `test_hyper_ideal_visualization_utility.cpp` | Poincaré disk projection, circumcircle |
 
-**Total: 36 tests, 0 skipped.**
+**Total: 23 tests, 0 skipped.**
 
 ---
 
@@ -29,17 +29,17 @@ All tests have CTest prefix `cgal.` (set via `TEST_PREFIX "cgal."` in CMakeLists
 | `ConformalMeshProperties` | `test_conformal_mesh.cpp` | 5 | Property maps (λ, θ, idx, α, geometry type) |
 | `ConformalMeshValidity` | `test_conformal_mesh.cpp` | 1 | CGAL validity for all factory meshes |
 | `HyperIdealFunctional` | `test_hyper_ideal_functional.cpp` | 7 | FD gradient checks + Hessian symmetry |
-| `SphericalFunctional` | `test_spherical_functional.cpp` | 12 | Angle formula + gradient + gauge-fix |
-| `EuclideanFunctional` | `test_euclidean_functional.cpp` | 11 | Angle formula + gradient |
+| `SphericalFunctional` | `test_spherical_functional.cpp` | 12 | Angle formula + gradient + gauge-fix + cross-module Hessian check |
+| `EuclideanFunctional` | `test_euclidean_functional.cpp` | 12 | Angle formula + gradient + cross-module Hessian check |
 | `EuclideanHessian` | `test_euclidean_hessian.cpp` | 9 | Cotangent Laplacian structure, FD agreement, PSD, null space |
 | `SphericalHessian` | `test_spherical_hessian.cpp` | 8 | Derivative correctness, NSD at equilibrium |
 | `NewtonSolver` | `test_newton_solver.cpp` | 11 | Convergence: Euclidean ×3, Spherical ×4, HyperIdeal ×4 |
 | `SparseQRFallback` | `test_newton_solver.cpp` | 3 | Full-rank LDLT · singular matrix → QR · closed mesh gauge mode |
-| `MeshIO` | `test_mesh_io.cpp` | 9 | OFF/OBJ round-trips, error handling |
+| `MeshIO` | `test_mesh_io.cpp` | 6 | OFF/OBJ round-trips, error handling |
 | `Pipeline` | `test_pipeline.cpp` | 5 | End-to-end: build → setup → solve → export → reload |
-| `Layout` | `test_layout.cpp` | 8 | Edge-length preservation (Eucl./Spher.), Poincaré disk layout |
+| `Layout` | `test_layout.cpp` | 6 | Edge-length preservation (Eucl./Spher.), Poincaré disk layout |
 | `Serialization` | `test_layout.cpp` | 2 | JSON and XML round-trips (DOF vector + layout UVs) |
-| `GaussBonnet` | `test_phase6.cpp` | 8 | χ, genus, sum/RHS, deficit, check, enforce |
+| `GaussBonnet` | `test_phase6.cpp` | 12 | χ, genus, sum/RHS, deficit, check, enforce |
 | `CutGraph` | `test_phase6.cpp` | 6 | Tree-cotree, open/closed meshes, flag–index consistency |
 | `HyperbolicTrilateration` | `test_phase6.cpp` | 4 | Möbius + law of cosines: exact distances, disk interior, off-origin |
 | `Normalisation` | `test_phase6.cpp` | 4 | Euclidean centroid, length ratios, Möbius centring |
@@ -51,16 +51,15 @@ All tests have CTest prefix `cgal.` (set via `TEST_PREFIX "cgal."` in CMakeLists
 | `PeriodMatrix` | `test_phase7.cpp` | 7 | τ ∈ ℍ, SL(2,ℤ) reduction, exception outside ℍ |
 | `FundamentalDomain` | `test_phase7.cpp` | 7 | Genus-1 parallelogram CCW, generators, g > 1 empty |
 | `TilingCopy/Neighbourhood` | `test_phase7.cpp` | 4 | Translation correct, tile count |
-| `CuttingUtility` | `test_geometry_utils.cpp` | 3 | point_in_triangle_2d: false, true, unit triangle (Java CuttinUtilityTest) |
-| `UnwrapUtility` | `test_geometry_utils.cpp` | 2 | corner angle: collinear → π, equilateral → π/3 (Java UnwrapUtilityTest) |
-| `ConvergenceUtility` | `test_geometry_utils.cpp` | 6 | circumradius + scale-invariant R_f/√A (Java ConvergenceUtilityTests) |
-| `HomologyGenerators` | `test_geometry_utils.cpp` | 1 | GTEST_SKIP stub — genus-2 mesh missing (Java HomologyTest Test 7, Phase 9c) |
+| `CuttingUtility` | `test_geometry_utils.cpp` | 3 | `point_in_triangle_2d`: false, true, unit triangle (Java CuttingUtilityTest) |
+| `UnwrapUtility` | `test_geometry_utils.cpp` | 2 | Corner angle: collinear → π, equilateral → π/3 (Java UnwrapUtilityTest) |
+| `ConvergenceUtility` | `test_geometry_utils.cpp` | 6 | Circumradius + scale-invariant R_f/√A (Java ConvergenceUtilityTests) |
+| `EuclideanLayout` | `test_geometry_utils.cpp` | 2 | Euclidean layout round-trip edge lengths |
+| `SphericalLayout` | `test_geometry_utils.cpp` | 1 | Spherical layout on unit sphere |
+| `HomologyGenerators` | `test_geometry_utils.cpp` | 1 | Genus-2 cut graph: χ = −2, 4 cut edges (`brezel2.obj`) |
+| `SmokeEuclidean` | `test_scalability_smoke.cpp` | 3 | Smoke tests on real meshes: CatHead (open), Brezel genus-1, Brezel2 genus-2 |
 
-**Total: 170 tests, 1 intentional skip.**
-
-The skip is `HomologyGenerators.Genus2_FourGeneratorPaths_BLOCKED` — blocked until
-a genus-2 mesh is available (Phase 9c).  It corresponds to a Java `@Ignore`-annotated
-test in the original library.
+**Total: 227 tests, 0 skipped.**
 
 ---
 

doc/architecture/phase-9a-validation.md

@@ -0,0 +1,228 @@
+# Phase 9a Validation Report
+
+This document records the mathematical and code-level validation of the two
+Phase 9a functionals against their reference sources.  It is produced as
+part of the Phase 9a acceptance procedure (decided 2026-05-19).
+
+| Functional | Reference | Java original | Lines |
+|---|---|---|---|
+| 9a.1 `cp_euclidean_functional.hpp` | Bobenko-Pinkall-Springborn 2010 | `CPEuclideanFunctional.java` (260) | 320 |
+| 9a.2 `inversive_distance_functional.hpp` | Luo 2004 + Glickenstein 2011 | none | 290 |
+
+---
+
+## 1.  CP-Euclidean (9a.1) — line-by-line Java mapping
+
+Reference file: `/Users/tarikmoussa/Desktop/conformallab/src/de/varylab/discreteconformal/functional/CPEuclideanFunctional.java`
+
+| Java line(s) | Java construct | C++ counterpart | Status |
+|---:|---|---|:---:|
+| 55–58 | `public class CPEuclideanFunctional<V,E,F>` | `namespace conformallab` (header-only, monomorphic on `ConformalMesh`) | ✓ |
+| 61–69 | `thetaMap, phiMap` ctor args | `CPEuclideanMaps { f_idx, theta_e, phi_f }` struct | ✓ |
+| 95–97 | `getDimension = hds.numFaces()` (incl. face 0) | `cp_euclidean_dimension(mesh, m)` counts only `f_idx ≥ 0` | refined |
+| 103–123 | `getNonZeroPattern` returns face-to-face adjacency | implicit in `cp_euclidean_hessian` triplet construction | ✓ |
+| 135–165 | `evaluateHessian` — interior edge `h_jk = sin θ / (cosh Δρ − cos θ)` | `cp_euclidean_hessian()` lines 224-247 | ✓ |
+| 146–151 | "skip if k == 0 / j == 0" gauge fix | `if (j >= 0)` / `if (k >= 0)` guard in triplet emission | equivalent |
+| 178–193 | per-face term `+φ_f · ρ_f` to energy and gradient | `cp_euclidean_energy/gradient` loop over faces | ✓ |
+| 196–232 | per-(directed)-edge term: boundary or interior branch | `cp_euclidean_energy/gradient` halfedge loop with `mesh.is_border(opposite)` check | ✓ |
+| 224–227 | `E += ½ p Δρ + Λ(θ*+p) − θ* ρ_left` | identical formula via `clausen2()` | ✓ |
+| 230 | `grad[left] -= p + θ*` | identical | ✓ |
+| 243–247 | `p(θ*, Δρ) = 2 atan(tan(θ*/2) tanh(Δρ/2))` | `cp_detail::p_function` | ✓ |
+
+### 1.1  Gauge convention divergence
+
+The Java code uses "face index 0 is pinned" as an implicit convention:
+hard-coded `if (face.getIndex() == 0)` short-circuits scatter throughout.
+The C++ port keeps the gauge user-selectable via
+`assign_cp_euclidean_face_dof_indices(mesh, m, pinned_face)`.  The default
+convenience overload picks the first face in iteration order, matching the
+Java behaviour for any mesh whose face 0 is the first iterated face.
+
+### 1.2  Test parity
+
+| Java test                                              | C++ test                                                 | Reproduces what |
+|---|---|---|
+| `init()` lines 53-86 dodecahedron-minus-face setup     | `make_open_tetrahedron()` (3 faces, 3 bdy edges)         | open-mesh boundary code path |
+| `setXGradient(rho)` (base class FunctionalTest)        | `FDGradientCheck_ClosedTetrahedron_RandomRho`            | FD-vs-analytic gradient |
+| `setXHessian(rho)`  (base class FunctionalTest)        | `FDHessianCheck_ClosedTetrahedron_RandomRho`             | FD-vs-analytic Hessian |
+| (none — implicit from FunctionalTest convexity check) | `HessianIsPSD`                                           | BPS-2010 §6 convexity |
+| (none)                                                 | `TangentialLimitGradientEqualsPhi`                       | θ=0 analytic check |
+| (none)                                                 | `PFunctionKnownValues`, `NaturalPhiMakesZeroTheEquilibrium` | helper-function unit tests |
+
+All Java tests reproduced; C++ adds 4 mathematical-property tests
+(PSD, tangential limit, p-function unit, natural-φ equilibrium).
+
+### 1.3  Numerical equivalence — seed-1 random ρ, FD gradient
+
+Java `FunctionalTest` uses `Random(1)` + uniform `[-0.5, +0.5]`.
+C++ uses `std::mt19937(1)` + `uniform_real_distribution<double>(-0.5, 0.5)`.
+The two RNG streams differ; numerical equivalence is therefore tested via
+the *property* "FD matches analytic to 1e-6 absolute" rather than via
+identical numerical traces.  Both implementations satisfy this property.
+
+---
+
+## 2.  Inversive Distance (9a.2) — line-by-line literature mapping
+
+No Java original exists.  The implementation derives directly from three
+published papers; each formula in the header is annotated with its source
+line in the paper.
+
+### 2.1  Edge-length formula  (Luo 2004 §3 / Glickenstein 2011 eq. 2.1)
+
+```
+ℓ_ij(u)²  =  exp(2 u_i) + exp(2 u_j) + 2 I_ij exp(u_i + u_j)
+          =  r_i² + r_j² + 2 I_ij r_i r_j
+```
+
+Implementation: `id_detail::edge_length_squared` (lines 130-138 of
+`inversive_distance_functional.hpp`).
+
+Tested at three special-case limits in
+`test_inversive_distance_functional.cpp` §1:
+
+| Inversive distance | Geometric meaning           | Closed-form ℓ        | Test |
+|:---:|---|---|---|
+| `I = +1` | tangential circles           | `r_i + r_j`         | `EdgeLengthFormula_TangentialLimit` |
+| `I = 0`  | orthogonal circles           | `√(r_i² + r_j²)`    | `EdgeLengthFormula_OrthogonalLimit` |
+| `I = −1` | inside-tangent / inverted    | `|r_i − r_j|`       | `EdgeLengthFormula_InsideTangentLimit` |
+| `I < −1` | impossible packing (no real ℓ) | `nan`/signal         | `EdgeLengthFormula_DegenerateReturnsMinusOne` |
+
+### 2.2  Bowers-Stephenson identity (Bowers-Stephenson 2004)
+
+```
+I_ij  =  ( ℓ_ij² − r_i² − r_j² )  /  ( 2 r_i r_j )
+```
+
+Implementation: `compute_inversive_distance_init_from_mesh` lines 152-172.
+The round-trip property — given (ℓ_3d, r0_i, r0_j) recover ℓ via the Luo
+formula — is tested in `BowersStephensonRoundTrip`.
+
+### 2.3  Gradient (Luo 2004 Lemma 3.1)
+
+```
+∂E/∂u_v  =  Θ_v  −  Σ_{T ∋ v}  α_v(T)
+```
+
+Implementation: `inversive_distance_gradient` lines 191-241.  This is
+structurally identical to the Euclidean functional (same halfedge
+convention, same `euclidean_angles()` law-of-cosines reused).  The only
+difference is the edge-length input: Luo's `ℓ²(I)` instead of Springborn's
+`exp(λ° + u_i + u_j)`.
+
+### 2.4  Energy — Luo's closed 1-form
+
+Luo (2004) proves the gradient 1-form `ω = Σ_v (Θ_v − Σ α_v) du_v` is
+closed on the open domain where every triangle is valid.  Hence the energy
+exists as a path integral.  No general closed-form expression is known
+(Glickenstein 2011 surveys partial results).  The implementation uses the
+same 10-point Gauss-Legendre quadrature as `euclidean_functional.hpp`
+(lines 243-274).
+
+This shared-quadrature choice keeps both functionals identical in the
+energy-evaluation cost and the FD-gradient validation pattern.
+
+### 2.5  Hessian — finite difference for now
+
+Glickenstein 2011 eq. (4.6) gives an analytic Hessian for the inversive-
+distance variational principle, but is more involved than the Springborn
+cot-Laplacian.  For MVP we rely on FD; the analytic form is a future
+optimisation (joining the Phase 9b roadmap for HyperIdeal as a sibling
+optimisation task).
+
+---
+
+## 3.  Cross-validation between 9a.1 and 9a.2
+
+The two functionals describe geometrically distinct circle packings
+(face-dual vs vertex-based) but agree in the *angle-defect structure*
+they expose to the Newton solver: both report `Θ − Σ α_actual` at every
+free DOF.  This is tested directly:
+
+```cpp
+TEST(InversiveDistanceFunctional, AngleDefectAtU0_AgreesWithEuclideanAtU0)
+{
+    auto mesh = make_quad_strip();
+
+    auto G_id = inversive_distance_gradient(mesh, x_id, m_id);
+    auto G_eu = euclidean_gradient            (mesh, x_eu, m_eu);
+
+    for (i in DOFs) EXPECT_NEAR(G_id[i], G_eu[i], 1e-10);
+}
+```
+
+Why this works: at `u = 0`, both initialisation procedures reconstruct the
+input 3-D edge length exactly (`compute_*_lambda0_from_mesh` for Euclidean,
+`compute_inversive_distance_init_from_mesh` for inversive distance).
+Therefore the actual angle sums per vertex are identical, and both
+gradients reduce to the same `Θ_default − Σ α(ℓ_3d)`.
+
+This is the **operational** consequence of Glickenstein 2011 §5:
+"different parametrisations of the same initial discrete metric produce the
+same Newton-time-zero gradient".
+
+---
+
+## 4.  Comparison with `euclidean_functional.hpp`
+
+| Aspect                     | Euclidean                                    | CP-Euclidean (9a.1)                          | Inversive Distance (9a.2)                                          |
+|---|---|---|---|
+| DOF basis                  | per vertex (`u_v = log scale`)                | per face (`ρ_f = log radius`)                | per vertex (`u_v = log radius`)                                    |
+| Per-edge constant          | `λ°_ij = 2 log ℓ°_ij`                         | `θ_e` (intersection angle)                   | `I_ij` (inversive distance)                                        |
+| Edge-length formula        | `ℓ = exp((λ° + u_i + u_j)/2)`                 | (no per-edge ℓ — face-circle radii)          | `ℓ² = r_i² + r_j² + 2 I r_i r_j`                                   |
+| Angles                     | half-tangent law of cosines                   | (face-internal angles via `p(θ*, Δρ)`)       | half-tangent law of cosines (reuses `euclidean_angles`)            |
+| Gradient                   | `Θ_v − Σ α_v(f)`                              | `φ_f − Σ_{h:face(h)=f} (p+θ*)`               | `Θ_v − Σ α_v(f)`                                                   |
+| Energy form                | path integral (10-pt GL)                      | closed form via `½ p Δρ + Λ(θ*+p) − θ* ρ`   | path integral (10-pt GL)                                           |
+| Hessian                    | analytic (cotangent Laplacian)                | analytic (`sin θ / (cosh Δρ − cos θ)`)       | finite difference (analytic deferred — Glickenstein 2011 eq. 4.6)  |
+| Convexity                  | strictly convex after gauge fix               | strictly convex after gauge fix              | locally convex on triangle-inequality domain (Luo 2004 Thm 1.2)    |
+| Gauge fix                  | pin one vertex (`v_idx = −1`)                 | pin one face   (`f_idx = −1`)                | pin one vertex (`v_idx = −1`)                                      |
+
+### 4.1  Structural reuse
+
+`inversive_distance_functional.hpp` reuses `euclidean_angles()` from
+`euclidean_geometry.hpp` unchanged.  The only difference from
+`euclidean_functional.hpp` is the four lines that map `(u_i, u_j, I_ij)` to
+`ℓ_ij²` before invoking `euclidean_angles()`.
+
+`cp_euclidean_functional.hpp` shares no algorithmic code with the Euclidean
+functional — it operates on a different DOF basis and a different energy
+form.  It does share the Clausen function via `clausen2()` from `clausen.hpp`.
+
+---
+
+## 5.  Test counts and acceptance criteria
+
+| Suite | Tests | Status |
+|---|---:|:---:|
+| `cgal.CPEuclideanFunctional.*`        | 10 | ✅ all pass |
+| `cgal.InversiveDistanceFunctional.*`  | 11 | ✅ all pass |
+| **Full CGAL regression**              | **205** | ✅ all pass |
+| Non-CGAL fast suite                   | 36 | ✅ all pass |
+
+### Acceptance criteria — met
+
+- [x]  FD-vs-analytic gradient check passes on all test meshes (both functionals)
+- [x]  FD-vs-analytic Hessian check passes on closed and open tetrahedron (9a.1)
+- [x]  Hessian PSD-property test passes (9a.1)
+- [x]  Bowers-Stephenson round-trip identity verified (9a.2)
+- [x]  Three special-case limits of Luo's edge formula verified at machine ε (9a.2)
+- [x]  Cross-validation against `euclidean_functional` at `u = 0` (9a.2)
+- [x]  All formulas cite their source paper or Java line number
+
+---
+
+## 6.  References
+
+- Bobenko, A. I., Pinkall, U. & Springborn, B. (2010). *Discrete conformal
+  maps and ideal hyperbolic polyhedra.* Geometry & Topology 14, 379–426.
+- Bowers, P. L. & Stephenson, K. (2004). *Uniformizing dessins and Belyĭ
+  maps via circle packing.* Memoirs of the AMS 170(805).
+- Glickenstein, D. (2011). *Discrete conformal variations and scalar
+  curvature on piecewise flat manifolds.* J. Differential Geometry 87(2),
+  201–238.
+- Luo, F. (2004). *Combinatorial Yamabe Flow on Surfaces.* Communications
+  in Contemporary Mathematics 6(5), 765–780.
+- Java original (CPEuclidean only):
+  `/Users/tarikmoussa/Desktop/conformallab/src/de/varylab/discreteconformal/functional/CPEuclideanFunctional.java`
+- Java test:
+  `/Users/tarikmoussa/Desktop/conformallab/src-test/de/varylab/discreteconformal/functional/CPEuclideanFunctionalTest.java`

doc/contributing.md

@@ -29,8 +29,8 @@ Two jobs run on push to `dev`/`main` or on pull requests:
 
 | Job | What it tests | Trigger |
 |---|---|---|
-| `test-fast` | 36 non-CGAL tests, no Boost | all branches |
-| `test-cgal` | 170 CGAL tests + 1 skip | `main`, `dev`, PRs only |
+| `test-fast` | 23 non-CGAL tests, no Boost | all branches |
+| `test-cgal` | 227 CGAL tests, 0 skipped | `main`, `dev`, PRs only |
 
 A PR is ready to merge when both jobs pass.
 
@@ -51,10 +51,7 @@ Every new algorithm needs:
 
 3. **Registration** — add the `.cpp` file to `code/tests/cgal/CMakeLists.txt`.
 
-Expected CI result: **36 + 170 tests pass, exactly 1 skipped**.
-The skip is an intentional `GTEST_SKIP()` stub for the genus-2 homology test
-(`cgal.HomologyGenerators.Genus2_FourGeneratorPaths_BLOCKED`) — blocked until a
-genus-2 mesh is available in Phase 9c.  Do not remove it.
+Expected CI result: **23 + 227 tests pass, 0 skipped**.
 
 ---
 

doc/getting-started.md

@@ -48,7 +48,7 @@ cmake --build build --target conformallab_tests -j$(nproc)
 ctest --test-dir build --output-on-failure
 ```
 
-Expected: **36 tests pass**.
+Expected: **23 tests pass**.
 
 ### Mode 2 — CGAL tests, headless (recommended for CI and development)
 
@@ -60,7 +60,7 @@ cmake --build build --target conformallab_cgal_tests -j$(nproc)
 ctest --test-dir build -R "^cgal\." --output-on-failure
 ```
 
-Expected: **173 tests pass, 1 skipped** (intentional stub for analytic HyperIdeal Hessian, Phase 9b).
+Expected: **227 tests pass, 0 skipped**.
 
 ### Mode 3 — Full local build (CLI app + interactive viewer)
 
@@ -146,7 +146,7 @@ sets x* = 0, so a small perturbation (-0.05) needs only one Newton step.
 bash scripts/try_it.sh
 ```
 This clones nothing (run from inside the repo), builds the CGAL test suite, runs
-all 173+36 tests, and prints a summary.  See `scripts/try_it.sh` for details.
+all 227+23 tests, and prints a summary.  See `scripts/try_it.sh` for details.
 
 ---
 

doc/math/complexity.md

@@ -0,0 +1,133 @@
+# Complexity and Scalability
+
+> **Measured on:** Apple M-series (ARM64), Release build (`-O2`), single thread.
+> CI runner (Raspberry Pi 4, ARM64) is ~10× slower — the smoke tests assert
+> on correctness only (iteration count, residual norm), not on wall-clock time.
+
+---
+
+## 1 — Algorithmic complexity per pipeline step
+
+| Step | Function | Time complexity | Space | Notes |
+|---|---|---|---|---|
+| Mesh load | `load_mesh()` | O(F) | O(V+F) | CGAL OFF/OBJ/PLY parser |
+| λ₀ initialisation | `compute_*_lambda0_from_mesh()` | O(E) | O(E) | one pass over edges |
+| Gauss–Bonnet check | `check_gauss_bonnet()` | O(V) | O(1) | one pass over vertices |
+| Gauss–Bonnet enforce | `enforce_gauss_bonnet()` | O(V) | O(1) | redistributes defect uniformly |
+| **Gradient** (Euclidean/Spherical) | `euclidean_gradient()` | O(F) | O(V) | one pass over faces |
+| **Gradient** (HyperIdeal) | `hyper_ideal_gradient()` | O(E) | O(V+E) | ζ-functions per edge |
+| **Hessian** (Euclidean) | `euclidean_hessian()` | O(F) | O(V) sparse | cotangent Laplacian, nnz ≈ 6V |
+| **Hessian** (Spherical) | `spherical_hessian()` | O(F) | O(V) sparse | spherical law-of-cosines analog |
+| **Hessian** (HyperIdeal) | `hyper_ideal_hessian()` | O(n·E) | O(V+E) sparse | **FD approximation: n extra gradient evals per Newton step** → Phase 9b will replace with O(E) analytic |
+| **Linear solve** | `SimplicialLDLT` | O(V^{1.5}) | O(V^{1.5}) | planar-graph fill-in; automatic SparseQR fallback |
+| **Newton iteration** | `newton_euclidean()` | O(V^{1.5}) per iter | O(V) | typically 3–20 iterations total |
+| **Full Newton solve** | `newton_euclidean()` | O(k · V^{1.5}) | O(V^{1.5}) | k = iteration count, k < 30 in practice |
+| Cut graph | `compute_cut_graph()` | O(E log E) | O(V+E) | spanning tree + cotree BFS |
+| Layout (BFS-trilateration) | `euclidean_layout()` | O(F) | O(V) | priority-BFS, one trilateration per face |
+| Holonomy | (inside `*_layout`) | O(g·E) | O(g) | one Möbius composition per seam edge per generator |
+| Period matrix | `compute_period_matrix()` | O(1) after holonomy | O(1) | τ = ω_b/ω_a, SL(2,ℤ) reduction |
+| Fundamental domain | `compute_fundamental_domain()` | O(g) | O(g) | g generator pairs |
+
+**Dominant cost:** the SimplicialLDLT factorization at O(V^{1.5}).
+For the meshes in the test suite (V up to ~7K) this is in the 10–100ms range.
+For meshes with V > 50K the HyperIdeal FD Hessian becomes a second bottleneck
+(Phase 9b: analytic Hessian will reduce this to O(E) per Newton step).
+
+---
+
+## 2 — Measured timings on test meshes
+
+All times measured in Release mode (`-O2`) on Apple M-series (ARM64), single thread,
+from `test_scalability_smoke.cpp` stdout output.
+
+### Newton solver (Euclidean, from x₀ = −0.05 perturbation)
+
+| Mesh | V | F | Genus | Iterations | ‖G‖_∞ | Newton time |
+|---|---|---|---|---|---|---|
+| `cathead.obj` | 131 | 248 | 0 (open) | 3 | 1.2e-12 | < 1 ms |
+| `brezel2.obj` | 2 622 | 5 248 | 2 | — (cut graph only) | — | — |
+| `brezel.obj` | 6 910 | 13 824 | 2 | 3 | 1.5e-12 | **69 ms** |
+
+### Cut graph (tree-cotree, Erickson–Whittlesey)
+
+| Mesh | V | F | Genus | Seam edges | Cut graph time |
+|---|---|---|---|---|---|
+| `brezel2.obj` | 2 622 | 5 248 | 2 | 4 (= 2g) | 10 ms |
+| `brezel.obj` | 6 910 | 13 824 | 2 | 4 (= 2g) | < 1 ms |
+
+> **Note on iteration count.** All three meshes converge in exactly 3 Newton
+> iterations from a −0.05 perturbation. This is consistent with quadratic
+> convergence: the Euclidean energy is strictly convex, so Newton reaches
+> machine-precision residual (‖G‖ ≈ 10⁻¹²) in very few steps regardless of
+> mesh size. The per-iteration cost (dominated by SimplicialLDLT) grows with V,
+> but the iteration count does not.
+
+---
+
+## 3 — Scaling projection
+
+Based on the O(V^{1.5}) model for the linear solve:
+
+| V | Projected Newton time (Euclidean) | Notes |
+|---|---|---|
+| 500 | ~2 ms | typical research mesh |
+| 5 000 | ~50 ms | brezel2-scale |
+| 7 000 | ~70 ms | brezel-scale (measured: 69ms ✓) |
+| 20 000 | ~500 ms | large detailed mesh |
+| 50 000 | ~3 s | remeshed high-resolution surface |
+| 100 000 | ~9 s | boundary of practical usability (single thread) |
+
+For V > 50K: consider iterative solvers (e.g. Conjugate Gradient preconditioned
+with incomplete Cholesky) as a Phase 10 engineering improvement.
+
+---
+
+## 4 — HyperIdeal Hessian bottleneck
+
+The HyperIdeal Hessian is currently computed by **finite differences** (Phase 9b
+plans an analytic replacement). The FD cost is:
+
+```
+n_dof extra gradient evaluations per Newton step
+```
+
+where `n_dof = V + E` (HyperIdeal has both vertex and edge DOFs). For a mesh with
+V=6910, F=13824 this means ~20K gradient evaluations per Newton step instead of 1,
+making HyperIdeal roughly **20× slower** than Euclidean for the same mesh.
+
+**After Phase 9b** (analytic HyperIdeal Hessian): the HyperIdeal time per iteration
+will match Euclidean — O(E) Hessian assembly, O(V^{1.5}) factorization.
+
+---
+
+## 5 — Memory usage
+
+| Component | Memory | Formula |
+|---|---|---|
+| Mesh | ~200 bytes/vertex | CGAL `Surface_mesh` overhead |
+| Eigen sparse Hessian | ~48 bytes/nonzero | nnz ≈ 6V for cotangent Laplacian |
+| SimplicialLDLT factorization | O(V^{1.5}) bytes | fill-in for planar sparse matrix |
+| Layout (UV coordinates) | 16 bytes/vertex | `Eigen::Vector2d` per vertex |
+| Total for brezel (V=6910) | **~40 MB** | estimate; actual measured not yet |
+
+---
+
+## 6 — How to run the smoke tests yourself
+
+```bash
+cmake -S code -B build -DWITH_CGAL_TESTS=ON -DCMAKE_BUILD_TYPE=Release
+cmake --build build --target conformallab_cgal_tests -j$(nproc)
+
+# Run all three scalability tests — timing printed to stdout
+./build/tests/cgal/conformallab_cgal_tests --gtest_filter="SmokeEuclidean*"
+```
+
+Expected output:
+```
+[SmokeEuclidean.CatHead]  V=131  F=248  iter=3 ||G||=1.2e-12 time=<1ms
+[SmokeEuclidean.Brezel]   V=6910 F=13824 iter=3 ||G||=1.5e-12 newton=69ms cut=0ms
+[SmokeEuclidean.Brezel2]  V=2622 F=5248  cut=10ms seams=4
+```
+
+Timings vary by hardware. The assertions (iter < 30, ‖G‖ < 1e-8, seams = 2g)
+are hardware-independent and run in CI.

doc/math/novelty-statement.md

@@ -91,7 +91,7 @@ is an open research question that this library is designed to investigate.
 
 ### 3.4 — Full test coverage of analytic invariants
 
-173 CGAL tests verify mathematically provable properties:
+176 CGAL tests verify mathematically provable properties:
 - Gauss–Bonnet: Σ(2π−Θᵥ) = 2π·χ(M) to machine precision
 - τ ∈ fundamental domain: three inequalities
 - Holonomy closure: [T_a, T_b] = Id (abelian for genus 1)
@@ -120,7 +120,7 @@ conformallab++ is a port of Stefan Sechelmann's Java ConformalLab (TU Berlin,
 ~850 commits, v1.0.0 2018, LGPL).  The port:
 
 - Replaces the custom Java halfedge structure (`CoHDS`) with `CGAL::Surface_mesh`
-- Replaces JUnit tests with GTest + CGAL test format (173 tests)
+- Replaces JUnit tests with GTest + CGAL test format (176 tests)
 - Adds Doxygen API documentation, CMake build, and CLI
 - Is MIT licensed (the Java original is LGPL)
 - Targets submission to the CGAL library as package `Discrete_conformal_map`

doc/math/references.md

@@ -19,7 +19,11 @@ Java reference implementation: [github.com/varylab/conformallab](https://github.
 | **Springborn** — *Ideal Hyperbolic Polyhedra and Discrete Uniformization*, Discrete & Computational Geometry (2020) | `hyper_ideal_geometry.hpp` — ζ₁₃/ζ₁₄/ζ₁₅ functions; `hyper_ideal_functional.hpp` |
 | **Pinkall, Polthier** — *Computing Discrete Minimal Surfaces and Their Conjugates*, Experimental Mathematics (1993) | `euclidean_hessian.hpp` — cotangent Laplacian |
 | **Bobenko, Springborn** — *Variational Principles for Circle Patterns and Koebe's Theorem*, Transactions AMS (2004) | Variational angle-sum framework underlying all three functionals |
-| **Luo** — *Combinatorial Yamabe Flow on Surfaces*, Communications in Contemporary Mathematics (2004) | Inversive-distance functional — **not yet ported**, Phase 9a |
+| **Luo** — *Combinatorial Yamabe Flow on Surfaces*, Communications in Contemporary Mathematics (2004) | Inversive-distance functional — **new research** in Phase 9a.2 (no Java original; implemented from this paper + Glickenstein 2011 + Bowers-Stephenson 2004) |
+| **Bowers, Stephenson** — *Uniformizing dessins and Belyĭ maps via circle packing*, Memoirs of the AMS 170(805) (2004) | Bowers-Stephenson identity I_ij = (ℓ²−r_i²−r_j²)/(2 r_i r_j) used to initialise inversive distance from input geometry (Phase 9a.2) |
+| **Glickenstein** — *Discrete conformal variations and scalar curvature on piecewise flat manifolds*, J. Differential Geometry 87 (2011) | Analytic Hessian of the inversive-distance functional (eq. 4.6) and cross-correspondence I_ij = cos θ_e between vertex-based (9a.2) and face-based (9a.1) circle packings |
+| **Bobenko, Pinkall, Springborn** — *Discrete conformal maps and ideal hyperbolic polyhedra*, Geometry & Topology 14 (2010) | Face-based circle-packing functional (`CPEuclideanFunctional.java` → `cp_euclidean_functional.hpp`, Phase 9a.1) |
+| **Schläfli** — *On the multiple integral ∫dx dy …*, Quarterly Journal of Pure and Applied Mathematics (1858/60) | Volume differential `2 dV = Σ_e aₑ dαₑ + Σ_v bᵥ dβᵥ` — foundation for the analytic HyperIdeal Hessian via Schläfli identity (Phase 9b-analytic, **new research beyond Java**) |
 | **Erickson, Whittlesey** — *Greedy Optimal Homotopy and Homology Generators*, SODA (2005) | `cut_graph.hpp` — tree-cotree algorithm |
 | **Bobenko, Springborn** — *A Discrete Laplace–Beltrami Operator for Simplicial Surfaces*, Discrete & Computational Geometry (2007) | Background for cotangent weights |
 | **Desbrun, Kanso, Tong** — *Discrete Differential Forms for Computational Modeling*, SIGGRAPH Course Notes (2006) | Discrete exterior calculus background for Phase 10a |
@@ -28,22 +32,22 @@ Java reference implementation: [github.com/varylab/conformallab](https://github.
 
 ## geometry-central cross-reference *(optional comparison track)*
 
-> Diese Referenzen beziehen sich auf eine alternative Implementierung desselben
-> mathematischen Problems. Sie sind keine Voraussetzung für conformallab++,
-> aber relevant für Kreuz-Validierung und mögliche algorithmische Adoptionen
-> (→ GC-1/2/3 im Phasen-Roadmap, → Abschnitt 9 in `validation.md`).
+> These references relate to an alternative implementation of the same
+> mathematical problem. They are not prerequisites for conformallab++,
+> but are relevant for cross-validation and possible algorithmic adoptions
+> (→ GC-1/2/3 in the phase roadmap, → Section 9 in `validation.md`).
 
-| Reference | Relevanz |
+| Reference | Relevance |
 |---|---|
-| **Gillespie, Springborn, Crane** — *Discrete Conformal Equivalence of Polyhedral Surfaces*, ACM SIGGRAPH 2021. DOI: [10.1145/3450626.3459763](https://doi.org/10.1145/3450626.3459763) | Implementiert in **geometry-central**. Erweitert Springborn 2020 um intrinsische Triangulierungen und Ptolemäische Flips. Löst dasselbe DCE-Problem wie conformallab++, aber mit anderem Algorithmus. |
-| **Sharp, Soliman, Crane** — *Navigating Intrinsic Triangulations*, ACM SIGGRAPH 2019 | Algorithmische Grundlage für `SignpostIntrinsicTriangulation` in geometry-central — relevant für GC-2 (optionales Pre-Conditioning). |
+| **Gillespie, Springborn, Crane** — *Discrete Conformal Equivalence of Polyhedral Surfaces*, ACM SIGGRAPH 2021. DOI: [10.1145/3450626.3459763](https://doi.org/10.1145/3450626.3459763) | Implemented in **geometry-central**. Extends Springborn 2020 with intrinsic triangulations and Ptolemaic flips. Solves the same DCE problem as conformallab++, but with a different algorithm. |
+| **Sharp, Soliman, Crane** — *Navigating Intrinsic Triangulations*, ACM SIGGRAPH 2019 | Algorithmic basis for `SignpostIntrinsicTriangulation` in geometry-central — relevant for GC-2 (optional pre-conditioning). |
 
-**Hinweis zu Springborn 2020:**  
-Das Papier *"Ideal Hyperbolic Polyhedra and Discrete Uniformization"*
-(Springborn, Discrete & Computational Geometry 2020) ist **in conformallab++
-bereits implementiert** — es ist die direkte Referenz für den HyperIdeal-Geometriemodus
-(`hyper_ideal_geometry.hpp`). Die geometry-central Implementierung (Gillespie 2021)
-baut auf diesem Papier auf und ergänzt es um Ptolemäische Flips.
+**Note on Springborn 2020:**  
+The paper *"Ideal Hyperbolic Polyhedra and Discrete Uniformization"*
+(Springborn, Discrete & Computational Geometry 2020) is **already implemented in
+conformallab++** — it is the direct reference for the HyperIdeal geometry mode
+(`hyper_ideal_geometry.hpp`). The geometry-central implementation (Gillespie 2021)
+builds on this paper and augments it with Ptolemaic flips.
 
 ---
 

doc/math/validation-protocol.md

@@ -199,7 +199,7 @@ inner/outer edge lengths).  Use `torus_8x8.off` for a finer approximation.
 ## Summary checklist
 
 ```
-[ ] Check 0: 170 tests pass, 1 skip
+[ ] Check 0: 176 tests pass, 0 skipped
 [ ] Check 1: Gauss–Bonnet exact (1e-10)
 [ ] Check 2: FD gradient < 1e-6 for all 3 geometries
 [ ] Check 3: Newton convergence < 50 iterations

doc/math/validation.md

@@ -14,7 +14,7 @@ cmake --build build --target conformallab_cgal_tests
 ctest --test-dir build -R cgal --output-on-failure
 ```
 
-All 173 tests pass (1 skipped by design — see `doc/api/tests.md`).
+All 227 tests pass, 0 skipped (see `doc/api/tests.md`).
 
 ---
 
@@ -193,66 +193,58 @@ These are the **holonomy consistency** checks implemented in `test_phase7.cpp`
 
 ## 9 — Cross-validation with geometry-central *(optional / hypothetical)*
 
-> **Hinweis:** Dieser Abschnitt beschreibt eine mögliche externe Kreuz-Validierung,
-> die keine Voraussetzung für die Korrektheit der Implementierung ist.
-> Sie ist interessant, weil geometry-central denselben mathematischen Kern
-> implementiert (Gillespie, Springborn, Crane — SIGGRAPH 2021, aufbauend auf
-> Springborn 2020), aber mit einer anderen algorithmischen Strategie
-> (Ptolemäische Flips + intrinsische Triangulierungen statt Newton auf der
-> Original-Triangulierung).
+> **Note:** This section describes a possible external cross-validation that is not
+> a prerequisite for the correctness of the implementation.
+> It is of interest because geometry-central implements the same mathematical core
+> (Gillespie, Springborn, Crane — SIGGRAPH 2021, building on
+> Springborn 2020), but with a different algorithmic strategy
+> (Ptolemaic flips + intrinsic triangulations instead of Newton on the
+> original triangulation).
 
-### Welche Outputs sind vergleichbar?
+### Which outputs are comparable?
 
-| Output | conformallab++ | geometry-central | Vergleichbar? |
+| Output | conformallab++ | geometry-central | Comparable? |
 |---|---|---|---|
-| u-Vektor (Skalierungsparameter) | `res.x` | `u` nach Yamabe flow | ✓ nach Normalisierung |
-| UV-Koordinaten | `layout.uv[v]` | konforme Parametrisierung | ✓ bis auf Möbius-Transformation |
-| Gauss-Bonnet Defekt | `gauss_bonnet_sum()` | implizit via Krümmungsfluss | ✓ (analytisch identisch) |
-| Anzahl Newton-Iterationen | `res.iterations` | Yamabe-Schritte | ~ (anderer Algorithmus) |
-| Period-Matrix τ | `pd.tau_reduced` | **nicht vorhanden** | ✗ |
-| Möbius-Holonomie | `hol.T_a, T_b` | **nicht vorhanden** | ✗ |
+| u-vector (scale parameters) | `res.x` | `u` after Yamabe flow | ✓ after normalisation |
+| UV coordinates | `layout.uv[v]` | conformal parameterisation | ✓ up to Möbius transformation |
+| Gauss-Bonnet deficit | `gauss_bonnet_sum()` | implicit via curvature flow | ✓ (analytically identical) |
+| Number of Newton iterations | `res.iterations` | Yamabe steps | ~ (different algorithm) |
+| Period matrix τ | `pd.tau_reduced` | **not available** | ✗ |
+| Möbius holonomy | `hol.T_a, T_b` | **not available** | ✗ |
 
-### Normalisierungsabgleich
+### Normalisation alignment
 
-Der u-Vektor in conformallab++ hat einen Freiheitsgrad (globale additive Konstante —
-Eichfreiheit nach Pin-Fixierung). geometry-central kann eine andere Konvention nutzen.
-Vor dem Vergleich normalisieren:
+The u-vector in conformallab++ has one degree of freedom (global additive constant —
+gauge freedom after pin-fixing). geometry-central may use a different convention.
+Normalise before comparing:
 
 ```cpp
-// conformallab++: u zentrieren
+// conformallab++: centre u
 double mean_u = std::accumulate(x.begin(), x.end(), 0.0) / x.size();
 std::vector<double> x_norm(x.size());
 for (int i = 0; i < x.size(); ++i) x_norm[i] = x[i] - mean_u;
 
-// Dann mit geometry-central u-Vektor (ebenfalls zentriert) vergleichen:
-// max|x_norm[i] - gc_u[i]| < 1e-8  →  identischer Konvergenzpunkt
+// Then compare with the geometry-central u-vector (also centred):
+// max|x_norm[i] - gc_u[i]| < 1e-8  →  identical convergence point
 ```
 
-### Wann ist der Vergleich sinnvoll?
+### When is the comparison useful?
 
-| Zeitpunkt | Was ist möglich |
+| Point in time | What is possible |
 |---|---|
-| **Jetzt (Phase 7)** | Manueller Vergleich mit denselben `.off`/`.obj` Testnetzen |
-| **Nach Phase 8** | Automatisiertes Vergleichsskript (Python oder separates C++-Binary) |
-| **Phase 10 (Forschung)** | Algorithmus-Vergleich: Newton vs. Ptolemäische Flips auf schwierigen Netzen |
+| **Now (Phase 7)** | Manual comparison using the same `.off`/`.obj` test meshes |
+| **After Phase 8** | Automated comparison script (Python or separate C++ binary) |
+| **Phase 10 (research)** | Algorithm comparison: Newton vs. Ptolemaic flips on difficult meshes |
 
-### Voraussetzungen für einen fairen Vergleich
+### Connection to the literature
 
-1. Identische Eingabenetze (OFF/OBJ, gleiche Vertex-Orientierung)
-2. Gleiche Gauss-Bonnet-Zielkrümmungen (Θᵥ = 2π für alle v, geschlossene Fläche)
-3. u-Normalisierung abgeglichen (zentriert, gleiche Eichfixierung)
-4. Konvergenztoleranz synchronisiert (max. Gradientnorm < 1e-8)
-
-### Verbindung zur Literatur
-
-Das Springborn 2020-Papier ("Ideal Hyperbolic Polyhedra and Discrete Uniformization")
-ist **in conformallab++ bereits implementiert** — es ist die mathematische Grundlage
-für den HyperIdeal-Geometriemodus (Phase 2/3). Die geometry-central Implementierung
-basiert auf der Weiterentwicklung von Gillespie, Springborn & Crane (2021), die
-denselben Variationsprinzip von Bobenko–Springborn 2004 verwendet, aber zusätzlich
-Ptolemäische Flips einsetzt, um die Triangulierung während der Optimierung zu
-verbessern — eine Idee, die in conformallab++ noch nicht implementiert ist (→ GC-2
-im Phasen-Roadmap).
+The Springborn 2020 paper ("Ideal Hyperbolic Polyhedra and Discrete Uniformization")
+is **already implemented in conformallab++** — it is the mathematical foundation
+for the HyperIdeal geometry mode (Phase 2/3). The geometry-central implementation
+is based on the extension by Gillespie, Springborn & Crane (2021), which uses the
+same variational principle of Bobenko–Springborn 2004 but additionally applies
+Ptolemaic flips to improve the triangulation during optimisation — an idea not yet
+implemented in conformallab++ (→ GC-2 in the phase roadmap).
 
 ---
 
@@ -260,7 +252,7 @@ im Phasen-Roadmap).
 
 Run these in order to validate the implementation:
 
-- [ ] `ctest --test-dir build -R cgal --output-on-failure` → 173 tests pass, 1 skip
+- [ ] `ctest --test-dir build -R cgal --output-on-failure` → 227 tests pass, 0 skipped
 - [ ] `cgal.GaussBonnet.*` all pass → topology is correctly read from mesh
 - [ ] `cgal.EuclideanFunctional.GradientCheck_*` pass → energy = integral of gradient
 - [ ] `cgal.PeriodMatrix.TauInFundamentalDomain_*` pass → SL(2,ℤ) reduction correct

doc/roadmap/java-parity.md

@@ -15,10 +15,11 @@ as the reference implementation for expected behaviour, edge cases, and test cas
 | Euclidean functional — energy, gradient | ✅ | ✅ | |
 | Spherical functional — energy, gradient, gauge-fix | ✅ | ✅ | |
 | HyperIdeal functional — energy, gradient | ✅ | ✅ | |
-| Inversive-distance functional (Luo 2004) | ✅ | ❌ Phase 9a | `InversiveDistanceFunctional.java` |
+| Inversive-distance functional (Luo 2004) | ❌ *(not in Java)* | ❌ Phase 9a.2 | **No Java source.** Implemented in C++ from Luo 2004 + Glickenstein 2011 + Bowers-Stephenson 2004 — **new research, not a port**. Verified: `find /Users/tarikmoussa/Desktop/conformallab -iname "*nversive*"` returns zero. |
+| CP-Euclidean functional (BPS 2010) | ✅ | ❌ Phase 9a.1 | `CPEuclideanFunctional.java` (260 lines) — face-based circle packing |
 | Euclidean Hessian — cotangent Laplacian | ✅ analytic | ✅ analytic | Pinkall–Polthier (1993) |
 | Spherical Hessian — ∂α/∂u via law of cosines | ✅ analytic | ✅ analytic | |
-| HyperIdeal Hessian — ζ → lᵢⱼ → β/α chain | ✅ analytic | ⚠️ symmetric FD | Phase 9b |
+| HyperIdeal Hessian — analytic via ζ → l → β/α | ❌ *(`hasHessian()==false`)* | ⚠️ FD (Phase 4a) → block-FD (Phase 9b) | **Java has NO Hessian for HyperIdeal** (verified: `HyperIdealFunctional.java:295-298` declares `hasHessian() { return false; }`).  Both C++ Hessian variants are **new research beyond Java**; analytic Schläfli-based variant is Phase 9b-analytic. |
 | Newton solver | ✅ | ✅ | |
 | SparseQR fallback for gauge modes | unknown | ✅ | New in C++ |
 | Cone metrics — prescribed Θᵥ ≠ 2π | ✅ fully | ⚠️ data structure only | |
@@ -48,12 +49,22 @@ They are candidates for Phase 9 or Phase 10.
 
 | Java class | Description | Phase |
 |---|---|---|
-| `InversiveDistanceFunctional` | Inversive-distance conformal energy | 9a |
-| `DiscreteHarmonicFormUtility` | Discrete harmonic 1-forms | 10a prerequisite |
-| `DiscreteHolomorphicFormUtility` | Holomorphic differentials on discrete surfaces | 10a |
-| `DiscreteRiemannUtility` | Discrete Riemann surfaces | 10 |
-| `CanonicalBasisUtility` | Canonical homology basis for genus g | 9c / 10 |
-| `HomologyUtility` | Homology computation | 9c |
+| `CPEuclideanFunctional` | Face-based circle-packing energy (BPS 2010) | 9a.1 |
+| `FundamentalPolygonUtility` (698 lines) | Construction + canonicalisation of 4g-gons for genus-g | 9c |
+| `CanonicalFormUtility` (532 lines) | High-level wrapper for 9c — drives canonicalisation pipeline | 9c |
+| `CuttingUtility` + `SurgeryUtility` (~800 lines) | Mesh cuts and gluing operations needed for fundamental domains | 9c (foundation) |
+| `DiscreteHarmonicFormUtility` (657 lines) | Discrete harmonic 1-forms via cotangent Laplacian (Hodge theory) | 10a prerequisite |
+| `DiscreteHolomorphicFormUtility` (285 lines) | Holomorphic differentials via Mercat complex structure | 10a (Bobenko-Springborn 2004 §6) |
+| `CanonicalBasisUtility` (337 lines) | Symplectic homology basis with intersection-form normalisation | 10a prerequisite |
+| `DiscreteRiemannUtility` (186 lines) | Period matrix τ, Siegel reduction (genus g) | 10b |
+| `DualityUtility` (308 lines), `HomologyUtility` (122 lines) | Primal/dual cohomology, cycle generators | 10a support |
+| `HyperbolicCyclicFunctional` (530 lines) | Discrete hyperbolic conformal energy (analogue of Euclidean) — completes the geometry suite | 10b–c |
+| `QuasiisothermicUtility` + `SinConditionApplication` (~1200 lines) | Lawson-correspondence parametrisation, sin-condition functional | 10b |
+| `KoebePolyhedron` (321 lines) | Koebe–Andreev–Thurston circle-packing construction | 10c |
+| `ElectrostaticSphereFunctional`, `MobiusCenteringFunctional` | Sphere-domain pre-processing functionals | 10c (optional) |
+
+Note: items marked as *new research* (e.g. Inversive Distance, HyperIdeal Hessian variants)
+are tracked separately in `doc/roadmap/research-track.md`.
 | `HomotopyUtility` | Homotopy generators | 9c |
 | `SpanningTreeUtility` | Spanning tree algorithms | 8 / infrastructure |
 | `SurgeryUtility` | Mesh surgery (cut/glue) | — |
@@ -65,22 +76,30 @@ They are candidates for Phase 9 or Phase 10.
 
 ---
 
-## HyperIdeal Hessian: FD vs. analytic
+## HyperIdeal Hessian — correction of an earlier mis-claim
 
-The Java library computes the HyperIdeal Hessian analytically through the chain:
+> **2026-05-21 audit:** A previous version of this document claimed
+> "the Java library computes the HyperIdeal Hessian analytically through the
+> chain (bᵢ, aₑ) → lᵢⱼ → ζ₁₃/ζ₁₄/ζ₁₅ → αᵢⱼ/βᵢ".  **This is incorrect.**
+> The Java source file `HyperIdealFunctional.java` line 295-298 declares
+> ```java
+> @Override
+> public boolean hasHessian() {
+>     return false;
+> }
+> ```
+> i.e. the upstream Java implementation supplies **no** HyperIdeal Hessian at
+> all — neither analytic nor numerical.  The chain rule above is the
+> *mathematical formulation* (from Springborn 2020 §4 + Schläfli 1858), not
+> something the Java code implements.
 
-```
-(bᵢ, aₑ) → lᵢⱼ → ζ₁₃/ζ₁₄/ζ₁₅ → αᵢⱼ / βᵢ
-```
+### Actual state of HyperIdeal Hessian in conformallab++
 
-conformallab++ uses a **symmetric finite-difference approximation**:
+| Variant | Status | Notes |
+|---|---|---|
+| Phase 4a — full FD `H[i,j] = (G(x+εeⱼ)[i] − G(x−εeⱼ)[i]) / (2ε)` | ✅ implemented | O(n·F) cost; PSD by Springborn 2020 strict convexity |
+| Phase 9b — block-FD (per-face 6×6 local block, scatter to global) | ✅ implemented (PR #9) | O(F·36) cost; ~96× speed-up over Phase 4a measured on V=200 mesh |
+| Phase 9b-analytic — Schläfli identity + chain rule through ζ₁₃/ζ₁₄/ζ₁₅ | 🔲 planned (research) | See `doc/roadmap/research-track.md` for the formal plan and citations |
 
-```
-H[i,j] = ( G(x + ε·eⱼ)[i] − G(x − ε·eⱼ)[i] ) / (2ε),   ε = 1e-5
-```
-
-Accuracy: O(ε²) ≈ 10⁻¹⁰ relative error. PSD guaranteed by strict convexity (Springborn 2020).
-Cost: n extra gradient evaluations per Newton step.
-Impact: negligible for meshes < 500 DOFs; measurable for larger meshes.
-
-The analytic Hessian is deferred to Phase 9b.
+All three are **new research beyond the Java port**.  Java parity for
+HyperIdeal stops at the gradient.

doc/roadmap/phases.md

@@ -16,7 +16,9 @@
 Phase 1   Clausen / Lobachevsky / ImLi₂ special functions            ✅
 Phase 2   Hyper-ideal geometry  (ζ, lᵢⱼ, αᵢⱼ, σᵢ, σᵢⱼ)             ✅
 Phase 3   CGAL Surface_mesh infrastructure + all three functionals
-          (Euclidean, Spherical, HyperIdeal) + analytical Hessians   ✅
+          (Euclidean, Spherical, HyperIdeal)
+          + analytical Hessians for Euclidean + Spherical
+          (HyperIdeal Hessian: symmetric FD — analytic deferred to 9b) ✅
 Phase 4   Newton solver (SimplicialLDLT + SparseQR fallback)
           + Mesh I/O (OFF/OBJ/PLY) + example programs                ✅   68 tests
 Phase 5   Priority-BFS layout + CLI app + JSON/XML serialisation      ✅   95 tests
@@ -24,7 +26,7 @@ Phase 6   Gauss–Bonnet check/enforce, tree-cotree cut graph (2g),
           exact hyperbolic trilateration, layout normalisation        ✅  121 tests
 Phase 7   MobiusMap, halfedge_uv, Möbius holonomy (SU(1,1)),
           period matrix τ∈ℍ + SL(2,ℤ) reduction,
-          fundamental domain parallelogram + tiling                  ✅  158 tests
+          fundamental domain parallelogram + tiling                  ✅  176 tests
 ```
 
 ---
@@ -68,106 +70,229 @@ mesh type.
 
 ---
 
-## ◼ Remaining porting — Phase 9
+## ◼ Phase 9 — Mixed: remaining Java port + first research extensions
 
-Java features from `de.varylab.discreteconformal` not yet in C++:
+> **Audit 2026-05-21:** Phase 9 was originally framed as "remaining
+> porting", but a closer look at the local Java repository revealed:
+> several Phase-9 items are **not** in Java at all (`InversiveDistanceFunctional`
+> does not exist; `HyperIdealFunctional.java:295-298` declares `hasHessian()=false`).
+> The plan below now distinguishes Java-port items from research items.
+> Full research catalogue: [`research-track.md`](research-track.md).
 
 ```
-9a   Inversive-distance functional (Luo 2004 / Bowers–Stephenson)
-       → inversive_distance_functional.hpp
-       Follows the exact same pattern as the three existing functionals.
-       → newton_inversive_distance()
-       → New test suite: test_inversive_distance.cpp
+9a — Circle-packing functionals  (split 2026-05-19)
+─────────────────────────────────────────────────────
 
-9b   Analytic HyperIdeal Hessian
-       → Replace FD Hessian in hyper_ideal_hessian.hpp
-       Direct differentiation through the chain:
-         (bᵢ, aₑ) → lᵢⱼ → ζ₁₃/ζ₁₄/ζ₁₅ → αᵢⱼ / βᵢ
-       Relevant for meshes > 500 DOFs (current FD Hessian is slow there).
+9a.1   CPEuclideanFunctional  (Java port)
+         → cp_euclidean_functional.hpp
+         Java source: CPEuclideanFunctional.java (260 lines)
+         Mathematical reference: Bobenko-Pinkall-Springborn 2010
+         Status: 🟡 PR #8 open, 10 tests passing.
+
+9a.2   Inversive-distance functional  (RESEARCH, not a port)
+         → inversive_distance_functional.hpp
+         Java source: NONE.  Empirically verified.
+         Mathematical reference: Luo 2004 + Bowers-Stephenson 2004 + Glickenstein 2011
+         Status: 🟡 PR #8 open, 11 tests passing.
+         Cross-validation: G_id(0) = G_eu(0) at 1e-10 (Glickenstein §5).
+
+9b — HyperIdeal Hessian  (RESEARCH — Java has no Hessian at all)
+─────────────────────────────────────────────────────────────────
+
+9b     Block-FD HyperIdeal Hessian
+         → Replace full FD in hyper_ideal_hessian.hpp
+         Java source: NONE (HyperIdealFunctional.java:295-298 declares
+                      hasHessian()==false; Java has NO Hessian).
+         Algorithm: per-face 6×6 block, scatter to global sparse matrix.
+         Status: 🟡 PR #9 open, 7 tests passing, ~96× speed-up measured.
+
+9b-analytic   Full analytic HyperIdeal Hessian via Schläfli identity
+         → planned, see research-track.md
+         Mathematical source: Springborn 2020 §4 + Schläfli 1858/60
+                              + Cho-Kim 1999 + Glickenstein 2011 §4
+         Algorithm: explicit chain rule through (bᵢ,aₑ) → ℓᵢⱼ → ζ₁₃/ζ₁₄/ζ₁₅ → αᵢⱼ/βᵢ
+         Includes: short LaTeX correctness note in doc/math/.
+         Effort: 10–14 days net.  Trigger: profiling on V > 5000.
+
+9c — Genus g > 1 fundamental domain  (Java port + research extensions)
+──────────────────────────────────────────────────────────────────────
 
 9c     4g-polygon boundary walk (genus g > 1)
          → Extend compute_fundamental_domain() beyond genus 1
-       Algorithm outline already in fundamental_domain.hpp as TODO(Phase 9).
-       Java reference: FundamentalDomainUtility.java
+         Java sources: FundamentalPolygonUtility.java (698 lines)
+                     + CanonicalFormUtility.java (532 lines)
+                     + CuttingUtility / SurgeryUtility (~800 lines)
+         Mathematical source: Poincaré 1882 + Sechelmann 2016 §5
+         Research component: bridging to conformallab++ cut_graph.hpp
+                             + holonomy infrastructure.
+         Effort: ~2 weeks for fundamental polygon, +2 weeks for surgery
+                 layer, +1 week integration.
 ```
 
 ---
 
 ## ◼ Optional / Hypothetical — geometry-central Cross-Comparison
 
-> **Status: keine geplante Phase — rein explorativ.**  
-> Diese Punkte sind keine Voraussetzung für Phase 8–10. Sie sind
-> interessant, weil geometry-central (Keenan Crane, CMU) auf denselben
-> mathematischen Grundlagen wie conformallab++ aufbaut — insbesondere auf
-> **Springborn 2020** und der direkten Weiterentwicklung durch
+> **Status: no planned phase — purely exploratory.**  
+> These items are not prerequisites for Phase 8–10. They are
+> of interest because geometry-central (Keenan Crane, CMU) is built on the same
+> mathematical foundations as conformallab++ — in particular
+> **Springborn 2020** and its direct extension by
 > **Gillespie, Springborn & Crane (SIGGRAPH 2021)**.  
-> Der entscheidende Unterschied: geometry-central löst dasselbe Problem
-> (diskrete konforme Äquivalenz) mit **intrinsischen Triangulierungen +
-> Ptolemäischen Flips**, während conformallab++ **Newton auf der
-> Original-Triangulierung** anwendet.
+> The key difference: geometry-central solves the same problem
+> (discrete conformal equivalence) using **intrinsic triangulations +
+> Ptolemaic flips**, while conformallab++ applies **Newton on the
+> original triangulation**.
 
 ```
-GC-1  [optional, jetzt möglich]
-      Mathematischer Output-Vergleich
-        → gleiche Testnetze (cathead.obj, brezel.obj, torus_4x4.off) in
-          beide Bibliotheken laden
-        → UV-Koordinaten, u-Vektor, Residualnorm vergleichen
-        → Normalisierungskonventionen abgleichen (u-Mittelwert, Skalierung)
-      Ziel: unabhängige Kreuz-Validierung der Konvergenzpunkte.
-      Aufwand: kleines Python/C++ Vergleichsskript, kein Bibliotheks-Umbau.
+GC-1  [optional, possible now]
+      Mathematical output comparison
+        → load the same test meshes (cathead.obj, brezel.obj, torus_4x4.off) into
+          both libraries
+        → compare UV coordinates, u-vector, residual norm
+        → align normalisation conventions (u mean, scaling)
+      Goal: independent cross-validation of convergence points.
+      Effort: small Python/C++ comparison script, no library restructuring.
 
-GC-2  [optional, sinnvoll nach Phase 8]
-      Intrinsic Delaunay Pre-Conditioning
-        → Vor dem Newton-Solver: geometry-central SignpostIntrinsicTriangulation
-          auf die Eingabe anwenden
-        → Ptolemäische Flips konditionieren die Hessian-Matrix vor
-        → Hypothese: weniger Newton-Iterationen auf nicht-Delaunay-Eingaben
-        → Implementierbar als optionaler cmake-Flag: -DWITH_GC_PRECOND=ON
-      Abhängigkeit: geometry-central als optionale externe Abhängigkeit
-      (header-only Teile genügen für den Flip-Algorithmus).
+GC-2  [optional, useful after Phase 8]
+      Intrinsic Delaunay pre-conditioning
+        → before the Newton solver: apply geometry-central SignpostIntrinsicTriangulation
+          to the input
+        → Ptolemaic flips pre-condition the Hessian matrix
+        → hypothesis: fewer Newton iterations on non-Delaunay inputs
+        → implementable as an optional cmake flag: -DWITH_GC_PRECOND=ON
+      Dependency: geometry-central as an optional external dependency
+      (header-only parts suffice for the flip algorithm).
 
-GC-3  [hypothetisch, Phase 10+ Forschung]
-      Ptolemäische Flip-basierter Solver als alternativer Backend
-        → Statt Newton: Ptolemäische Flips + penultimate-step Normalisierung
-          (Gillespie–Springborn–Crane 2021 Algorithmus)
-        → Vergleich: Konvergenzradius, Robustheit auf pathologischen Netzen,
-          numerische Stabilität auf hohen Genus-Flächen
-        → Für conformallab++ interessant, weil der Newton-Ansatz auf
-          stark nicht-Delaunay Netzen (z.B. nach Remeshing) instabil
-          werden kann.
-      Keine Implementierung geplant — Konzeptnotiz für Phase 10-Forschung.
+GC-3  [hypothetical, Phase 10+ research]
+      Ptolemaic flip-based solver as an alternative backend
+        → instead of Newton: Ptolemaic flips + penultimate-step normalisation
+          (Gillespie–Springborn–Crane 2021 algorithm)
+        → comparison: convergence radius, robustness on pathological meshes,
+          numerical stability on high-genus surfaces
+        → relevant for conformallab++ because the Newton approach can become
+          unstable on strongly non-Delaunay meshes (e.g. after remeshing).
+      No implementation planned — conceptual note for Phase 10 research.
 ```
 
-**Verbindung zur Literatur:**  
-Das Springborn 2020-Papier ("Ideal Hyperbolic Polyhedra and Discrete
-Uniformization") ist in conformallab++ als HyperIdeal-Geometriemodus
-bereits implementiert (Phase 2/3). Die Gillespie–Springborn–Crane
-2021-Erweiterung — die geometry-central implementiert — ergänzt dies um
-intrinsische Triangulierungen und macht den Algorithmus robust gegen
-schlechte Eingangs-Triangulierungen. Beide teilen denselben
-mathematischen Kern (diskrete konforme Äquivalenz, Gauss–Bonnet,
-Variationsprinzip von Bobenko–Springborn 2004).
+**Connection to the literature:**  
+The Springborn 2020 paper ("Ideal Hyperbolic Polyhedra and Discrete
+Uniformization") is already implemented in conformallab++ as the HyperIdeal
+geometry mode (Phase 2/3). The Gillespie–Springborn–Crane
+2021 extension — implemented in geometry-central — augments this with
+intrinsic triangulations and makes the algorithm robust against
+poor input triangulations. Both share the same
+mathematical core (discrete conformal equivalence, Gauss–Bonnet,
+variational principle of Bobenko–Springborn 2004).
 
 ---
 
-## ◼ New research — Phase 10+
+## ◼ Phase 10 — Genus g ≥ 2 (research with partial Java support)
 
-No direct Java reference implementation exists for these items.
+Most Phase-10 items have partial Java references (utility classes for
+forms and homology) but the **assembly** into a working uniformization
+pipeline is research.  Full catalogue with primary literature:
+[`research-track.md`](research-track.md).
 
 ```
 Phase 10   Global uniformization for genus g ≥ 2
 
-10a  Discrete holomorphic differentials
-       Integrate basis 1-forms ωᵢ along b-cycles of the cut graph.
-       Mathematical basis: Bobenko–Springborn (2004), §6.
-       Java partial reference: DiscreteHolomorphicFormUtility.java
+10a  Discrete holomorphic and harmonic 1-forms
+       → Integrate basis 1-forms ωᵢ along b-cycles of the cut graph.
+       Mathematical reference: Bobenko-Springborn 2004 §6 + Mercat 2001.
+       Java sources (partial, port-with-research):
+         CanonicalBasisUtility.java        337 lines  (homology basis)
+         HomologyUtility.java              122 lines
+         DualityUtility.java               308 lines
+         DiscreteHarmonicFormUtility.java  657 lines
+         DiscreteHolomorphicFormUtility.java 285 lines
+       Effort: ~6 weeks net (4 utility ports + 1 integration).
 
 10b  Siegel period matrix Ω ∈ H_g  (g×g complex symmetric, Im(Ω) > 0)
-       Ωᵢⱼ = ∫_{bⱼ} ωᵢ
-       Reduction to Siegel fundamental domain via Sp(2g,ℤ).
-       Requires: 10a
+       → Ωᵢⱼ = ∫_{bⱼ} ωᵢ
+       → Reduction to Siegel fundamental domain via Sp(2g,ℤ).
+       Mathematical reference: Bobenko-Springborn 2004 + Gottschling 1959.
+       Java partial reference: DiscreteRiemannUtility.java (186 lines).
+       Requires: 10a.
+       Effort: ~1 week net after 10a.
+
+10b'  Alternative methods (parallel research track)
+       → HyperbolicCyclicFunctional (Java, 530 lines) — completes the
+         classical three-mode set with hyperbolic energy.
+       → Quasi-isothermic parametrisation (Lawson correspondence):
+         QuasiisothermicUtility.java + SinConditionApplication.java
+         (~1 200 Java lines combined).
+       → MobiusCenteringFunctional (Java, 289 lines) — sphere centering.
+       Each independent; can be tackled in any order.
 
 10c  Full uniformization for genus g ≥ 2
-       Embedding as H²/Γ with Γ ⊂ PSL(2,ℝ) a Fuchsian group.
-       Requires: 10a + 10b + stable cut graph for g ≥ 2 (Phase 9c)
+       → Embedding as H²/Γ with Γ ⊂ PSL(2,ℝ) a Fuchsian group.
+       Mathematical reference: Sechelmann 2016 §6 (discrete instance);
+                               Bers 1960 (continuous theory).
+       Java reference: NONE — Java has the polygon + period matrix
+                              pieces but does not assemble them into
+                              a Fuchsian-group representation.
+       Status: **fully new research.**
+       Requires: 10a + 10b + Phase 9c.
+
+10c'  Optional Java-port additions (low priority)
+       → KoebePolyhedron.java (321 lines) — Koebe-Andreev-Thurston
+         circle packings.  Adds a fifth DCE method.
+       → ElectrostaticSphereFunctional (127 lines) — sphere
+         distribution baseline.
+       → CirclePatternLayout / CirclePatternUtility — face-circle
+         pattern layouts.
+       None of these are required for the genus-g uniformization
+       pipeline; they extend the breadth of methods.
+```
+
+---
+
+## ◼ Phase 11+ — Specialised applications (optional, deferred)
+
+> **Status:** out-of-scope for v1.0 but recorded here so that future
+> contributors don't re-discover them.  Both items live in the Java
+> repo as plugin sub-packages and would benefit from porting *only*
+> after Phase 10 is complete (they require the period-matrix and
+> fundamental-domain infrastructure to be in place first).
+
+```
+11a   Schottky uniformisation
+        Java plugin:        plugin/schottky/* (~12 Java files, ~3 000 LoC)
+        Mathematical basis: Schottky group — discrete subgroup
+                            Γ ⊂ PSL(2,ℂ) generated by hyperbolic loxodromic
+                            elements, fundamental domain a sphere with
+                            2g disjoint discs removed.
+        Use case:           "handlebody" uniformisation, complement of
+                            Phase 10c's Fuchsian-group representation
+                            (Schottky represents Riemann surfaces as
+                            quotients of domains in S² rather than of H²).
+        Requires:           Phase 10b (period matrix) + working
+                            Möbius-group machinery from Phase 7.
+        Effort:             very large (4–6 weeks) — significant Java
+                            code, complex-analytic algorithms,
+                            substantial test design.
+
+11b   Riemann maps (planar conformal mapping)
+        Java plugin:        plugin/riemannmap/* (~6 Java files, ~1 500 LoC)
+        Mathematical basis: Riemann mapping theorem — every simply
+                            connected proper subdomain of ℂ is conformally
+                            equivalent to the unit disc.  Discrete version
+                            via circle packing or Schwarz-Christoffel-like
+                            formulae.
+        Use case:           Texture mapping of bounded planar regions;
+                            classical conformal mapping for engineering
+                            applications (electrostatics, fluid flow).
+        Requires:           Phase 10b' QuasiisothermicUtility or the
+                            CP-Euclidean machinery from Phase 9a.1
+                            (depending on the chosen discrete-Riemann
+                            algorithm).
+        Effort:             large (3–4 weeks) — smaller than Schottky
+                            but still substantial.  Heavy on
+                            visualisation; consider porting only the
+                            algorithmic core.
+
+Both items are tracked here so the project memory is preserved; they
+are NOT roadmap commitments.  See `research-track.md` for the formal
+research-versus-port classification before starting either.
 ```

doc/roadmap/research-track.md

@@ -0,0 +1,317 @@
+# Research Track — items beyond the Java port
+
+> **Purpose:** This document consolidates everything in conformallab++
+> that goes *beyond* a port of `de.varylab.discreteconformal`.  Items
+> listed here are **new research**, drawn from published mathematical
+> sources (not from Java code).  They are separated from the
+> port-tracking sheet `doc/roadmap/java-parity.md` so that the porting
+> work and the research work can be planned independently.
+>
+> **Created:** 2026-05-21, after a full doc audit that identified four
+> items previously mislabelled as "ports".  This document corrects the
+> record and extends it with the explicit research plan for Phase
+> 9b-analytic.
+
+---
+
+## How to read this document
+
+Every entry has the structure:
+
+```
+### <item>
+* Mathematical source(s):  <papers with year, journal, equation/section>
+* Java reference:          NONE  (or:  partial — <class>, with the note "<what>")
+* Status:                  🔲 planned · 🟡 PR open · ✅ landed · ❌ blocked
+* Acceptance criteria:     <what tests/proofs must pass>
+* Effort:                  small / medium / large
+* Phase:                   9b-analytic / 9c / 10a / 10b / 10c
+```
+
+The phase numbers match `doc/roadmap/phases.md`.
+
+---
+
+## Items already on `main` (research, not port)
+
+### Hyper-ideal Hessian — FD (Phase 4a, ✅ landed)
+* **Mathematical source:** symmetric central difference of the
+  analytic gradient `G = (β − Θ, α − θ)` (Springborn 2020 §4 for the
+  gradient itself).
+* **Java reference:** `HyperIdealFunctional.java:295-298` declares
+  `hasHessian() { return false; }` — **Java has no Hessian at all**.
+* **Status:** ✅ landed in `code/include/hyper_ideal_hessian.hpp` Phase 4a.
+* **Why a research item, not a port:** the existing Phase 4a label
+  describes only *when* it was added to the C++ project, not Java
+  parity.  The Hessian is a conformallab++ addition.
+* **Effort:** small (already done).
+
+### Period matrix τ for genus 1 (Phase 7, ✅ landed)
+* **Mathematical source:**
+  - Sechelmann (2016) *Variational Methods for Discrete Surface
+    Parameterization* §4 — SL(2,ℤ) reduction algorithm.
+  - Bobenko-Springborn (2004) §6 — period matrix definition.
+* **Java reference:** partial — `PeriodMatrixUtility.java` exists in Java
+  with similar functionality (this *is* a port).
+* **Status:** ✅ landed in `code/include/period_matrix.hpp`.
+* **Note:** listed here only because parts of `phase-9a-validation.md`
+  reference it as research; clarification — the genus-1 period matrix is
+  a Java port, the **genus g ≥ 2** extension (Phase 10b) is research.
+
+### Möbius holonomy in SU(1,1) (Phase 7, ✅ landed)
+* **Mathematical source:** Bobenko-Springborn (2004) §5; Sechelmann
+  (2016) §3 for the SU(1,1) representation.
+* **Java reference:** partial — Java has Möbius transformations but not
+  the holonomy-around-cut-graph computation in the same form.
+* **Status:** ✅ landed in `code/include/layout.hpp` (`MobiusMap` class).
+* **Why partially research:** the half-edge `uv` storage for proper
+  seam-aware texture atlasing is new in conformallab++.
+
+### Cross-API consistency tests (Phase 7 stubs, ✅ landed)
+* `EuclideanFunctional.GradientCheck_Hessian` and the spherical analog
+  were ported from Java `@Ignore` stubs and given real bodies.
+* See `doc/architecture/phase-9a-validation.md` for the full mapping.
+
+---
+
+## Items currently on open PRs
+
+### CP-Euclidean functional (Phase 9a.1, 🟡 PR #8)
+* **Mathematical source:** Bobenko, Pinkall, Springborn (2010).
+  *Discrete conformal maps and ideal hyperbolic polyhedra.*
+  Geometry & Topology 14, 379–426.
+* **Java reference:** ✅ `CPEuclideanFunctional.java` (260 lines + 88-line
+  `CPEuclideanFunctionalTest.java`).  **This one IS a port.**
+* **Status:** 🟡 PR #8 open, 10 tests including Java-test parity.
+* **Note:** listed here because the *face-based* DOF structure is new in
+  conformallab++ (existing functionals all have vertex/edge DOFs); the
+  trait API generalisation needed for it is research-flavoured but the
+  algorithm itself is a port.
+
+### Inversive-distance functional (Phase 9a.2, 🟡 PR #8)
+* **Mathematical sources:**
+  - **Luo, F.** (2004). *Combinatorial Yamabe Flow on Surfaces.*
+    Comm. Contemp. Math. 6(5), 765–780.  → edge-length formula §3,
+    gradient identity Lemma 3.1.
+  - **Bowers, P. L. & Stephenson, K.** (2004). *Uniformizing dessins
+    and Belyĭ maps via circle packing.* Memoirs of the AMS 170(805).
+    → inversive-distance identity `I_ij = (ℓ²−r_i²−r_j²)/(2 r_i r_j)`.
+  - **Glickenstein, D.** (2011). *Discrete conformal variations and
+    scalar curvature on piecewise flat manifolds.* J. Diff. Geom.
+    87(2), 201–238.  → §5 correspondence `I_ij = cos θ_e`, eq. 4.6
+    analytic Hessian (used later by Phase 9b-analytic mirror).
+* **Java reference:** ❌ **none.**  Verified empirically:
+  ```bash
+  $ find /Users/tarikmoussa/Desktop/conformallab -iname "*nversive*"
+  (zero matches)
+  ```
+* **Status:** 🟡 PR #8 open, 11 tests including limit-case verification
+  and cross-validation with `euclidean_functional.hpp` at `u = 0`.
+* **Acceptance criteria (all met):**
+  - Three limit-cases of Luo's `ℓ²` formula at machine precision
+    (tangent, orthogonal, inside-tangent).
+  - Bowers-Stephenson round-trip identity at machine precision.
+  - FD-vs-analytic gradient check ≤ 1e-6 on triangle, quad-strip, tetra.
+  - Cross-validation `G_id(0) = G_eu(0)` at 1e-10 (Glickenstein §5).
+
+### Hyper-ideal Hessian — block-FD (Phase 9b, 🟡 PR #9)
+* **Mathematical source:** per-face locality lemma:
+  `∂G_x/∂y = Σ_{f: x,y ∈ local(f)} ∂(β or α)/∂y at f`.
+  Same gradient as Phase 4a (Springborn 2020 §4).
+* **Java reference:** ❌ none (`hasHessian() == false`).
+* **Status:** 🟡 PR #9 open, 7 tests, measured 96× speed-up over Phase 4a.
+* **Why research:** the locality lemma + 6×6 block-scatter is a
+  conformallab++ algorithmic contribution; it makes Hessian-based Newton
+  viable on meshes that the upstream Java cannot solve in reasonable
+  time at all (since it has no Hessian).
+
+---
+
+## Planned research (not yet PR)
+
+### Hyper-ideal Hessian — full analytic (Phase 9b-analytic, 🔲 planned)
+
+* **Mathematical sources:**
+  - **Schläfli, L.** (1858/60). *On the multiple integral
+    ∫dx dy …*  Quart. J. Pure & Appl. Math.  → second-order Schläfli
+    identity: `2 dV = Σ_e aₑ dαₑ + Σ_v bᵥ dβᵥ` for any hyperbolic
+    polyhedron, with corresponding bilinear differential on second
+    derivatives.
+  - **Springborn, B.** (2020). *Ideal Hyperbolic Polyhedra and
+    Discrete Uniformization.* Discrete & Comput. Geom.  → §4 for the
+    hyper-ideal energy whose gradient is `(β − Θ, α − θ)`, hence
+    Hessian is the Schläfli bilinear form's restriction to the
+    constraint surface.
+  - **Cho, Y. & Kim, H.** (1999). *On the volume formula for
+    hyperbolic tetrahedra.*  Discr. Comput. Geom. 22, 347–366.
+    → explicit derivative formulas for `∂α/∂a`, `∂α/∂b`, `∂β/∂a`,
+    `∂β/∂b` at hyperbolic tetrahedra.
+  - **Glickenstein, D.** (2011) §4 — analogous derivation for the
+    cone-vertex case (extending the formulas across the ideal /
+    hyper-ideal vertex boundary).
+
+* **Java reference:** ❌ none.
+
+* **Chain of differentiation:**
+
+  ```
+  (bᵢ, aₑ)  →  ℓᵢⱼ           via lij()      (closed form: ζ₁₃, ζ₁₄, ζ₁₅)
+            →  βᵢ            via zeta()     (law of cosines)
+            →  αᵢⱼ           via alpha_ij() (zeta + sigma_i + sigma_ij)
+  ```
+
+  Each arrow is a smooth function in the interior of its domain.  The
+  chain rule then gives, for each face:
+
+  ```
+  ∂βᵢ/∂(bⱼ, aₑ)  =  Σ_k  (∂βᵢ/∂ℓₖ) · (∂ℓₖ/∂(bⱼ, aₑ))
+  ∂αᵢⱼ/∂(bₖ, aₑ) =  (similar, with β-dependence factored)
+  ```
+
+  These are then assembled into the local 6×6 block, scattered the
+  same way as block-FD (Phase 9b).
+
+* **Acceptance criteria:**
+  - Each of the four partial-derivative formulas (`∂α/∂a`, `∂α/∂b`,
+    `∂β/∂a`, `∂β/∂b`) cross-checked against block-FD at random `x` on
+    every supported vertex configuration:
+      - all hyper-ideal vertices (general case)
+      - one ideal vertex (`σᵢ`/`σⱼ`/`σₖ` ideal branches)
+      - two ideal vertices
+  - Schläfli identity `H · x = 0` for the constant-vector `x` that
+    corresponds to a global Möbius dilation must hold numerically
+    (gauge null space).
+  - PSD property preserved (Springborn 2020 §4.3).
+  - Measured speed-up over Phase 9b block-FD ≥ 3× (asymptotic ~6×).
+  - **Correctness proof:** a short LaTeX note in
+    `doc/math/hyperideal-hessian-derivation.tex` showing each
+    Schläfli + chain-rule step with edge-cases.
+
+* **Effort:** large (10–14 days net).  Significant share of the time
+  is the formal derivation note and the per-case symbolic verification.
+
+* **Phase:** 9b-analytic.
+
+* **Why deferred:** Phase 9b (block-FD) already removes the practical
+  Hessian bottleneck (96× speed-up measured).  Analytic gives only
+  another ~6× but at substantial implementation + verification cost.
+  Land on demand when profiling on a real V > 5000 application points
+  to it as the new bottleneck.
+
+---
+
+### Inversive-distance Hessian — full analytic (Phase 9a.2-analytic, 🔲 planned)
+
+* **Mathematical source:** Glickenstein, D. (2011) eq. (4.6).
+* **Java reference:** ❌ none.
+* **Chain:** `(uᵢ, uⱼ) → ℓᵢⱼ → αᵢⱼ` with `∂ℓ²/∂u_i = 2(r_i² + I r_i r_j)`.
+* **Effort:** medium (5–7 days, less involved than HyperIdeal because
+  the chain has fewer levels and no `σ` intermediaries).
+* **Status:** 🔲 planned, mirrors Phase 9b-analytic in spirit.
+
+---
+
+### Genus g ≥ 2 fundamental domain (Phase 9c, 🔲 planned)
+* **Mathematical sources:**
+  - **Poincaré, H.** (1882). *Théorie des groupes fuchsiens.*
+    Acta Math. 1, 1–62. → 4g-gon construction.
+  - **Sechelmann** (2016) §5 for the canonical-form algorithm.
+* **Java reference:** ✅ partial — `FundamentalPolygonUtility.java`
+  (698 lines) + `CanonicalFormUtility.java` (532 lines) exist; this is
+  a port-with-research-extensions (the C++ side will need to bridge to
+  the cut-graph + holonomy infrastructure already in conformallab++).
+* **Effort:** large (10–14 days).
+* **Status:** roadmap item, no PR yet.
+
+---
+
+### Discrete holomorphic and harmonic 1-forms (Phase 10a, 🔲 planned)
+* **Mathematical sources:**
+  - **Mercat, C.** (2001). *Discrete Riemann surfaces and the Ising
+    model.* Comm. Math. Phys. 218, 177–216. → discrete complex
+    structure on a quad mesh.
+  - **Bobenko, A. I. & Springborn, B.** (2004) §6 — discrete
+    harmonic and holomorphic 1-forms on triangulated surfaces.
+* **Java reference:** ✅ `DiscreteHarmonicFormUtility.java` (657 lines)
+  + `DiscreteHolomorphicFormUtility.java` (285 lines).  Port-with-
+  research:  the C++ port can choose between literal Java translation
+  and a redesign that uses `cut_graph.hpp` + `period_matrix.hpp`
+  natively (research opportunity).
+* **Effort:** very large (3+ weeks); see java-parity.md.
+
+---
+
+### Siegel period matrix Ω ∈ H_g (Phase 10b, 🔲 planned)
+* **Mathematical sources:**
+  - **Bobenko-Springborn (2004)** §6 for the discrete formula
+    `Ω_{ij} = ∫_{b_j} ω_i`.
+  - Siegel-fundamental-domain reduction algorithm (Gottschling 1959).
+* **Java reference:** ✅ partial — `DiscreteRiemannUtility.java`
+  (186 lines).
+* **Acceptance criteria:** `Ω` symmetric, `Im(Ω) > 0`, in the standard
+  fundamental domain of `Sp(2g, ℤ)`.
+* **Effort:** medium (1 week after 10a).
+
+---
+
+### Full uniformization for genus g ≥ 2 (Phase 10c, 🔲 planned)
+* **Mathematical source:** classical (Poincaré 1883; Bers 1960);
+  Sechelmann 2016 §6 for the discrete instance.
+* **Java reference:** ❌ none — Java has the polygon + period matrix
+  pieces but does not assemble them into a Fuchsian group representation.
+* **Status:** **fully new research** — depends on 9c + 10a + 10b.
+
+---
+
+### geometry-central cross-comparison track (Optional, 🔲 exploratory)
+Three independent items (GC-1/2/3) tracked separately in
+`doc/roadmap/phases.md` and analysed in detail in
+`doc/architecture/geometry-central-comparison.md`.  They are **purely
+exploratory**, not roadmap commitments.
+
+| ID | Item | Effort |
+|---|---|---|
+| GC-1 | Output-vector cross-validation against geometry-central | small (2 days) |
+| GC-2 | Intrinsic Delaunay pre-conditioning via Ptolemaic flips | medium (1 week) |
+| GC-3 | Ptolemaic flip-based solver as alternative backend | research (Phase 10+) |
+
+---
+
+## Java features still worth porting
+
+These are tracked separately in
+[`java-parity.md`](java-parity.md), summarised here only for cross-reference:
+
+| Java class | Lines | Suggested phase | Effort |
+|---|---|---|---|
+| `FundamentalPolygonUtility` + `CanonicalFormUtility` | 698 + 532 | 9c | 2 weeks |
+| `CuttingUtility` + `SurgeryUtility` | 584 + 217 | 9c foundation | 2 weeks |
+| `DiscreteHarmonicFormUtility` | 657 | 10a | 2 weeks |
+| `DiscreteHolomorphicFormUtility` | 285 | 10a | 2 weeks |
+| `CanonicalBasisUtility` | 337 | 10a prereq | 1 week |
+| `DualityUtility` + `HomologyUtility` | 308 + 122 | 10a support | 1 week |
+| `DiscreteRiemannUtility` | 186 | 10b | small |
+| `HyperbolicCyclicFunctional` | 530 | 10b–c | 2 weeks |
+| `QuasiisothermicUtility` + `SinConditionApplication` | ~1 200 | 10b | 3 weeks |
+| `KoebePolyhedron` | 321 | 10c | 2 weeks |
+| `MobiusCenteringFunctional`, `ElectrostaticSphereFunctional` | 289 + 127 | 10c (optional) | small |
+
+Total identified backlog: ~6 500 Java lines, estimated ~5 months of work
+to bring it all over.  None of it changes the **mathematical** scope —
+all 11 items above sit within Phases 9c, 10a, 10b, 10c.
+
+---
+
+## Maintenance rule
+
+If a future PR claims "ports X from Java", **first verify** by:
+
+```bash
+find /Users/tarikmoussa/Desktop/conformallab -iname "*X*"
+grep -r "ClassName" /Users/tarikmoussa/Desktop/conformallab/src
+```
+
+If either returns zero matches, the item is research and belongs in
+**this** document, not in `java-parity.md`.  Add it with the structured
+template above, including the primary literature reference and the
+acceptance criteria.

doc/tutorials/add-inversive-distance.md

@@ -1,33 +1,84 @@
-# Tutorial: Porting the Inversive-Distance Functional (Phase 9a)
+# Tutorial: Implementing the Inversive-Distance Functional (Phase 9a.2)
 
-This is a complete, step-by-step example of how to add a new functional
-to conformallab++.  It ports `InversiveDistanceFunctional.java` from the
-Java reference implementation (Luo 2004).
+This tutorial walks through adding a **new** discrete-conformal functional
+to conformallab++.  The running example is the **vertex-based inversive-
+distance functional** of Luo (2004), used as Phase 9a.2 of the roadmap.
+
+> ## ⚠️ This is research, not a port
+>
+> An earlier draft of this document claimed this functional was a port of
+> `de.varylab.discreteconformal.functional.InversiveDistanceFunctional`.
+> **That Java class does not exist.**  Verified empirically:
+>
+> ```bash
+> $ find /Users/tarikmoussa/Desktop/conformallab -iname "*nversive*"
+> (zero results)
+> $ grep -r "InversiveDistance" /Users/tarikmoussa/Desktop/conformallab/src
+> (zero matches)
+> ```
+>
+> The closest Java cousin is `CPEuclideanFunctional.java`, which implements
+> the **face-based** circle-packing variant (Phase 9a.1).  The vertex-based
+> inversive-distance functional (this tutorial) is built **from the
+> literature**, not from a Java reference, and the correctness validation
+> is cross-checked against three sources:
+>
+> 1. **Luo, F.** (2004). *Combinatorial Yamabe Flow on Surfaces.* Comm. Contemp. Math. 6(5), 765–780.
+> 2. **Bowers, P. L. & Stephenson, K.** (2004). *Uniformizing dessins and Belyĭ maps via circle packing.* Mem. AMS 170(805).
+> 3. **Glickenstein, D.** (2011). *Discrete conformal variations and scalar curvature on piecewise flat manifolds.* J. Differential Geometry 87(2), 201–238.
+>
+> The tutorial below has been re-written to match this reality.
 
 **Prerequisite:** Read [doc/api/extending.md](../api/extending.md) first
-for the general pattern.  This tutorial fills in every detail for one
-specific case.
+for the general functional-porting pattern.  This tutorial fills in the
+mathematical and code details for one specific case.
 
 ---
 
 ## Mathematical background
 
-Inversive distance (Luo 2004) uses a different edge-length update formula:
+Inversive-distance circle packing parametrises **each vertex** by a circle
+of radius `r_i = exp(u_i)`.  Two adjacent circles have an *inversive
+distance* `I_ij` that is a fixed constant of the edge, derived once from
+the initial geometry via the Bowers–Stephenson identity:
 
 ```
-Given inversive distances I_{ij} ∈ ℝ for each edge {i,j}:
-
-  cosh(l̃_{ij}) = I_{ij} · cosh((u_i + u_j) / 2)
-               + (cosh²((u_i - u_j) / 2) - 1) · ...
+I_ij = ( ℓ_ij² − r_i² − r_j² ) / ( 2 r_i r_j )           (Bowers-Stephenson 2004)
 ```
 
-For the Euclidean version the angle formula is the same law of cosines,
-but the log-lengths Λ̃ are computed differently from the u-vector.
+Geometric interpretation of `I_ij`:
 
-**Reference:** Luo, F. (2004). *Combinatorial Yamabe Flow on Surfaces*.
-Communications in Contemporary Mathematics, 6(5), 765–780.
+| Range | Configuration |
+|---|---|
+| `I_ij = +1`            | tangent circles (Koebe-style) |
+| `I_ij ∈ (0, 1)`        | overlapping with intersection angle `φ`, `I = cos φ` |
+| `I_ij = 0`             | orthogonal circles |
+| `I_ij ∈ (−1, 0)`       | disjoint circles, inversive distance > 1 |
+| `I_ij ≤ −1`            | impossible packing |
 
-**Java source:** `de.varylab.discreteconformal.functional.InversiveDistanceFunctional`
+The edge length under a state `u` is then determined by Luo's formula:
+
+```
+ℓ_ij(u)²  =  exp(2 u_i) + exp(2 u_j) + 2 I_ij exp(u_i + u_j)
+          =  r_i² + r_j² + 2 I_ij r_i r_j                       (Luo 2004 §3)
+```
+
+The angle formula is the same numerically-stable half-tangent law of
+cosines used by `euclidean_functional.hpp`; only the way `ℓ_ij` is
+computed from `u` is different.
+
+The gradient is the standard Yamabe-flow gradient:
+
+```
+∂E/∂u_v  =  Θ_v  −  Σ_{T ∋ v}  α_v(T)                          (Luo 2004 Lemma 3.1)
+```
+
+The energy is a path integral of the gradient (Luo's 1-form is closed on
+the domain where every triangle is valid); we use the same 10-point
+Gauss-Legendre quadrature as `euclidean_functional.hpp`.
+
+The Hessian is finite-difference for the MVP; an analytic form
+(Glickenstein 2011 eq. 4.6) is documented in the research-track roadmap.
 
 ---
 
@@ -38,165 +89,212 @@ cp code/include/euclidean_functional.hpp \
    code/include/inversive_distance_functional.hpp
 ```
 
-Edit the new file:
+Modify the maps struct: replace `lambda0` (Euclidean log-length) with the
+inversive-distance constant `I_e` and the initial radius `r0` (used for
+the Bowers-Stephenson init).
 
 ```cpp
-#pragma once
-// inversive_distance_functional.hpp
-//
-// Phase 9a — Inversive-distance discrete conformal functional (Luo 2004).
-// Ported from de.varylab.discreteconformal.functional.InversiveDistanceFunctional.
-//
-// Usage: identical to euclidean_functional.hpp — replace lambda0 with
-// inversive_distance0 (the initial inversive distances per edge).
-
-#include "conformal_mesh.hpp"
-#include <Eigen/Dense>
-#include <cmath>
-
-namespace conformallab {
-
 struct InversiveDistanceMaps {
-    CGAL::Surface_mesh<CGAL::Simple_cartesian<double>::Point_3>
-        ::Property_map<Edge_index, double>   inv_dist0; ///< I_{ij} per edge
-    CGAL::Surface_mesh<CGAL::Simple_cartesian<double>::Point_3>
-        ::Property_map<Vertex_index, double> theta_v;   ///< target corner angles Θ_v
-    CGAL::Surface_mesh<CGAL::Simple_cartesian<double>::Point_3>
-        ::Property_map<Vertex_index, int>    v_idx;     ///< DOF index (-1 = pinned)
+    ConformalMesh::Property_map<Vertex_index, int>     v_idx;    // DOF index (−1 = pinned)
+    ConformalMesh::Property_map<Vertex_index, double>  theta_v;  // target cone angle
+    ConformalMesh::Property_map<Vertex_index, double>  r0;       // initial radius r_i^(0)
+    ConformalMesh::Property_map<Edge_index,   double>  I_e;      // inversive distance per edge
 };
-
-// ... (follow euclidean_functional.hpp exactly, replacing lambda0 with inv_dist0
-//      and the angle formula with the Luo (2004) version)
 ```
 
+Then implement the four entry points that any functional needs in
+conformallab++:
+
+- `setup_inversive_distance_maps(mesh)` — create maps with defaults.
+- `compute_inversive_distance_init_from_mesh(mesh, m)` — choose `r_i^(0)`
+  from the input geometry, then compute `I_ij` via Bowers-Stephenson.
+- `inversive_distance_gradient(mesh, x, m)` — Luo's `Θ − Σ α`.
+- `inversive_distance_energy(mesh, x, m)` — 10-point Gauss-Legendre path integral.
+
+For the full implementation, see `code/include/inversive_distance_functional.hpp`
+(part of PR #8).
+
 ---
 
-## Step 2 — Implement the energy, gradient, and angle formula
+## Step 2 — Edge-length kernel
 
-The Euclidean angle formula uses the law of cosines on edge lengths
-derived from log-lengths.  For inversive distance, the edge lengths
-are derived from inversive distances I_{ij} and the u-vector:
+The single new pure-math primitive is the Luo edge-length formula.  Wrap
+it in a small detail helper so the gradient function reads cleanly:
 
 ```cpp
-// Euclidean (reference):
-//   lambda_ij = lambda0_ij + u_i + u_j
-//   l_ij      = exp(lambda_ij / 2)
+namespace id_detail {
 
-// Inversive distance (Luo 2004):
-//   cosh(l̃_ij) = I_ij * cosh((u_i + u_j) / 2)   [simplified form]
-//   l̃_ij       = acosh(I_ij * cosh((u_i + u_j) / 2))
+// ℓ² = exp(2u_i) + exp(2u_j) + 2 I exp(u_i + u_j)
+// Returns -1 on degenerate input (no valid packing).
+inline double edge_length_squared(double u_i, double u_j, double I_ij) {
+    double ri = std::exp(u_i);
+    double rj = std::exp(u_j);
+    double l2 = ri*ri + rj*rj + 2.0 * I_ij * ri * rj;
+    return l2 > 0.0 ? l2 : -1.0;
+}
+
+} // namespace id_detail
 ```
 
-Then the **corner angle** at vertex k opposite edge {i,j} in triangle {i,j,k}
-is computed by the standard law of cosines from l̃_{ij}, l̃_{jk}, l̃_{ki}.
-
-The **gradient** is the same as Euclidean:
-
-```cpp
-G_v = Σ_{faces containing v} alpha_v(face, u)  −  Theta_v
-```
+This is the only place where the inversive-distance model differs from
+the Euclidean one.  All downstream code (angle computation, gradient
+accumulation, energy integration) is structurally identical.
 
 ---
 
-## Step 3 — Write the gradient-check test
+## Step 3 — Reuse `euclidean_angles()`
 
-Create `code/tests/cgal/test_inversive_distance.cpp`:
+The half-tangent law of cosines is independent of how lengths were
+obtained.  Feed `log(ℓ²)` to the existing helper to compute the three
+corner angles per face:
 
 ```cpp
-#include "inversive_distance_functional.hpp"
-#include "mesh_factory.hpp"
-#include <gtest/gtest.h>
+auto fa = euclidean_angles(std::log(l12sq), std::log(l23sq), std::log(l31sq));
+```
 
-// Finite-difference gradient check: copy the pattern from
-// test_euclidean_functional.cpp :: EuclideanFunctional.GradientCheck_Triangle
-TEST(InversiveDistance, GradientCheck_Triangle)
-{
-    // Build a single equilateral triangle (open mesh, no boundary issues).
-    ConformalMesh mesh = MeshFactory::make_open_mesh(MeshFactory::Kind::triangle);
-    InversiveDistanceMaps maps = setup_inversive_distance_maps(mesh);
-    compute_inversive_distance0_from_mesh(mesh, maps);  // I_ij from 3D edge lengths
+This is the **non-trivial reuse** that justifies the structural similarity
+to the Euclidean functional — we get the law-of-cosines numerics for free,
+and only the edge-length input changes.
 
-    const int n = /* count free DOFs */;
-    std::vector<double> x0(n, 0.0);
-    constexpr double eps = 1e-5;
+---
 
-    auto G  = inversive_distance_gradient(mesh, x0, maps);
+## Step 4 — Validation tests
 
-    for (int i = 0; i < n; ++i) {
-        auto xp = x0; xp[i] += eps;
-        auto xm = x0; xm[i] -= eps;
-        double Ep = inversive_distance_energy(mesh, xp, maps);
-        double Em = inversive_distance_energy(mesh, xm, maps);
-        double fd = (Ep - Em) / (2.0 * eps);
-        EXPECT_NEAR(G[i], fd, 1e-6) << "gradient mismatch at DOF " << i;
+The acceptance criteria for this functional are stricter than for a Java
+port because there is no reference implementation to compare against.  We
+need **three independent validations**:
+
+### 4.1  Limit-case edge lengths
+
+Each of Luo's special cases (`I = 1` tangent, `I = 0` orthogonal,
+`I = −1` inside-tangent) gives a closed-form `ℓ` that must be reproduced
+to machine precision:
+
+```cpp
+TEST(InversiveDistanceFunctional, EdgeLengthFormula_TangentialLimit) {
+    // r_i=1, r_j=2, I=1:  ℓ² = 1 + 4 + 2·1·1·2 = 9 ⇒ ℓ = 3 = r_i + r_j
+    double l2 = id_detail::edge_length_squared(0.0, std::log(2.0), 1.0);
+    EXPECT_NEAR(std::sqrt(l2), 3.0, 1e-12);
+}
+```
+
+Three such tests cover the diagnostic special cases.
+
+### 4.2  Bowers-Stephenson round-trip
+
+The initialisation `compute_inversive_distance_init_from_mesh` must be
+self-consistent: starting from `(ℓ_3d, r_i, r_j)` and computing `I_ij`,
+the round-trip back through Luo's formula must give the original `ℓ`.
+
+```cpp
+TEST(InversiveDistanceFunctional, BowersStephensonRoundTrip) {
+    auto mesh = make_triangle();
+    auto m = setup_inversive_distance_maps(mesh);
+    compute_inversive_distance_init_from_mesh(mesh, m);
+
+    for (auto e : mesh.edges()) {
+        double l_3d  = /* mesh 3-D edge length */;
+        double ri    = m.r0[mesh.source(mesh.halfedge(e))];
+        double rj    = m.r0[mesh.target(mesh.halfedge(e))];
+        double l_rec = std::sqrt(ri*ri + rj*rj + 2.0 * m.I_e[e] * ri * rj);
+        EXPECT_NEAR(l_rec, l_3d, 1e-12);
     }
 }
 ```
 
-Run with:
+### 4.3  FD-vs-analytic gradient check
 
-```bash
-./build/conformallab_cgal_tests --gtest_filter="InversiveDistance.*"
+Standard pattern from every functional in conformallab++ — see
+`test_euclidean_functional.cpp`.  Compare the analytic gradient
+to a symmetric finite difference of the energy.
+
+### 4.4  Cross-validation against `euclidean_functional.hpp`
+
+At `u = 0`, both functionals reconstruct the input 3-D edge length
+exactly (Euclidean via `compute_lambda0`, inversive distance via
+Bowers-Stephenson).  Therefore the actual angle sums are identical,
+and the two gradients (with default `Θ_v = 2π`) must match component-wise:
+
+```cpp
+TEST(InversiveDistanceFunctional, AngleDefectAtU0_AgreesWithEuclideanAtU0) {
+    auto G_id = inversive_distance_gradient(mesh, /*x=0*/, m_id);
+    auto G_eu = euclidean_gradient            (mesh, /*x=0*/, m_eu);
+    for (size_t i = 0; i < G_id.size(); ++i)
+        EXPECT_NEAR(G_id[i], G_eu[i], 1e-10);
+}
 ```
 
+This is the empirical statement of Glickenstein 2011 §5: different
+parametrisations of the same initial discrete metric produce the same
+Newton-time-zero gradient.
+
 ---
 
-## Step 4 — Register in CMakeLists
+## Step 5 — Register the tests
 
-Add to `code/tests/cgal/CMakeLists.txt` inside the `add_executable` block:
+In `code/tests/cgal/CMakeLists.txt`:
 
 ```cmake
-    # ── Phase 9a: Inversive-distance functional ────────────────────────────────
-    test_inversive_distance.cpp
+    # ── Phase 9a.2: InversiveDistance (Luo 2004 + Glickenstein 2011) ─────────
+    #    Vertex-based inversive-distance circle-packing functional.  No Java
+    #    reference; implemented from the literature.  Cross-validated against
+    #    EuclideanCyclicFunctional at the natural initial geometry (u = 0).
+    test_inversive_distance_functional.cpp
+```
+
+Run:
+
+```bash
+ctest --test-dir build -R "InversiveDistance" --output-on-failure
 ```
 
 ---
 
-## Step 5 — Add a Newton wrapper
+## Step 6 — Newton solver
 
-In `code/include/newton_solver.hpp` add:
+Once the functional passes its tests, wire a Newton wrapper into
+`newton_solver.hpp`:
 
 ```cpp
-/// Solve the inversive-distance conformal problem.
-/// \see newton_euclidean() — identical structure.
 inline NewtonResult newton_inversive_distance(
     ConformalMesh&                  mesh,
     std::vector<double>             x0,
     const InversiveDistanceMaps&    m,
     double                          tol      = 1e-8,
-    int                             max_iter = 200)
-{
-    // Copy newton_euclidean() exactly, replacing euclidean_* with
-    // inversive_distance_*.  The Hessian is PSD (Luo 2004, Thm. 1),
-    // so SimplicialLDLT with SparseQR fallback applies directly.
-}
+    int                             max_iter = 200);
 ```
 
+The body is structurally identical to `newton_euclidean()` — same
+SimplicialLDLT + SparseQR fallback, same termination test.  Only the
+inner gradient / Hessian calls differ.
+
 ---
 
-## Step 6 — Verify against Java output
+## Checklist for a new functional
 
-The Java library outputs text results for a triangulated torus.  To compare:
-
-1. Run Java ConformalLab on the same OFF mesh with Inversive-Distance mode.
-2. Record the final gradient norm and angle sums.
-3. Run the C++ equivalent and check:
-
-```cpp
-EXPECT_LT(res.grad_inf_norm, 1e-8);
-EXPECT_LT(res.iterations, 50);  // inversive-distance converges faster than hyper-ideal
-```
-
-**Java reference:** `InversiveDistanceFunctionalTest.java` in `de.varylab.discreteconformal.test`
+- [ ] `code/include/<name>_functional.hpp` compiles
+- [ ] Limit-case edge-length tests pass at machine precision
+- [ ] Round-trip identity (init ⇄ length formula) verified
+- [ ] FD-vs-analytic gradient check passes on triangle, quad strip, tetra
+- [ ] Cross-validation test against an existing functional at `u = 0`
+- [ ] Newton wrapper added to `newton_solver.hpp`
+- [ ] Registered in `code/tests/cgal/CMakeLists.txt`
+- [ ] `doc/roadmap/java-parity.md` updated (port status or research note)
+- [ ] `doc/math/references.md` extended with the primary paper(s)
+- [ ] If this is *new research* beyond Java: add an entry in
+      `doc/roadmap/research-track.md` with citations and acceptance criteria
 
 ---
 
-## Checklist
+## How to know if it's a port or research
 
-- [ ] `code/include/inversive_distance_functional.hpp` compiles
-- [ ] `GradientCheck_Triangle` passes
-- [ ] `GradientCheck_OpenMesh` passes (copy from Euclidean tests)
-- [ ] Newton converges on `torus_4x4.off`
-- [ ] Result matches Java output (gradient norm < 1e-8 on same mesh)
-- [ ] Registered in `CMakeLists.txt`
-- [ ] `doc/roadmap/java-parity.md` updated: Phase 9a → ✅
+Run the local Java-repo check **first** before writing any tutorial doc:
+
+```bash
+find /Users/tarikmoussa/Desktop/conformallab -iname "*<feature>*"
+grep -r "<ClassName>" /Users/tarikmoussa/Desktop/conformallab/src
+```
+
+If both return zero matches, the feature is **not** in Java and any C++
+implementation is **new research**, not a port.  The tutorial framing and
+the `doc/roadmap/research-track.md` entry should reflect this from day one.

scripts/try_it.sh

@@ -10,8 +10,8 @@
 #   bash scripts/try_it.sh
 #
 # Expected output (last lines):
-#   [PASS]  173 CGAL tests pass, 1 skipped
-#   [PASS]  36  non-CGAL tests pass
+#   [PASS]  227 CGAL tests pass, 0 skipped
+#   [PASS]  23  non-CGAL tests pass
 #   [EXAMPLE] Converged in N iterations. ||G||_inf < 1e-9
 
 set -euo pipefail