Regenerate 9-vertex LLM benchmark with Bloch-Wigner and correct vertex config

Key improvements:
- Use Bloch-Wigner dilogarithm for precise volume computation
- Fix vertex configuration: 0, 1, ∞ + 6 free (was incorrectly 0, 1, i, ∞ + 5)
- Add use_bloch_wigner parameter to ideal_poly_volume_via_delaunay()
- Update optimization script with correct vertex counts and improved docs
- New optimal volume: 8.162538347504972 (precise to 15 digits)

Bloch-Wigner is ~2×10⁻⁵ more accurate than Lobachevsky with 256 terms.

🤖 Generated with Claude Code

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

examples/optimization/9vertex/optimize_9vertex_for_llm_test.py

@@ -2,7 +2,9 @@
 """
 Find optimal 9-vertex ideal polyhedron for LLM benchmark test.
 
-9 vertices = 0, 1, i, ∞ + 5 free vertices = 10 real parameters
+9 vertices = 0, 1, ∞ + 6 free vertices = 12 real parameters
+
+Uses Bloch-Wigner dilogarithm for precise volume computation.
 """
 
 import numpy as np
@@ -20,12 +22,15 @@ from ideal_poly_volume_toolkit.geometry import ideal_poly_volume_via_delaunay
 
 
 def compute_volume_objective(params, n_free):
-    """Objective function: negative volume for minimization."""
+    """Objective function: negative volume for minimization.
+
+    Uses Bloch-Wigner dilogarithm for precise, fast volume computation.
+    """
     real_parts = params[:n_free]
     imag_parts = params[n_free:]
 
-    # Fixed vertices: 0, 1, i
-    z_fixed = np.array([0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 1.0j])
+    # Fixed vertices: 0, 1 (∞ is implicit in the triangulation)
+    z_fixed = np.array([0.0 + 0.0j, 1.0 + 0.0j])
 
     # Free vertices
     z_free = np.array([complex(r, i) for r, i in zip(real_parts, imag_parts)])
@@ -34,7 +39,8 @@ def compute_volume_objective(params, n_free):
     z_all = np.concatenate([z_fixed, z_free])
 
     try:
-        vol = ideal_poly_volume_via_delaunay(z_all, mode="fast", series_terms=64)
+        # Use Bloch-Wigner dilogarithm for precise computation
+        vol = ideal_poly_volume_via_delaunay(z_all, use_bloch_wigner=True)
         return -vol  # Negative for maximization
     except:
         return 1e10  # Penalty for invalid configurations
@@ -42,12 +48,12 @@ def compute_volume_objective(params, n_free):
 
 def main():
     print("=" * 70)
-    print("Optimizing 9-vertex ideal polyhedron (5 free + 0,1,i,∞)")
+    print("Optimizing 9-vertex ideal polyhedron (6 free + 0,1,∞)")
     print("=" * 70)
 
-    n_free_vertices = 5
+    n_free_vertices = 6  # 9 total = 0, 1, ∞ + 6 free
     n_params = n_free_vertices * 2
-    n_trials = 5  # Reduced from 10 for speed
+    n_trials = 10  # More trials for better optimization
 
     # Bounds for optimization
     bounds = [(-2, 2)] * n_params
@@ -97,15 +103,15 @@ def main():
     real_parts = best_config[:n_free]
     imag_parts = best_config[n_free:]
 
-    z_fixed = np.array([0.0 + 0.0j, 1.0 + 0.0j, 0.0 + 1.0j])
+    z_fixed = np.array([0.0 + 0.0j, 1.0 + 0.0j])
     z_free = np.array([complex(r, i) for r, i in zip(real_parts, imag_parts)])
     z_all = np.concatenate([z_fixed, z_free])
 
     print("\nVertices:")
-    print("  Fixed: 0, 1, i, ∞")
+    print("  Fixed: 0, 1, ∞")
     print("  Free:")
     for i, z in enumerate(z_free):
-        print(f"    z{i+3}: {z.real:.6f} + {z.imag:.6f}i")
+        print(f"    z{i+2}: {z.real:.6f} + {z.imag:.6f}i")
 
     # Save results
     result_data = {
@@ -114,15 +120,15 @@ def main():
             "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             "n_vertices": 9,
             "n_trials": n_trials,
-            "best_seed": int(best_seed)
+            "best_seed": int(best_seed),
+            "computation_method": "Bloch-Wigner dilogarithm"
         },
         "optimal_configuration": {
             "volume": float(best_volume),
             "vertices": {
                 "fixed": [
                     {"real": 0.0, "imag": 0.0},
-                    {"real": 1.0, "imag": 0.0},
-                    {"real": 0.0, "imag": 1.0}
+                    {"real": 1.0, "imag": 0.0}
                 ],
                 "free": [
                     {"real": float(z.real), "imag": float(z.imag)}

ideal_poly_volume_toolkit/geometry.py

@@ -306,10 +306,34 @@ def ideal_poly_volume_via_hull_project_back(W, index_inf=0, mode="fast", dps=120
         total += triangle_volume_from_points(z1, z2, z3, mode=mode, series_terms=series_terms, dps=dps)
     return total
 
-def ideal_poly_volume_via_delaunay(z_finite_complex: np.ndarray, mode="fast", dps=120, series_terms=64):
+def ideal_poly_volume_via_delaunay(z_finite_complex: np.ndarray, mode="fast", dps=120, series_terms=64, use_bloch_wigner=False):
+    """
+    Compute volume of ideal polyhedron using Delaunay triangulation.
+
+    Args:
+        z_finite_complex: Array of finite vertices (complex numbers)
+        mode: "fast" (series) or "exact" (mpmath) - only used if use_bloch_wigner=False
+        dps: Decimal precision for exact mode
+        series_terms: Number of terms for fast mode
+        use_bloch_wigner: If True, use Bloch-Wigner dilogarithm (most accurate)
+
+    Returns:
+        Total volume as float
+    """
     idx_tris = delaunay_triangulation_indices(z_finite_complex)
     total = 0.0
-    for (i,j,k) in idx_tris:
-        z1, z2, z3 = z_finite_complex[i], z_finite_complex[j], z_finite_complex[k]
-        total += triangle_volume_from_points(z1, z2, z3, mode=mode, series_terms=series_terms, dps=dps)
+
+    if use_bloch_wigner:
+        # Use Bloch-Wigner dilogarithm (most accurate and fast)
+        for (i,j,k) in idx_tris:
+            z1 = torch.tensor(z_finite_complex[i], dtype=torch.complex128)
+            z2 = torch.tensor(z_finite_complex[j], dtype=torch.complex128)
+            z3 = torch.tensor(z_finite_complex[k], dtype=torch.complex128)
+            total += triangle_volume_bloch_wigner(z1, z2, z3).item()
+    else:
+        # Use Lobachevsky function (series or exact)
+        for (i,j,k) in idx_tris:
+            z1, z2, z3 = z_finite_complex[i], z_finite_complex[j], z_finite_complex[k]
+            total += triangle_volume_from_points(z1, z2, z3, mode=mode, series_terms=series_terms, dps=dps)
+
     return total

results/data/9vertex_optimal_for_llm_test.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6bf4eef136f1f1bf2e77dc6e98b543d4e2fd841c24fc9e77f6016bb25c6f1d6c
-size 1501
+oid sha256:0eed32f8c44a298fce4d90b50bac935a636ea379e32d101a51c487b178197e25
+size 1608