| |
| """ |
| Validator for problem 059: Thomson Problem for n=50 |
| |
| The Thomson problem asks for n points on a unit sphere that minimize |
| the electrostatic potential energy E = Σᵢ<ⱼ 1/|xᵢ - xⱼ|. |
| |
| For n=50, this validator: |
| 1. Checks all points are on the unit sphere S² |
| 2. Computes the electrostatic energy |
| 3. Reports the configuration quality |
| |
| Expected input format: |
| {"points": [[x, y, z], ...]} 50 points on S² |
| or [[x, y, z], ...] |
| """ |
|
|
| import argparse |
| from typing import Any |
|
|
| import numpy as np |
|
|
| from . import ValidationResult, load_solution, output_result, success, failure |
|
|
|
|
| TARGET_N = 50 |
| TOLERANCE = 1e-9 |
|
|
|
|
| def validate(solution: Any) -> ValidationResult: |
| """ |
| Validate a Thomson configuration for n=50. |
| |
| Args: |
| solution: Dict with 'points' key or list of 50 3D points |
| |
| Returns: |
| ValidationResult with energy and configuration properties |
| """ |
| try: |
| if isinstance(solution, dict) and 'points' in solution: |
| points_data = solution['points'] |
| elif isinstance(solution, list): |
| points_data = solution |
| else: |
| return failure("Invalid format: expected dict with 'points' or list") |
|
|
| points = np.array(points_data, dtype=np.float64) |
| except (ValueError, TypeError) as e: |
| return failure(f"Failed to parse points: {e}") |
|
|
| if points.ndim != 2: |
| return failure(f"Points must be 2D array, got {points.ndim}D") |
|
|
| n, d = points.shape |
| if d != 3: |
| return failure(f"Points must be in ℝ³, got dimension {d}") |
|
|
| if n != TARGET_N: |
| return failure(f"Expected {TARGET_N} points, got {n}") |
|
|
| |
| norms = np.linalg.norm(points, axis=1) |
| off_sphere = np.abs(norms - 1.0) > TOLERANCE |
| if np.any(off_sphere): |
| worst_idx = np.argmax(np.abs(norms - 1.0)) |
| return failure( |
| f"Point {worst_idx} not on unit sphere: |x| = {norms[worst_idx]:.10f}", |
| off_sphere_count=int(np.sum(off_sphere)) |
| ) |
|
|
| |
| energy = 0.0 |
| min_dist = float('inf') |
| for i in range(n): |
| for j in range(i + 1, n): |
| dist = np.linalg.norm(points[i] - points[j]) |
| if dist < TOLERANCE: |
| return failure(f"Points {i} and {j} are coincident") |
| energy += 1.0 / dist |
| min_dist = min(min_dist, dist) |
|
|
| return success( |
| f"Thomson configuration for n={n}: energy = {energy:.10f}, min distance = {min_dist:.6f}", |
| num_points=n, |
| energy=energy, |
| min_distance=min_dist |
| ) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description='Validate Thomson configuration for n=50') |
| parser.add_argument('solution', help='Solution as JSON string or path to JSON file') |
| parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output') |
| args = parser.parse_args() |
|
|
| solution = load_solution(args.solution) |
| result = validate(solution) |
| output_result(result) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
