Major reorganization and feature additions

## Reorganization
- Moved all examples to organized examples/ directory by category
- examples/distributions/ (tetrahedron, 5-vertex, 6-vertex, euclidean)
- examples/optimization/ (7-vertex, 12-vertex, 20-vertex, platonic)
- examples/visualization/
- examples/analysis/
- Created bin/ directory for command-line tools and GUI
- Created results/ directory with data/, plots/, logs/ subdirectories
- Moved documentation to docs/ directory
- Cleaned up 91+ root-level files into organized structure

## New Features

### Command-Line Tools (bin/)
- optimize_polyhedron.py: General optimization wrapper with canonical output
- analyze_distribution.py: Distribution analysis wrapper
- gui.py: Comprehensive Gradio web interface

### Gradio GUI (bin/gui.py)
- 5-tab interface: Optimization, Distribution, Visualization, Arithmeticity, About
- Parallel optimization using all CPU cores (64-core support)
- Real-time progress tracking
- 3D visualization in Klein and Poincaré ball models
- Holonomy computation (Penner-Rivin algorithm)
- Symmetry group computation (via pynauty/nauty)
- Load optimization results across tabs

### Core Modules
- visualization.py: 3D visualization with correct Klein→Poincaré transformation
- Fixed algorithm: subdivide in Klein model, map to Poincaré
- Mesh-based rendering showing curved hyperbolic faces
- Support for both Klein and Poincaré ball models
- rivin_holonomy.py: Penner-Rivin holonomy computation
- pointset_to_fuchsian.py: Full Fuchsian group pipeline
- symmetry.py: Automorphism group computation using nauty

## Performance Optimizations
- Parallel workers: Use all CPU cores for differential evolution (77x speedup)
- Reduced series terms: 96→64 (negligible accuracy loss, 15% faster)
- Adaptive population size: Automatically reduces for high vertex counts
- CPU-only: GPU is 2.7x slower due to transfer overhead for small tensors

### Benchmark Results (64 cores)
- 7-vertex: ~10 seconds for 10 trials (was ~5 minutes)
- 20-vertex: ~2 minutes for 10 trials (was ~2.8 hours)

## Bug Fixes
- Fixed Gradio State management (moved inside Blocks context)
- Fixed BytesIO→PIL Image conversion for plot display
- Fixed Klein→Poincaré transformation in visualization
- Fixed pickling issue with lambda functions (use functools.partial)
- Fixed distribution vertex count display (shows total vs random)

## Interface Improvements
- Number input for vertices (was limited to 20, now up to 100)
- Clearer labels and info messages
- Subdivision level control (0-5, default 3)
- Better error messages and validation

## Dependencies Added
- gradio: Web interface
- pynauty: Symmetry group computation
- plotly: Interactive 3D plots
- PIL/Pillow: Image handling

🤖 Generated with Claude Code
https://claude.com/claude-code

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

README.md

@@ -1 +1,159 @@
-See examples in ideal_poly_volume_toolkit/examples.
+# Ideal Polyhedra Volume Toolkit
+
+A Python toolkit for computing and optimizing volumes of ideal hyperbolic polyhedra using Delaunay triangulation, hull projection, and fast/exact Lobachevsky functions.
+
+## Installation
+
+Install the package in development mode:
+
+```bash
+pip install -e .
+```
+
+Dependencies: `numpy`, `scipy`, `mpmath`, `torch`
+
+## Project Structure
+
+```
+ideal_poly_volume_toolkit/
+├── ideal_poly_volume_toolkit/   # Core package
+│   ├── geometry.py              # Core geometry and volume computation functions
+│   ├── visualization.py         # 3D visualization utilities
+│   ├── rivin_holonomy.py        # Penner-Rivin holonomy computation
+│   ├── pointset_to_fuchsian.py  # Full Fuchsian group pipeline
+│   └── __init__.py
+│
+├── bin/                         # Command-line tools and GUI
+│   ├── gui.py                   # 🎨 Interactive Gradio web interface
+│   ├── optimize_polyhedron.py  # General optimization wrapper
+│   ├── analyze_distribution.py # Distribution analysis wrapper
+│   └── README.md
+│
+├── examples/                    # Organized example scripts
+│   ├── distributions/          # Distribution analysis examples
+│   │   ├── tetrahedron/       # Tetrahedron volume distributions
+│   │   ├── five_vertex/       # 5-vertex polyhedra distributions
+│   │   ├── six_vertex/        # 6-vertex polyhedra distributions
+│   │   └── euclidean/         # Euclidean tetrahedra analysis
+│   ├── optimization/           # Optimization examples by vertex count
+│   │   ├── 7vertex/           # 7-vertex optimization (octahedron variants)
+│   │   ├── 12vertex/          # 12-vertex optimization
+│   │   ├── 20vertex/          # 20-vertex optimization (icosahedron)
+│   │   └── platonic/          # Platonic solid analysis
+│   ├── visualization/          # Visualization scripts
+│   └── analysis/               # Statistical and theoretical analysis
+│
+├── scripts/                     # Active research/development scripts
+├── results/                     # Output files
+│   ├── data/                   # JSON configuration files
+│   ├── plots/                  # PNG visualization outputs
+│   └── logs/                   # Optimization logs
+└── docs/                        # Documentation
+    ├── RESULTS_SUMMARY.md
+    └── PLATONIC_MAXIMALITY_RESULTS.md
+```
+
+## Core Functionality
+
+### `ideal_poly_volume_toolkit.geometry` - Volume Computation
+
+- **Stereographic projection**: `lift_to_sphere_with_inf()`, `inverse_stereographic_from_sphere_pts()`
+- **Triangulation**: `delaunay_triangulation_indices()`, `hull_tris_projected_back()`
+- **Lobachevsky function**: `lob_fast()` (PyTorch autodiff), `lob_exact()` (mpmath high-precision)
+- **Volume computation**:
+  - `triangle_volume_from_points()` - Single triangle volume
+  - `ideal_poly_volume_via_delaunay()` - Full polyhedron via Delaunay
+  - `ideal_poly_volume_via_hull_project_back()` - Full polyhedron via convex hull
+
+### `ideal_poly_volume_toolkit.rivin_holonomy` - Penner-Rivin Algorithm
+
+- **Holonomy computation**: `generators_from_triangulation()` - Compute Fuchsian group generators
+- **Arithmeticity testing**: Check if polyhedra have arithmetic holonomy (traces in number fields)
+- **Triangulation structures**: `Triangulation` class for managing ideal triangulations
+
+### `ideal_poly_volume_toolkit.pointset_to_fuchsian` - Full Pipeline
+
+- **Group computation**: `group_from_pointset()` - Convert point sets to Fuchsian groups
+- **Trace field analysis**: `invariant_trace_field_signature()` - Analyze arithmetic properties
+- **Visualization**: `render_snapshot()` - High-quality rendering with iridescence and transparency
+- **Mesh export**: `hull_to_mesh()`, `export_mesh_obj()` - Export to OBJ format
+
+## Quick Start
+
+### 🎨 Interactive GUI (Easiest)
+
+The fastest way to get started is with the Gradio web interface:
+
+```bash
+python bin/gui.py
+```
+
+Then open your browser to `http://127.0.0.1:7860`
+
+**Features:**
+- Interactive optimization with real-time progress
+- Distribution analysis with automatic plotting
+- 3D visualization in sphere and Poincaré ball models
+- No need to remember command-line arguments!
+
+### Command-Line Tools
+
+For scripting and batch processing, use the wrapper scripts in `bin/`:
+
+```bash
+# Optimize a 7-vertex polyhedron (10 trials)
+python bin/optimize_polyhedron.py --vertices 7 --trials 10
+
+# Analyze volume distribution for tetrahedra
+python bin/analyze_distribution.py --vertices 4 --samples 10000
+
+# Get help on any tool
+python bin/optimize_polyhedron.py --help
+```
+
+See `bin/README.md` for detailed usage and examples.
+
+### Computing a volume (Python API)
+
+```python
+import numpy as np
+from ideal_poly_volume_toolkit.geometry import ideal_poly_volume_via_delaunay
+
+# Define vertices in the complex plane (stereographic projection)
+vertices = np.array([0.0+0.0j, 1.0+0.0j, 0.5+0.866j])
+volume = ideal_poly_volume_via_delaunay(vertices)
+print(f"Volume: {volume}")
+```
+
+### Running examples
+
+Examples are organized by topic. For instance:
+
+```bash
+# 7-vertex optimization
+cd examples/optimization/7vertex
+python optimize_7vertex.py
+
+# Tetrahedron distribution analysis
+cd examples/distributions/tetrahedron
+python tetrahedron_volume_distribution.py
+
+# Visualization
+cd examples/visualization
+python visualize_golden_config.py
+```
+
+## Key Examples
+
+- **7-vertex optimization**: Testing the hypothesis that the maximum volume is an octahedron with one stellated face
+- **20-vertex optimization**: Finding maximal volume configurations for icosahedron-like polyhedra
+- **Distribution analysis**: Statistical analysis of volume distributions for various polyhedra
+- **Platonic solids**: Analysis of regular polyhedra and their perturbations
+
+## Research Results
+
+See `docs/RESULTS_SUMMARY.md` and `docs/PLATONIC_MAXIMALITY_RESULTS.md` for detailed findings.
+
+## License
+
+See LICENSE file.

bin/.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

bin/README.md

@@ -0,0 +1,153 @@
+# Command-Line Tools
+
+This directory contains general-purpose wrapper scripts and GUI for common tasks.
+
+## 🎨 Interactive GUI
+
+### `gui.py`
+
+**Launch the interactive Gradio web interface:**
+
+```bash
+# Local only (default)
+python bin/gui.py
+
+# Create shareable public link
+python bin/gui.py --share
+
+# Custom port
+python bin/gui.py --port 8080
+
+# Get help
+python bin/gui.py --help
+```
+
+The GUI will open in your browser at `http://127.0.0.1:7860` (or your custom port)
+
+**Features:**
+- **Optimization Tab**: Find maximal volume configurations with adjustable parameters
+  - Number of vertices, trials, iterations
+  - Real-time progress tracking
+  - Automatic result saving
+
+- **Distribution Analysis Tab**: Sample random configurations and analyze statistics
+  - Configurable sample size
+  - Automatic histogram generation
+  - Statistics: mean, median, quartiles, std dev
+
+- **3D Visualization Tab**: Interactive polyhedron visualization
+  - Delaunay triangulation (2D complex plane)
+  - Sphere projection (3D)
+  - Poincaré ball model (3D hyperbolic geometry)
+  - Adjustable subdivision for smooth surfaces
+  - Load results directly from optimization
+
+- **About Tab**: Documentation and usage tips
+
+**Advantages:**
+- No need to remember command-line arguments
+- Visual feedback and progress bars
+- Interactive 3D plots you can rotate and zoom
+- Seamless workflow: optimize → visualize
+- Beginner-friendly interface
+
+---
+
+## Available Tools
+
+### `optimize_polyhedron.py`
+
+General-purpose optimization wrapper for finding maximal volume configurations.
+
+**Usage:**
+```bash
+# Optimize a 7-vertex polyhedron with 10 trials
+python bin/optimize_polyhedron.py --vertices 7 --trials 10
+
+# Optimize 12-vertex with more iterations
+python bin/optimize_polyhedron.py --vertices 12 --trials 20 --maxiter 300
+
+# Custom output location
+python bin/optimize_polyhedron.py --vertices 20 --trials 5 --output my_results.json
+```
+
+**Arguments:**
+- `--vertices, -v`: Number of vertices (required, must be >= 4)
+- `--trials, -t`: Number of optimization trials (default: 10)
+- `--maxiter, -m`: Max iterations per trial (default: 200)
+- `--popsize, -p`: Population size for differential evolution (default: 15)
+- `--output, -o`: Output JSON file (default: auto-generated in results/data/)
+- `--seed, -s`: Random seed base (default: 42)
+
+**Output:**
+Saves a JSON file with:
+- Best configuration found (volume, parameters, vertex coordinates)
+- Combinatorial structure (faces, edges, Euler characteristic)
+- All trial results
+
+---
+
+### `analyze_distribution.py`
+
+Analyze volume distributions by sampling random polyhedra configurations.
+
+**Usage:**
+```bash
+# Analyze 10,000 random tetrahedra
+python bin/analyze_distribution.py --vertices 4 --samples 10000
+
+# Analyze with custom output
+python bin/analyze_distribution.py --vertices 6 --samples 50000 --output my_plot.png
+
+# Include reference volume and save data
+python bin/analyze_distribution.py --vertices 5 --samples 20000 --reference 3.66 --data distribution_data.json
+```
+
+**Arguments:**
+- `--vertices, -v`: Number of vertices (required, must be >= 3)
+- `--samples, -n`: Number of random samples (default: 10000)
+- `--seed, -s`: Random seed (default: 42)
+- `--output, -o`: Output plot file (default: auto-generated in results/plots/)
+- `--data, -d`: Output data JSON file (optional)
+- `--reference, -r`: Reference volume to mark on plot (optional)
+- `--series-terms`: Number of series terms for Lobachevsky function (default: 96)
+
+**Output:**
+- PNG plot with histogram and box plot
+- Optional JSON file with statistics and all volume samples
+
+---
+
+## Examples
+
+### Quick Optimization Run
+```bash
+# Find best 7-vertex configuration with 5 quick trials
+python bin/optimize_polyhedron.py -v 7 -t 5 --maxiter 100
+```
+
+### Distribution Analysis Pipeline
+```bash
+# Analyze distribution, save data, and use max volume as reference
+python bin/analyze_distribution.py -v 5 -n 10000 --data dist_data.json
+```
+
+### Reproduce Research Results
+```bash
+# Optimize different vertex counts systematically
+for n in 5 6 7 8; do
+    python bin/optimize_polyhedron.py -v $n -t 20 -m 300
+done
+```
+
+---
+
+## Output Conventions
+
+All outputs are saved to standardized locations:
+
+- **Optimization results**: `results/data/{n}vertex_optimization_TIMESTAMP.json`
+- **Distribution plots**: `results/plots/{n}vertex_distribution_TIMESTAMP.png`
+- **Distribution data**: `results/data/{n}vertex_distribution_TIMESTAMP.json`
+
+Timestamps are in format: `YYYYMMDD_HHMMSS`

bin/analyze_distribution.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+General-purpose wrapper for analyzing volume distributions of ideal polyhedra.
+
+Usage:
+    python bin/analyze_distribution.py --vertices 4 --samples 10000
+    python bin/analyze_distribution.py --vertices 6 --samples 50000 --output custom_plot.png
+"""
+
+import argparse
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+from datetime import datetime
+from pathlib import Path
+import sys
+
+from ideal_poly_volume_toolkit.geometry import (
+    delaunay_triangulation_indices,
+    ideal_poly_volume_via_delaunay,
+)
+
+
+def sample_random_vertex():
+    """
+    Sample a uniform random point on the unit sphere and project to complex plane.
+    Uses stereographic projection from north pole.
+    """
+    # Sample uniform point on sphere using Gaussian method
+    vec = np.random.randn(3)
+    vec = vec / np.linalg.norm(vec)
+    x, y, z = vec
+
+    # Skip near north pole (maps to infinity)
+    if z > 0.999:
+        return None
+
+    # Stereographic projection
+    w = complex(x/(1-z), y/(1-z))
+    return w
+
+
+def analyze_distribution(n_vertices, n_samples, seed=42, series_terms=96):
+    """
+    Analyze volume distribution for n_vertices polyhedra.
+
+    Args:
+        n_vertices: Number of vertices (must be >= 3)
+        n_samples: Number of random configurations to sample
+        seed: Random seed
+        series_terms: Number of terms for Lobachevsky function approximation
+
+    Returns:
+        dict with volumes and statistics
+    """
+    np.random.seed(seed)
+
+    # First 3 vertices are fixed to break symmetry
+    fixed_vertices = [complex(0, 0), complex(1, 0), complex(0, 1)]
+    n_random = n_vertices - 3
+
+    if n_random < 0:
+        raise ValueError("Need at least 3 vertices")
+
+    volumes = []
+    print(f"Sampling {n_samples} random {n_vertices}-vertex configurations...")
+
+    for i in range(n_samples):
+        if (i + 1) % (n_samples // 10) == 0:
+            print(f"  Progress: {i + 1}/{n_samples} ({100*(i+1)/n_samples:.1f}%)")
+
+        # Build configuration
+        vertices = fixed_vertices.copy()
+
+        # Add random vertices
+        for _ in range(n_random):
+            v = sample_random_vertex()
+            if v is None:
+                continue  # Skip degenerate samples
+
+            # Skip if too close to existing vertices
+            too_close = False
+            for existing in vertices:
+                if abs(v - existing) < 0.01:
+                    too_close = True
+                    break
+            if too_close:
+                continue
+
+            vertices.append(v)
+
+        # Only proceed if we have the right number of vertices
+        if len(vertices) != n_vertices:
+            continue
+
+        # Compute volume
+        try:
+            vertices_np = np.array(vertices, dtype=np.complex128)
+            vol = ideal_poly_volume_via_delaunay(
+                vertices_np, mode='fast', series_terms=series_terms
+            )
+
+            # Sanity check
+            if vol > 0 and vol < 1000:
+                volumes.append(vol)
+        except:
+            pass  # Skip invalid configurations
+
+    volumes = np.array(volumes)
+
+    if len(volumes) == 0:
+        raise ValueError("No valid configurations found!")
+
+    print(f"\nSuccessfully analyzed {len(volumes)} valid configurations")
+
+    return {
+        'volumes': volumes,
+        'n_samples_requested': n_samples,
+        'n_valid': len(volumes),
+        'mean': np.mean(volumes),
+        'median': np.median(volumes),
+        'std': np.std(volumes),
+        'min': np.min(volumes),
+        'max': np.max(volumes),
+        'q25': np.percentile(volumes, 25),
+        'q75': np.percentile(volumes, 75),
+    }
+
+
+def plot_distribution(volumes, stats, n_vertices, output_file, reference_volume=None):
+    """Create histogram plot of volume distribution."""
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
+
+    # Histogram
+    ax1.hist(volumes, bins=50, density=True, alpha=0.7,
+             color='steelblue', edgecolor='black', linewidth=0.5)
+    ax1.axvline(stats['mean'], color='red', linestyle='--', linewidth=2,
+                label=f"Mean: {stats['mean']:.4f}")
+    ax1.axvline(stats['median'], color='green', linestyle='--', linewidth=2,
+                label=f"Median: {stats['median']:.4f}")
+
+    if reference_volume is not None:
+        ax1.axvline(reference_volume, color='orange', linestyle='--', linewidth=2,
+                    label=f"Reference: {reference_volume:.4f}")
+
+    ax1.set_xlabel('Volume', fontsize=12)
+    ax1.set_ylabel('Density', fontsize=12)
+    ax1.set_title(f'{n_vertices}-Vertex Ideal Polyhedra Volume Distribution', fontsize=14)
+    ax1.legend(fontsize=10)
+    ax1.grid(True, alpha=0.3)
+
+    # Box plot
+    ax2.boxplot([volumes], vert=True, patch_artist=True,
+                boxprops=dict(facecolor='lightblue', alpha=0.7),
+                medianprops=dict(color='red', linewidth=2),
+                flierprops=dict(marker='o', markerfacecolor='gray', markersize=4, alpha=0.5))
+    ax2.set_ylabel('Volume', fontsize=12)
+    ax2.set_title('Volume Distribution (Box Plot)', fontsize=14)
+    ax2.set_xticklabels([f'{n_vertices} vertices'])
+    ax2.grid(True, alpha=0.3, axis='y')
+
+    plt.tight_layout()
+    plt.savefig(output_file, dpi=150, bbox_inches='tight')
+    print(f"Plot saved to: {output_file}")
+    plt.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Analyze volume distributions of ideal polyhedra',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --vertices 4 --samples 10000
+  %(prog)s --vertices 6 --samples 50000 --output my_analysis.png
+  %(prog)s --vertices 5 --samples 20000 --reference 3.66
+        """
+    )
+
+    parser.add_argument('--vertices', '-v', type=int, required=True,
+                        help='Number of vertices (must be >= 3)')
+    parser.add_argument('--samples', '-n', type=int, default=10000,
+                        help='Number of random samples (default: 10000)')
+    parser.add_argument('--seed', '-s', type=int, default=42,
+                        help='Random seed (default: 42)')
+    parser.add_argument('--output', '-o', type=str, default=None,
+                        help='Output plot file (default: results/plots/{n}vertex_distribution_TIMESTAMP.png)')
+    parser.add_argument('--data', '-d', type=str, default=None,
+                        help='Output data JSON file (optional)')
+    parser.add_argument('--reference', '-r', type=float, default=None,
+                        help='Reference volume to mark on plot (optional)')
+    parser.add_argument('--series-terms', type=int, default=96,
+                        help='Number of series terms for Lobachevsky function (default: 96)')
+
+    args = parser.parse_args()
+
+    if args.vertices < 3:
+        print("Error: Number of vertices must be at least 3")
+        sys.exit(1)
+
+    # Setup output files
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    if args.output is None:
+        plot_file = f"results/plots/{args.vertices}vertex_distribution_{timestamp}.png"
+    else:
+        plot_file = args.output
+
+    if args.data is not None:
+        data_file = args.data
+    else:
+        data_file = f"results/data/{args.vertices}vertex_distribution_{timestamp}.json"
+
+    # Ensure output directories exist
+    Path(plot_file).parent.mkdir(parents=True, exist_ok=True)
+    if args.data is not None:
+        Path(data_file).parent.mkdir(parents=True, exist_ok=True)
+
+    print("=" * 70)
+    print("Ideal Polyhedron Volume Distribution Analysis")
+    print("=" * 70)
+    print(f"Vertices:      {args.vertices}")
+    print(f"Samples:       {args.samples}")
+    print(f"Random seed:   {args.seed}")
+    print(f"Plot output:   {plot_file}")
+    if args.data:
+        print(f"Data output:   {data_file}")
+    print("=" * 70)
+    print()
+
+    # Run analysis
+    results = analyze_distribution(
+        args.vertices,
+        args.samples,
+        seed=args.seed,
+        series_terms=args.series_terms
+    )
+
+    # Print statistics
+    print("\n" + "=" * 70)
+    print("STATISTICS:")
+    print("=" * 70)
+    print(f"Valid configs:  {results['n_valid']:,} / {results['n_samples_requested']:,}")
+    print(f"Mean volume:    {results['mean']:.8f}")
+    print(f"Median volume:  {results['median']:.8f}")
+    print(f"Std deviation:  {results['std']:.8f}")
+    print(f"Min volume:     {results['min']:.8f}")
+    print(f"Max volume:     {results['max']:.8f}")
+    print(f"25th percentile: {results['q25']:.8f}")
+    print(f"75th percentile: {results['q75']:.8f}")
+
+    if args.reference is not None:
+        print(f"\nReference volume: {args.reference:.8f}")
+        print(f"Mean/Reference:   {results['mean']/args.reference:.4f}")
+        print(f"Max/Reference:    {results['max']/args.reference:.4f}")
+
+    # Create plot
+    plot_distribution(
+        results['volumes'],
+        results,
+        args.vertices,
+        plot_file,
+        reference_volume=args.reference
+    )
+
+    # Save data if requested
+    if args.data is not None:
+        output_data = {
+            'metadata': {
+                'timestamp': datetime.now().isoformat(),
+                'n_vertices': args.vertices,
+                'n_samples_requested': args.samples,
+                'n_valid': results['n_valid'],
+                'seed': args.seed,
+                'series_terms': args.series_terms,
+            },
+            'statistics': {
+                'mean': float(results['mean']),
+                'median': float(results['median']),
+                'std': float(results['std']),
+                'min': float(results['min']),
+                'max': float(results['max']),
+                'q25': float(results['q25']),
+                'q75': float(results['q75']),
+            },
+            'volumes': results['volumes'].tolist(),
+        }
+
+        with open(data_file, 'w') as f:
+            json.dump(output_data, f, indent=2)
+
+        print(f"\nData saved to: {data_file}")
+
+    print("=" * 70)
+
+
+if __name__ == '__main__':
+    main()

bin/gui.py

@@ -0,0 +1,893 @@
+#!/usr/bin/env python3
+"""
+Gradio GUI for Ideal Polyhedron Volume Toolkit
+
+Interactive interface for:
+- Optimizing polyhedra
+- Analyzing distributions
+- 3D visualization in sphere and Poincaré ball models
+
+Usage:
+    python bin/gui.py           # Local only (127.0.0.1:7860)
+    python bin/gui.py --share   # Create shareable public link
+    python bin/gui.py --port 8080  # Custom port
+"""
+
+import gradio as gr
+import numpy as np
+import json
+import io
+import matplotlib.pyplot as plt
+import argparse
+from datetime import datetime
+from pathlib import Path
+from PIL import Image
+
+from ideal_poly_volume_toolkit.geometry import (
+    delaunay_triangulation_indices,
+    triangle_volume_from_points_torch,
+    ideal_poly_volume_via_delaunay,
+)
+from ideal_poly_volume_toolkit.visualization import (
+    plot_polyhedron_klein,
+    plot_polyhedron_poincare,
+    plot_delaunay_2d,
+    create_polyhedron_mesh,
+)
+from ideal_poly_volume_toolkit.rivin_holonomy import (
+    Triangulation,
+    generators_from_triangulation,
+)
+from ideal_poly_volume_toolkit.symmetry import (
+    compute_symmetry_group,
+    format_symmetry_report,
+)
+
+import torch
+from scipy.optimize import differential_evolution
+
+# Note: GPU is slower than CPU for this problem due to small tensor sizes
+# and transfer overhead, so we use CPU explicitly
+DEVICE = torch.device('cpu')
+
+
+# ============================================================================
+# Optimization Functions
+# ============================================================================
+
+def spherical_to_complex(theta, phi):
+    """Convert spherical coordinates to complex via stereographic projection."""
+    return np.tan(theta/2) * np.exp(1j * phi)
+
+
+def compute_volume(params, n_vertices):
+    """Compute volume for a polyhedron with n_vertices.
+
+    Performance optimizations:
+    - Reduced series_terms to 64 (good balance of speed/accuracy)
+    - Single torch tensor conversion
+    - Parallel evaluation via differential_evolution workers
+
+    Args:
+        params: Optimization parameters (theta, phi pairs)
+        n_vertices: Total number of vertices
+
+    Returns:
+        Negative volume (for minimization)
+
+    Note:
+        The polishing step (L-BFGS-B) uses finite differences for gradients.
+        PyTorch autodiff could be used but the Delaunay triangulation is
+        not differentiable, making gradients unreliable near topology changes.
+    """
+    complex_points = [complex(0, 0), complex(1, 0), complex(0, 1)]
+    n_params = n_vertices - 3
+
+    for i in range(n_params):
+        theta = params[2*i]
+        phi = params[2*i + 1]
+        z = spherical_to_complex(theta, phi)
+        complex_points.append(z)
+
+    Z_np = np.array(complex_points, dtype=np.complex128)
+
+    try:
+        idx = delaunay_triangulation_indices(Z_np)
+    except:
+        return 1000.0
+
+    # Single torch conversion (CPU is faster than GPU for small tensors)
+    Z_torch = torch.tensor(Z_np, dtype=torch.complex128, device=DEVICE)
+
+    total_volume = 0
+    for (i, j, k) in idx:
+        try:
+            vol = triangle_volume_from_points_torch(
+                Z_torch[i], Z_torch[j], Z_torch[k], series_terms=64
+            )
+            total_volume += vol.item()
+        except:
+            return 1000.0
+
+    return -total_volume
+
+
+def run_optimization(n_vertices, n_trials, max_iter, pop_size, seed, progress=gr.Progress()):
+    """Run optimization with progress tracking.
+
+    Uses parallel workers (all CPU cores) for faster optimization.
+    """
+    import os
+    from functools import partial
+
+    # Validate and convert inputs
+    try:
+        n_vertices = int(n_vertices)
+        if n_vertices < 4:
+            return "Error: Number of vertices must be at least 4", None
+        if n_vertices > 100:
+            return "Error: Number of vertices limited to 100 for practical computation time", None
+    except (ValueError, TypeError):
+        return "Error: Number of vertices must be an integer", None
+
+    n_cpus = os.cpu_count()
+    progress(0, desc=f"Starting optimization (using {n_cpus} CPU cores)...")
+
+    n_free_vertices = n_vertices - 3
+    n_params = n_free_vertices * 2
+    bounds = [(0.1, np.pi - 0.1), (0, 2*np.pi)] * n_free_vertices
+
+    # Adaptive settings for large vertex counts
+    # For high dimensions, reduce popsize to avoid excessive evaluations
+    adaptive_popsize = min(pop_size, max(10, 15 - (n_vertices - 7) // 3))
+
+    best_volume = 0
+    best_params = None
+    all_volumes = []
+
+    # Create picklable objective function using partial
+    # (lambdas can't be pickled for multiprocessing)
+    objective_func = partial(compute_volume, n_vertices=n_vertices)
+
+    for trial in range(n_trials):
+        progress((trial + 1) / n_trials, desc=f"Trial {trial + 1}/{n_trials}")
+
+        result = differential_evolution(
+            objective_func,
+            bounds,
+            maxiter=max_iter,
+            popsize=adaptive_popsize,
+            seed=seed + trial,
+            polish=True,
+            disp=False,
+            workers=-1,  # Use all CPU cores for parallel evaluation
+            updating='deferred'  # Better for parallel workers
+        )
+
+        volume = -result.fun
+        all_volumes.append(volume)
+
+        if volume > best_volume:
+            best_volume = volume
+            best_params = result.x
+
+    # Reconstruct best configuration
+    complex_points = [complex(0, 0), complex(1, 0), complex(0, 1)]
+    for i in range(n_free_vertices):
+        theta = best_params[2*i]
+        phi = best_params[2*i + 1]
+        z = spherical_to_complex(theta, phi)
+        complex_points.append(z)
+
+    Z_np = np.array(complex_points, dtype=np.complex128)
+    idx = delaunay_triangulation_indices(Z_np)
+
+    # Compute statistics
+    stats = {
+        'n_vertices': n_vertices,
+        'n_faces': len(idx),
+        'best_volume': float(best_volume),
+        'mean_volume': float(np.mean(all_volumes)),
+        'std_volume': float(np.std(all_volumes)),
+        'all_volumes': [float(v) for v in all_volumes],
+    }
+
+    # Save result
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_file = f"results/data/{n_vertices}vertex_optimization_{timestamp}.json"
+    Path(output_file).parent.mkdir(parents=True, exist_ok=True)
+
+    with open(output_file, 'w') as f:
+        json.dump({
+            'metadata': {'timestamp': datetime.now().isoformat()},
+            'best': {
+                'volume': stats['best_volume'],
+                'params': best_params.tolist(),
+                'vertices_real': Z_np.real.tolist(),
+                'vertices_imag': Z_np.imag.tolist(),
+            },
+            'statistics': stats,
+        }, f, indent=2)
+
+    # Create summary text
+    summary = f"""
+## Optimization Results
+
+**Configuration:**
+- Vertices: {n_vertices}
+- Trials: {n_trials}
+- Iterations per trial: {max_iter}
+
+**Best Result:**
+- Volume: {best_volume:.8f}
+- Faces: {len(idx)}
+
+**Statistics over all trials:**
+- Mean: {stats['mean_volume']:.8f}
+- Std Dev: {stats['std_volume']:.8f}
+- Best/Mean: {best_volume/stats['mean_volume']:.4f}
+
+**Saved to:** `{output_file}`
+"""
+
+    # Return data as dict for state management
+    opt_data = {
+        'vertices': Z_np,
+        'triangulation': idx,
+        'stats': stats
+    }
+
+    return summary, opt_data
+
+
+# ============================================================================
+# Distribution Analysis Functions
+# ============================================================================
+
+def analyze_volume_distribution(n_vertices, n_samples, seed, progress=gr.Progress()):
+    """Analyze volume distribution with progress tracking.
+
+    Note: n_vertices is the number of random vertices to add.
+    Total vertices = n_vertices + 3 fixed (0, 1, i) + 1 at infinity = n_vertices + 4
+    """
+    np.random.seed(seed)
+
+    # Fixed vertices: 0, 1, i (infinity is implicit in the volume computation)
+    fixed_vertices = [complex(0, 0), complex(1, 0), complex(0, 1)]
+    n_random = n_vertices
+    total_vertices = n_vertices + 3  # Will have infinity implicitly
+
+    volumes = []
+
+    def sample_random_vertex():
+        vec = np.random.randn(3)
+        vec = vec / np.linalg.norm(vec)
+        x, y, z = vec
+        if z > 0.999:
+            return None
+        w = complex(x/(1-z), y/(1-z))
+        return w
+
+    for i in range(n_samples):
+        if (i + 1) % 100 == 0:
+            progress((i + 1) / n_samples, desc=f"Sampling: {i + 1}/{n_samples}")
+
+        vertices = fixed_vertices.copy()
+
+        for _ in range(n_random):
+            v = sample_random_vertex()
+            if v is None or any(abs(v - existing) < 0.01 for existing in vertices):
+                continue
+            vertices.append(v)
+
+        if len(vertices) != total_vertices:
+            continue
+
+        try:
+            vertices_np = np.array(vertices, dtype=np.complex128)
+            vol = ideal_poly_volume_via_delaunay(vertices_np, mode='fast', series_terms=96)
+            if 0 < vol < 1000:
+                volumes.append(vol)
+        except:
+            pass
+
+    volumes = np.array(volumes)
+
+    # Create histogram
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.hist(volumes, bins=50, density=True, alpha=0.7, color='steelblue', edgecolor='black')
+    ax.axvline(np.mean(volumes), color='red', linestyle='--', linewidth=2,
+               label=f'Mean: {np.mean(volumes):.4f}')
+    ax.axvline(np.median(volumes), color='green', linestyle='--', linewidth=2,
+               label=f'Median: {np.median(volumes):.4f}')
+    ax.set_xlabel('Volume', fontsize=12)
+    ax.set_ylabel('Density', fontsize=12)
+    ax.set_title(f'{total_vertices}-Vertex Volume Distribution ({len(volumes)} samples)', fontsize=14)
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # Save plot to BytesIO and convert to PIL Image for Gradio
+    buf = io.BytesIO()
+    plt.tight_layout()
+    plt.savefig(buf, format='png', dpi=150)
+    buf.seek(0)
+    plt.close()
+
+    # Convert BytesIO to PIL Image for Gradio
+    img = Image.open(buf)
+
+    # Statistics summary
+    summary = f"""
+## Distribution Analysis Results
+
+**Configuration:**
+- Random vertices: {n_random}
+- Fixed vertices: 3 (at 0, 1, i)
+- **Total vertices: {total_vertices}** (+ ∞)
+- Samples requested: {n_samples}
+- Valid samples: {len(volumes)}
+
+**Statistics:**
+- Mean: {np.mean(volumes):.8f}
+- Median: {np.median(volumes):.8f}
+- Std Dev: {np.std(volumes):.8f}
+- Min: {np.min(volumes):.8f}
+- Max: {np.max(volumes):.8f}
+- Q25: {np.percentile(volumes, 25):.8f}
+- Q75: {np.percentile(volumes, 75):.8f}
+"""
+
+    return summary, img
+
+
+# ============================================================================
+# Visualization Functions
+# ============================================================================
+
+def visualize_configuration(vertices_real, vertices_imag, vis_type, subdivisions):
+    """Create visualization based on user selection."""
+    if not vertices_real or not vertices_imag:
+        return None, "Please provide vertices"
+
+    try:
+        # Parse vertices
+        real_parts = [float(x.strip()) for x in vertices_real.split(',')]
+        imag_parts = [float(x.strip()) for x in vertices_imag.split(',')]
+
+        if len(real_parts) != len(imag_parts):
+            return None, "Real and imaginary parts must have same length"
+
+        vertices = np.array([complex(r, i) for r, i in zip(real_parts, imag_parts)])
+
+        if vis_type == "Delaunay (2D)":
+            idx = delaunay_triangulation_indices(vertices)
+            fig = plot_delaunay_2d(vertices, idx)
+            return fig, f"Showing Delaunay triangulation with {len(idx)} faces"
+
+        elif vis_type == "Klein Ball (3D)":
+            fig = plot_polyhedron_klein(vertices, subdivisions=subdivisions)
+            return fig, f"Showing Klein model (subdivision level: {subdivisions})"
+
+        elif vis_type == "Poincaré Ball (3D)":
+            fig = plot_polyhedron_poincare(vertices, subdivisions=subdivisions)
+            return fig, f"Showing Poincaré ball model (subdivision level: {subdivisions})"
+
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+
+def load_from_optimization(opt_data):
+    """Load vertices from optimization results."""
+    if opt_data is None:
+        return "", ""
+
+    # opt_data is a dict with vertices
+    vertices = opt_data.get('vertices', None)
+    if vertices is None:
+        return "", ""
+
+    real_str = ", ".join(f"{v.real:.6f}" for v in vertices)
+    imag_str = ", ".join(f"{v.imag:.6f}" for v in vertices)
+
+    return real_str, imag_str
+
+
+# ============================================================================
+# Holonomy/Arithmeticity Functions
+# ============================================================================
+
+def compute_holonomy_analysis(vertices_real, vertices_imag, progress=gr.Progress()):
+    """Compute holonomy generators and check arithmeticity."""
+    if not vertices_real or not vertices_imag:
+        return "Please provide vertices", None
+
+    try:
+        # Parse vertices
+        real_parts = [float(x.strip()) for x in vertices_real.split(',')]
+        imag_parts = [float(x.strip()) for x in vertices_imag.split(',')]
+
+        if len(real_parts) != len(imag_parts):
+            return "Real and imaginary parts must have same length", None
+
+        vertices = np.array([complex(r, i) for r, i in zip(real_parts, imag_parts)])
+
+        progress(0.2, desc="Computing Delaunay triangulation...")
+
+        # Get triangulation
+        idx = delaunay_triangulation_indices(vertices)
+        F = len(idx)
+
+        progress(0.4, desc="Building adjacency structure...")
+
+        # Build adjacency structure
+        adjacency = {}
+        edge_id_map = {}
+        edge_id = 0
+
+        for i, tri_i in enumerate(idx):
+            for side_i in range(3):
+                v1_i, v2_i = tri_i[side_i], tri_i[(side_i + 1) % 3]
+                edge = tuple(sorted([v1_i, v2_i]))
+
+                # Find matching triangle
+                for j, tri_j in enumerate(idx):
+                    if i == j:
+                        continue
+                    for side_j in range(3):
+                        v1_j, v2_j = tri_j[side_j], tri_j[(side_j + 1) % 3]
+                        if set([v1_j, v2_j]) == set([v1_i, v2_i]):
+                            if (i, side_i) not in adjacency:
+                                if edge not in edge_id_map:
+                                    edge_id_map[edge] = edge_id
+                                    edge_id += 1
+                                adjacency[(i, side_i)] = (j, side_j, edge_id_map[edge])
+
+        progress(0.6, desc="Computing holonomy generators...")
+
+        # Define order and orientation
+        order = {t: [0, 1, 2] for t in range(F)}
+        orientation = {}
+        for edge, eid in edge_id_map.items():
+            for (t, s), (u, su, e) in adjacency.items():
+                if e == eid:
+                    orientation[eid] = ((t, s), (u, su))
+                    break
+
+        # Create triangulation
+        T = Triangulation(F, adjacency, order, orientation)
+
+        # Zero shears for ideal polyhedra
+        Z = {eid: 0.0 for eid in range(edge_id)}
+
+        # Compute generators
+        gens = generators_from_triangulation(T, Z, root=0)
+
+        progress(0.8, desc="Analyzing traces...")
+
+        # Analyze traces
+        trace_analysis = []
+        traces = []
+        integral_count = 0
+
+        for i, (u, v, tokens, M) in enumerate(gens):
+            trace = M[0][0] + M[1][1]
+            traces.append(trace)
+
+            nearest_int = round(trace)
+            distance = abs(trace - nearest_int)
+            is_close = distance < 0.01
+
+            if is_close:
+                integral_count += 1
+
+            trace_analysis.append({
+                'generator': i,
+                'edge': (u, v),
+                'trace': float(trace),
+                'nearest_int': int(nearest_int),
+                'distance': float(distance),
+                'is_close': is_close
+            })
+
+        progress(1.0, desc="Complete!")
+
+        # Create summary
+        summary = f"""
+## Holonomy Analysis Results
+
+**Configuration:**
+- Vertices: {len(vertices)}
+- Triangular faces: {F}
+- Number of generators: {len(gens)}
+
+**Arithmeticity Test:**
+- Generators with integral traces: {integral_count}/{len(gens)}
+- Percentage: {100*integral_count/len(gens):.1f}%
+
+**Interpretation:**
+"""
+        if integral_count == len(gens):
+            summary += "✅ **ALL TRACES ARE INTEGERS!**\n\n"
+            summary += "This polyhedron is **ARITHMETIC** - it has deep number-theoretic structure!\n"
+            summary += "The holonomy lies in PSL(2,O_K) for some number field K."
+        elif integral_count > len(gens) * 0.7:
+            summary += "⚠️ **MOST TRACES ARE CLOSE TO INTEGERS**\n\n"
+            summary += f"This suggests possible arithmetic structure with {integral_count}/{len(gens)} integral traces.\n"
+            summary += "May be commensurable with an arithmetic group."
+        else:
+            summary += "❌ **NOT ARITHMETIC**\n\n"
+            summary += "Only a few traces are close to integers. This is likely a generic configuration."
+
+        summary += "\n\n## Trace Details:\n\n"
+        summary += "| Generator | Edge | Trace | Nearest Int | Distance | Status |\n"
+        summary += "|-----------|------|-------|-------------|----------|--------|\n"
+
+        for ta in trace_analysis:
+            status = "✅ INTEGRAL" if ta['is_close'] else "❌"
+            summary += f"| {ta['generator']} | {ta['edge'][0]}-{ta['edge'][1]} | "
+            summary += f"{ta['trace']:.6f} | {ta['nearest_int']} | "
+            summary += f"{ta['distance']:.6f} | {status} |\n"
+
+        # Create plot
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+
+        # Plot traces
+        gen_nums = [ta['generator'] for ta in trace_analysis]
+        trace_vals = [ta['trace'] for ta in trace_analysis]
+        colors = ['green' if ta['is_close'] else 'red' for ta in trace_analysis]
+
+        ax1.bar(gen_nums, trace_vals, color=colors, alpha=0.7, edgecolor='black')
+        ax1.axhline(y=0, color='k', linestyle='-', linewidth=0.5)
+        ax1.set_xlabel('Generator', fontsize=12)
+        ax1.set_ylabel('Trace', fontsize=12)
+        ax1.set_title('Holonomy Generator Traces', fontsize=14)
+        ax1.grid(True, alpha=0.3)
+
+        # Plot distances from integers
+        distances = [ta['distance'] for ta in trace_analysis]
+        ax2.bar(gen_nums, distances, color=colors, alpha=0.7, edgecolor='black')
+        ax2.axhline(y=0.01, color='orange', linestyle='--', linewidth=2,
+                    label='Threshold (0.01)')
+        ax2.set_xlabel('Generator', fontsize=12)
+        ax2.set_ylabel('Distance from nearest integer', fontsize=12)
+        ax2.set_title('Integrality Test', fontsize=14)
+        ax2.legend()
+        ax2.grid(True, alpha=0.3)
+        ax2.set_yscale('log')
+
+        plt.tight_layout()
+
+        # Save plot to BytesIO and convert to PIL Image for Gradio
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', dpi=150)
+        buf.seek(0)
+        plt.close()
+
+        # Convert BytesIO to PIL Image for Gradio
+        img = Image.open(buf)
+
+        return summary, img
+
+    except Exception as e:
+        return f"Error: {str(e)}", None
+
+
+def compute_symmetry_analysis(vertices_real, vertices_imag):
+    """Compute symmetry group of the polyhedron."""
+    if not vertices_real or not vertices_imag:
+        return "Please provide vertices"
+
+    try:
+        # Parse vertices
+        real_parts = [float(x.strip()) for x in vertices_real.split(',')]
+        imag_parts = [float(x.strip()) for x in vertices_imag.split(',')]
+
+        if len(real_parts) != len(imag_parts):
+            return "Real and imaginary parts must have same length"
+
+        vertices = np.array([complex(r, i) for r, i in zip(real_parts, imag_parts)])
+
+        # Lift to 3D (Klein model in the ball)
+        from ideal_poly_volume_toolkit.visualization import lift_to_sphere_with_inf
+        vertices_3d = lift_to_sphere_with_inf(vertices)
+
+        # Compute symmetry group
+        sym_info = compute_symmetry_group(vertices_3d)
+
+        # Format report
+        report = format_symmetry_report(sym_info)
+
+        return report
+
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+# ============================================================================
+# Gradio Interface
+# ============================================================================
+
+def create_gui():
+    """Create the main Gradio interface."""
+
+    with gr.Blocks(title="Ideal Polyhedron Volume Toolkit", theme=gr.themes.Soft()) as demo:
+        # Shared state for passing optimization results to visualization
+        opt_result_state = gr.State(None)
+        gr.Markdown("""
+        # 🔺 Ideal Polyhedron Volume Toolkit
+
+        Interactive GUI for computing and optimizing volumes of ideal hyperbolic polyhedra.
+        """)
+
+        with gr.Tabs():
+            # ================================================================
+            # Tab 1: Optimization
+            # ================================================================
+            with gr.Tab("🎯 Optimization"):
+                gr.Markdown("Find maximal volume configurations for ideal polyhedra")
+
+                with gr.Row():
+                    with gr.Column():
+                        opt_vertices = gr.Number(value=7, label="Number of Vertices",
+                                                minimum=4, maximum=100,
+                                                info="Recommended: 4-30 (higher is much slower)")
+                        opt_trials = gr.Slider(1, 50, value=10, step=1,
+                                              label="Number of Trials")
+                        opt_maxiter = gr.Slider(50, 500, value=150, step=50,
+                                               label="Max Iterations per Trial",
+                                               info="150-200 is usually sufficient")
+                        opt_popsize = gr.Slider(10, 30, value=15, step=5,
+                                               label="Population Size")
+                        opt_seed = gr.Number(value=42, label="Random Seed")
+
+                        opt_button = gr.Button("Run Optimization", variant="primary")
+
+                    with gr.Column():
+                        opt_output = gr.Markdown("Results will appear here...")
+
+                opt_button.click(
+                    run_optimization,
+                    inputs=[opt_vertices, opt_trials, opt_maxiter, opt_popsize, opt_seed],
+                    outputs=[opt_output, opt_result_state]
+                )
+
+            # ================================================================
+            # Tab 2: Distribution Analysis
+            # ================================================================
+            with gr.Tab("📊 Distribution Analysis"):
+                gr.Markdown("""
+                Analyze volume distributions by sampling random configurations.
+
+                **Note:** Vertices are added to fixed base (0, 1, i, ∞).
+                So 4 random vertices = 7 total vertices.
+                """)
+
+                with gr.Row():
+                    with gr.Column():
+                        dist_vertices = gr.Slider(1, 10, value=4, step=1,
+                                                 label="Number of Random Vertices")
+                        dist_samples = gr.Slider(100, 50000, value=5000, step=100,
+                                                label="Number of Samples")
+                        dist_seed = gr.Number(value=42, label="Random Seed")
+
+                        dist_button = gr.Button("Analyze Distribution", variant="primary")
+
+                    with gr.Column():
+                        dist_output = gr.Markdown("Results will appear here...")
+                        dist_plot = gr.Image(label="Distribution")
+
+                dist_button.click(
+                    analyze_volume_distribution,
+                    inputs=[dist_vertices, dist_samples, dist_seed],
+                    outputs=[dist_output, dist_plot]
+                )
+
+            # ================================================================
+            # Tab 3: 3D Visualization
+            # ================================================================
+            with gr.Tab("🔮 3D Visualization"):
+                gr.Markdown("Visualize polyhedra in different models")
+
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Input Vertices")
+                        gr.Markdown("Enter vertices as comma-separated values in the complex plane")
+
+                        vis_real = gr.Textbox(
+                            label="Real parts",
+                            value="0, 1, 0, 0.5",
+                            placeholder="0, 1, 0.5, -0.5"
+                        )
+                        vis_imag = gr.Textbox(
+                            label="Imaginary parts",
+                            value="0, 0, 1, 0.866",
+                            placeholder="0, 0, 0.866, 0.866"
+                        )
+
+                        with gr.Row():
+                            load_opt_button = gr.Button("Load from Optimization", size="sm")
+
+                        gr.Markdown("### Visualization Options")
+                        vis_type = gr.Radio(
+                            ["Delaunay (2D)", "Klein Ball (3D)", "Poincaré Ball (3D)"],
+                            value="Klein Ball (3D)",
+                            label="Visualization Type"
+                        )
+                        vis_subdivisions = gr.Slider(0, 5, value=3, step=1,
+                                                    label="Subdivision Level (3D only)",
+                                                    info="Higher = smoother curves (slower rendering)")
+
+                        vis_button = gr.Button("Generate Visualization", variant="primary")
+
+                    with gr.Column():
+                        vis_plot = gr.Plot(label="Visualization")
+                        vis_status = gr.Textbox(label="Status", interactive=False)
+
+                vis_button.click(
+                    visualize_configuration,
+                    inputs=[vis_real, vis_imag, vis_type, vis_subdivisions],
+                    outputs=[vis_plot, vis_status]
+                )
+
+                load_opt_button.click(
+                    load_from_optimization,
+                    inputs=[opt_result_state],
+                    outputs=[vis_real, vis_imag]
+                )
+
+            # ================================================================
+            # Tab 4: Arithmeticity / Holonomy
+            # ================================================================
+            with gr.Tab("🔬 Arithmeticity"):
+                gr.Markdown("Check if a polyhedron is arithmetic using Penner-Rivin holonomy")
+
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Input Vertices")
+                        arith_real = gr.Textbox(
+                            label="Real parts",
+                            value="0, 1, 0, 0.5",
+                            placeholder="0, 1, 0.5, -0.5"
+                        )
+                        arith_imag = gr.Textbox(
+                            label="Imaginary parts",
+                            value="0, 0, 1, 0.866",
+                            placeholder="0, 0, 0.866, 0.866"
+                        )
+
+                        with gr.Row():
+                            load_opt_arith_button = gr.Button("Load from Optimization", size="sm")
+
+                        arith_button = gr.Button("Compute Holonomy & Check Arithmeticity", variant="primary")
+                        symmetry_button = gr.Button("Compute Symmetry Group", variant="secondary")
+
+                    with gr.Column():
+                        arith_output = gr.Markdown("Results will appear here...")
+                        arith_plot = gr.Image(label="Trace Analysis")
+
+                arith_button.click(
+                    compute_holonomy_analysis,
+                    inputs=[arith_real, arith_imag],
+                    outputs=[arith_output, arith_plot]
+                )
+
+                symmetry_button.click(
+                    compute_symmetry_analysis,
+                    inputs=[arith_real, arith_imag],
+                    outputs=[arith_output]
+                )
+
+                load_opt_arith_button.click(
+                    load_from_optimization,
+                    inputs=[opt_result_state],
+                    outputs=[arith_real, arith_imag]
+                )
+
+                gr.Markdown("""
+                ### About Arithmeticity
+
+                A hyperbolic 3-manifold is **arithmetic** if its holonomy representation lies in PSL(2, O_K)
+                where O_K is the ring of integers in a number field K.
+
+                For ideal polyhedra, this can be tested by computing:
+                1. Holonomy generators (Penner-Rivin algorithm)
+                2. Traces of these generators
+                3. Checking if traces are integers (or lie in a number field)
+
+                **Arithmetic polyhedra have deep number-theoretic significance!**
+
+                If all traces are integers, the configuration is arithmetic and related to
+                special lattices in hyperbolic space.
+                """)
+
+            # ================================================================
+            # Tab 5: About
+            # ================================================================
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown("""
+                ## About This Tool
+
+                This GUI provides an interactive interface to the **Ideal Polyhedron Volume Toolkit**.
+
+                ### Features
+
+                - **Optimization**: Find maximal volume configurations using differential evolution
+                - **Distribution Analysis**: Sample random configurations and analyze volume distributions
+                - **3D Visualization**: View polyhedra in multiple models:
+                  - Delaunay triangulation in complex plane (2D)
+                  - Stereographic projection on unit sphere (3D)
+                  - Poincaré ball model (3D hyperbolic geometry)
+                - **Arithmeticity Testing**: Check if polyhedra have arithmetic holonomy (Penner-Rivin)
+
+                ### Mathematical Background
+
+                Ideal polyhedra are polyhedra in hyperbolic 3-space with all vertices at infinity.
+                Their volumes can be computed using:
+                - Delaunay triangulation of vertex positions
+                - Lobachevsky's formula for ideal tetrahedra
+                - Stereographic projection from the complex plane
+
+                ### Usage Tips
+
+                1. Start with **Optimization** to find interesting configurations
+                2. Use **Load from Optimization** in the Visualization tab to see results
+                3. Adjust **subdivision level** for smoother 3D visualizations
+                4. Compare sphere and Poincaré ball models to understand hyperbolic geometry
+
+                ### Documentation
+
+                - See `README.md` for installation and Python API
+                - See `bin/README.md` for command-line tools
+                - See `examples/` for research scripts
+
+                ---
+
+                **Version:** 0.3.0
+                **License:** MIT
+                """)
+
+        gr.Markdown("---")
+        gr.Markdown("*Ideal Polyhedron Volume Toolkit GUI*")
+
+    return demo
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Launch Gradio GUI for Ideal Polyhedron Volume Toolkit",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s                    # Launch locally on 127.0.0.1:7860
+  %(prog)s --share            # Create shareable public link
+  %(prog)s --port 8080        # Use custom port
+  %(prog)s --share --port 8080  # Share with custom port
+        """
+    )
+
+    parser.add_argument('--share', action='store_true',
+                        help='Create a shareable public Gradio link')
+    parser.add_argument('--port', type=int, default=7860,
+                        help='Port to run the server on (default: 7860)')
+    parser.add_argument('--server-name', type=str, default="127.0.0.1",
+                        help='Server name/IP to bind to (default: 127.0.0.1)')
+
+    args = parser.parse_args()
+
+    demo = create_gui()
+
+    print("=" * 70)
+    print("🎨 Ideal Polyhedron Volume Toolkit - GUI")
+    print("=" * 70)
+    if args.share:
+        print("Creating shareable public link...")
+        print("⚠️  WARNING: Public links expose your local server to the internet")
+    else:
+        print(f"Launching local server at http://{args.server_name}:{args.port}")
+    print("=" * 70)
+
+    demo.launch(
+        share=args.share,
+        server_name=args.server_name,
+        server_port=args.port
+    )

bin/optimize_polyhedron.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""
+General-purpose wrapper for optimizing ideal polyhedron volumes.
+
+Usage:
+    python bin/optimize_polyhedron.py --vertices 7 --trials 10
+    python bin/optimize_polyhedron.py --vertices 12 --trials 20 --output custom_name.json
+"""
+
+import argparse
+import json
+import numpy as np
+import torch
+from datetime import datetime
+from pathlib import Path
+import sys
+
+from ideal_poly_volume_toolkit.geometry import (
+    delaunay_triangulation_indices,
+    triangle_volume_from_points_torch,
+)
+from scipy.optimize import differential_evolution
+
+
+def spherical_to_complex(theta, phi):
+    """Convert spherical coordinates to complex via stereographic projection."""
+    return np.tan(theta/2) * np.exp(1j * phi)
+
+
+def compute_volume(params, n_vertices):
+    """
+    Compute volume for a polyhedron with n_vertices.
+
+    First 3 vertices are fixed to break symmetry:
+    - z1 = 0
+    - z2 = 1
+    - z3 = i
+
+    Remaining (n_vertices - 3) vertices are parameterized by spherical coords.
+    """
+    # Fixed vertices
+    complex_points = [complex(0, 0), complex(1, 0), complex(0, 1)]
+
+    # Parameterized vertices (2 params each: theta, phi)
+    n_params = n_vertices - 3
+    for i in range(n_params):
+        theta = params[2*i]
+        phi = params[2*i + 1]
+        z = spherical_to_complex(theta, phi)
+        complex_points.append(z)
+
+    Z_np = np.array(complex_points, dtype=np.complex128)
+
+    # Delaunay triangulation
+    try:
+        idx = delaunay_triangulation_indices(Z_np)
+    except:
+        return 1000.0  # Penalty for degenerate configuration
+
+    # Convert to torch for volume computation
+    Z_torch = torch.tensor(Z_np, dtype=torch.complex128)
+
+    # Compute total volume
+    total_volume = 0
+    for (i, j, k) in idx:
+        try:
+            vol = triangle_volume_from_points_torch(
+                Z_torch[i], Z_torch[j], Z_torch[k], series_terms=96
+            )
+            total_volume += vol.item()
+        except:
+            return 1000.0  # Penalty for invalid configuration
+
+    return -total_volume  # Negative for minimization
+
+
+def analyze_structure(Z_np, idx):
+    """Analyze the combinatorial structure of the triangulation."""
+    n_vertices = len(Z_np)
+    n_faces = len(idx)
+
+    # Count edges
+    edges = set()
+    for (i, j, k) in idx:
+        edges.add((min(i,j), max(i,j)))
+        edges.add((min(i,k), max(i,k)))
+        edges.add((min(j,k), max(j,k)))
+    n_edges = len(edges)
+
+    # Vertex degrees
+    vertex_degrees = [0] * n_vertices
+    for edge in edges:
+        vertex_degrees[edge[0]] += 1
+        vertex_degrees[edge[1]] += 1
+
+    # Euler characteristic check
+    euler_char = n_vertices - n_edges + n_faces
+
+    return {
+        'n_vertices': n_vertices,
+        'n_faces': n_faces,
+        'n_edges': n_edges,
+        'euler_characteristic': euler_char,
+        'vertex_degrees': sorted(vertex_degrees),
+    }
+
+
+def reconstruct_vertices(params, n_vertices):
+    """Reconstruct complex vertices from parameters."""
+    complex_points = [complex(0, 0), complex(1, 0), complex(0, 1)]
+
+    n_params = n_vertices - 3
+    for i in range(n_params):
+        theta = params[2*i]
+        phi = params[2*i + 1]
+        z = spherical_to_complex(theta, phi)
+        complex_points.append(z)
+
+    return np.array(complex_points, dtype=np.complex128)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Optimize ideal polyhedron volumes',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --vertices 7 --trials 10
+  %(prog)s --vertices 12 --trials 20 --maxiter 300
+  %(prog)s --vertices 20 --trials 5 --output results/data/my_20vertex.json
+        """
+    )
+
+    parser.add_argument('--vertices', '-v', type=int, required=True,
+                        help='Number of vertices (must be >= 4)')
+    parser.add_argument('--trials', '-t', type=int, default=10,
+                        help='Number of optimization trials (default: 10)')
+    parser.add_argument('--maxiter', '-m', type=int, default=200,
+                        help='Max iterations per trial (default: 200)')
+    parser.add_argument('--popsize', '-p', type=int, default=15,
+                        help='Population size for differential evolution (default: 15)')
+    parser.add_argument('--output', '-o', type=str, default=None,
+                        help='Output JSON file (default: results/data/{n}vertex_optimization_TIMESTAMP.json)')
+    parser.add_argument('--seed', '-s', type=int, default=42,
+                        help='Random seed base (default: 42)')
+
+    args = parser.parse_args()
+
+    if args.vertices < 4:
+        print("Error: Number of vertices must be at least 4")
+        sys.exit(1)
+
+    # Setup output file
+    if args.output is None:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_file = f"results/data/{args.vertices}vertex_optimization_{timestamp}.json"
+    else:
+        output_file = args.output
+
+    # Ensure output directory exists
+    Path(output_file).parent.mkdir(parents=True, exist_ok=True)
+
+    # Calculate number of parameters (2 per free vertex)
+    n_free_vertices = args.vertices - 3
+    n_params = n_free_vertices * 2
+    bounds = [(0.1, np.pi - 0.1), (0, 2*np.pi)] * n_free_vertices
+
+    print("=" * 70)
+    print(f"Ideal Polyhedron Volume Optimization")
+    print("=" * 70)
+    print(f"Vertices:       {args.vertices}")
+    print(f"Free vertices:  {n_free_vertices} (parameterized)")
+    print(f"Parameters:     {n_params} (spherical coordinates)")
+    print(f"Trials:         {args.trials}")
+    print(f"Max iterations: {args.maxiter}")
+    print(f"Population:     {args.popsize}")
+    print(f"Output:         {output_file}")
+    print("=" * 70)
+
+    best_volume = 0
+    best_params = None
+    all_results = []
+
+    for trial in range(args.trials):
+        print(f"\nTrial {trial + 1}/{args.trials}...")
+
+        result = differential_evolution(
+            lambda p: compute_volume(p, args.vertices),
+            bounds,
+            maxiter=args.maxiter,
+            popsize=args.popsize,
+            seed=args.seed + trial,
+            polish=True,
+            disp=False
+        )
+
+        volume = -result.fun
+        print(f"  Volume: {volume:.8f}")
+        print(f"  Success: {result.success}")
+        print(f"  Iterations: {result.nit}")
+
+        all_results.append({
+            'trial': trial + 1,
+            'volume': float(volume),
+            'params': result.x.tolist(),
+            'success': bool(result.success),
+            'iterations': int(result.nit),
+            'function_evals': int(result.nfev)
+        })
+
+        if volume > best_volume:
+            best_volume = volume
+            best_params = result.x
+            print(f"  → NEW BEST!")
+
+    # Analyze best configuration
+    print("\n" + "=" * 70)
+    print("BEST RESULT:")
+    print("=" * 70)
+    print(f"Volume: {best_volume:.10f}")
+
+    # Reconstruct and analyze
+    Z_np = reconstruct_vertices(best_params, args.vertices)
+    idx = delaunay_triangulation_indices(Z_np)
+    structure = analyze_structure(Z_np, idx)
+
+    print(f"\nCombinatorial structure:")
+    print(f"  Vertices:    {structure['n_vertices']}")
+    print(f"  Edges:       {structure['n_edges']}")
+    print(f"  Faces:       {structure['n_faces']}")
+    print(f"  Euler char:  {structure['euler_characteristic']} (should be 2 for sphere)")
+    print(f"  Vertex degrees: {structure['vertex_degrees']}")
+
+    # Save results
+    output_data = {
+        'metadata': {
+            'timestamp': datetime.now().isoformat(),
+            'n_vertices': args.vertices,
+            'n_trials': args.trials,
+            'maxiter': args.maxiter,
+            'popsize': args.popsize,
+            'seed_base': args.seed,
+        },
+        'best': {
+            'volume': float(best_volume),
+            'params': best_params.tolist(),
+            'vertices_real': Z_np.real.tolist(),
+            'vertices_imag': Z_np.imag.tolist(),
+            'structure': structure,
+            'triangulation': [list(map(int, tri)) for tri in idx],
+        },
+        'all_trials': all_results,
+    }
+
+    with open(output_file, 'w') as f:
+        json.dump(output_data, f, indent=2)
+
+    print(f"\nResults saved to: {output_file}")
+    print("=" * 70)
+
+
+if __name__ == '__main__':
+    main()

bin/results/data/20vertex_optimization_20251026_203700.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d5c59c2eff34286466db53ecd01ec78225d18bf90c079c9e135f94943acc02e
+size 2270

bin/results/data/7vertex_optimization_20251026_191114.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95afdc4df0c3c803fd61f1e8aa8575595273114afa20650b3f135b837ea44eff
+size 1141

bin/results/data/7vertex_optimization_20251026_193813.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e689212237436e5f0e27cfed6a331d4f35c0acefc2a191c543801a9ea00a2f28
+size 1141

bin/results/data/7vertex_optimization_20251026_194915.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cabef18150170f696ba1de13d3a78c94846c8da6dc504f7b31e3fa5bedc919f1
+size 1141

bin/results/data/7vertex_optimization_20251026_195701.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b10bdad76be2cae8ae2013d4fde01eb7469d09e98e0b92048287d11914854a7
+size 894

bin/results/data/7vertex_optimization_20251026_200737.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3595713fd3c48b86f2ea9c81c567d340f075f014ff27004ec16454f1e2850463
+size 894

bin/results/data/7vertex_optimization_20251026_201344.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0dd44c390c87270a8449ce4fa672e5931975d7cc657c678de8a678eaa753041
+size 894

bin/results/data/7vertex_optimization_20251026_202024.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b508899ef59f5dde600783de57f0299f17b852d8dfae29deec2aa8f22c25943
+size 894

bin/results/data/7vertex_optimization_20251026_205947.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b19d5cb571808690d50c3eab47b7054b243250d5a6db1252d74df50d7318a938
+size 901

bin/results/data/9vertex_optimization_20251026_205959.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5daec075aa4a4fe8e0765f38daf454e16a6df26bdb092b0c6c56f40e7fddd204
+size 1109

bin/results/data/9vertex_optimization_20251026_210116.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ee32067e12f06496d538600e41a2204da27e1f978596b0e05d6007a53a82f7f
+size 1200

examples/README.md

@@ -0,0 +1,44 @@
+# Examples Directory
+
+This directory contains organized example scripts demonstrating the use of the ideal polyhedra volume toolkit.
+
+## Directory Structure
+
+### `distributions/`
+Analysis of volume distributions for various polyhedra:
+- `tetrahedron/` - 4-vertex polyhedra volume distributions (10 files)
+- `five_vertex/` - 5-vertex polyhedra distributions
+- `six_vertex/` - 6-vertex polyhedra distributions
+- `euclidean/` - Euclidean tetrahedra analysis and fitting
+
+### `optimization/`
+Optimization scripts organized by vertex count:
+- `7vertex/` - 7-vertex optimization (octahedron with stellated face hypothesis) - 9 scripts
+- `12vertex/` - 12-vertex optimization - 3 scripts
+- `20vertex/` - 20-vertex optimization (icosahedron-like) - 6 scripts
+- `platonic/` - Platonic solid analysis and perturbations
+
+### `visualization/`
+Visualization scripts (5 scripts):
+- Sphere projection visualizations
+- Golden ratio configurations
+- Maximal volume configurations
+- Volume landscapes
+
+### `analysis/`
+Statistical and theoretical analysis scripts (14 scripts):
+- Beta distribution theory
+- Central limit theorem analysis
+- Combinatorial mixture analysis
+- Special configuration analysis
+
+## Running Examples
+
+All examples can be run from their respective directories:
+
+```bash
+cd examples/optimization/7vertex
+python optimize_7vertex.py
+```
+
+Or from the project root using absolute imports (package must be installed with `pip install -e .`).

check_arithmetic_holonomy.py → examples/optimization/20vertex/check_arithmetic_holonomy.py

@@ -1,9 +1,7 @@
 import numpy as np
-import sys
-sys.path.append('/Users/igorrivin/devel/platonic')
-from rivin_holonomy import Triangulation, generators_from_triangulation
 import json
 from scipy.spatial import Delaunay
+from ideal_poly_volume_toolkit.rivin_holonomy import Triangulation, generators_from_triangulation
 
 def compute_holonomy_traces(vertices_complex, triangles):
     """

check_local_maxima_arithmetic.py → examples/optimization/20vertex/check_local_maxima_arithmetic.py

@@ -6,11 +6,9 @@ Tests the conjecture that local maxima are more likely to be arithmetic.
 
 import numpy as np
 import json
-import sys
-sys.path.append('/Users/igorrivin/devel/platonic')
-from rivin_holonomy import Triangulation, generators_from_triangulation
-from scipy.spatial import Delaunay
 import os
+from scipy.spatial import Delaunay
+from ideal_poly_volume_toolkit.rivin_holonomy import Triangulation, generators_from_triangulation
 
 def build_triangulation_from_config(vertices_dict):
     """Convert vertex configuration to triangulation for holonomy computation."""