Added generated data

Author: Akshat Gupta

examples/circle_packing2/README.md

@@ -0,0 +1,240 @@
+# Circle Packing Example
+
+This example demonstrates how OpenEvolve can be used to tackle the challenging mathematical problem of circle packing, a classic problem in computational geometry. Specifically, we focus on packing 26 circles of varying sizes into a unit square to maximize the sum of their radii, replicating one of the tasks from the AlphaEvolve paper.
+
+## Problem Overview
+
+The circle packing problem involves placing n non-overlapping circles inside a container (in this case, a unit square) to optimize a specific metric. For this example:
+
+- We pack exactly 26 circles
+- Each circle must lie entirely within the unit square
+- No circles may overlap
+- We aim to maximize the sum of all circle radii
+
+According to the AlphaEvolve paper, a solution with a sum of radii of approximately 2.635 is achievable for n=26. Our goal was to match or exceed this result.
+
+## Our Approach
+
+We structured our evolution in two phases, each with a different configuration to encourage exploration and exploitation at different stages:
+
+### Phase 1: Initial Exploration
+
+In the first phase, we focused on exploring different fundamental approaches to the packing problem:
+
+- Used a constructor-based approach that places circles in strategic positions
+- Explored various geometric patterns (concentric rings, grid-based arrangements, etc.)
+- Developed simple optimization routines to maximize circle sizes without overlaps
+
+Configuration highlights:
+```yaml
+max_iterations: 100
+population_size: 60  
+num_islands: 4
+exploitation_ratio: 0.7
+```
+
+### Phase 2: Breaking Through the Plateau
+
+After the initial exploration phase, we observed our solutions plateauing around 2.377. For the second phase, we reconfigured OpenEvolve to encourage more radical innovations:
+
+- Increased the population size to promote diversity
+- Lowered the exploitation ratio to favor exploration
+- Updated the system prompt to suggest different optimization techniques
+- Allowed for longer and more complex code solutions
+
+Configuration highlights:
+```yaml
+max_iterations: 100
+population_size: 70  
+num_islands: 5
+exploitation_ratio: 0.6
+```
+
+## Evolution Progress
+
+We tracked the evolution over 470 generations, capturing visualizations at each checkpoint. The progression shows dramatic improvements in the packing strategy:
+
+### Initial Solution (Generation 0)
+
+The initial program used a simple constructive approach with a central circle and two concentric rings:
+
+```python
+# Initial attempt
+# Place a large circle in the center
+centers[0] = [0.5, 0.5]
+
+# Place 8 circles around it in a ring
+for i in range(8):
+    angle = 2 * np.pi * i / 8
+    centers[i + 1] = [0.5 + 0.3 * np.cos(angle), 0.5 + 0.3 * np.sin(angle)]
+
+# Place 16 more circles in an outer ring
+for i in range(16):
+    angle = 2 * np.pi * i / 16
+    centers[i + 9] = [0.5 + 0.7 * np.cos(angle), 0.5 + 0.7 * np.sin(angle)]
+```
+
+This approach yielded a sum of radii of approximately 0.959.
+
+![Initial Circle Packing](circle_packing_1.png)
+
+### Generation 10 Breakthrough
+
+By generation 10, OpenEvolve had already discovered a more sophisticated approach:
+
+```python
+# Generation 10
+# Parameters for the arrangement (fine-tuned)
+r_center = 0.1675  # Central circle radius
+
+# 1. Place central circle
+centers[0] = [0.5, 0.5]
+radii[0] = r_center
+
+# 2. First ring: 6 circles in hexagonal arrangement
+r_ring1 = 0.1035
+ring1_distance = r_center + r_ring1 + 0.0005  # Small gap for stability
+for i in range(6):
+    angle = 2 * np.pi * i / 6
+    centers[i+1] = [
+        0.5 + ring1_distance * np.cos(angle),
+        0.5 + ring1_distance * np.sin(angle)
+    ]
+    radii[i+1] = r_ring1
+```
+
+The key innovations at this stage included:
+- A carefully tuned hexagonal arrangement for the first ring
+- Strategic placement of corner circles
+- An additional optimization step to maximize each circle's radius
+
+This approach achieved a sum of radii of approximately 1.795.
+
+![Generation 10 Packing](circle_packing_10.png)
+
+### Generation 100: Grid-Based Approach
+
+By generation 100, OpenEvolve had pivoted to a grid-based approach with variable sized circles:
+
+```python
+# Generation 100
+# Row 1: 5 circles
+centers[0] = [0.166, 0.166]
+centers[1] = [0.333, 0.166]
+centers[2] = [0.500, 0.166]
+centers[3] = [0.667, 0.166]
+centers[4] = [0.834, 0.166]
+
+# Row 2: 6 circles (staggered)
+centers[5] = [0.100, 0.333]
+centers[6] = [0.266, 0.333]
+# ... additional circles
+```
+
+Key innovations:
+- Grid-like pattern with staggered rows
+- Variable circle sizes based on position (larger in the center)
+- More aggressive optimization routine with 50 iterations
+
+This approach achieved a sum of radii of approximately 2.201.
+
+![Generation 100 Packing](circle_packing_190.png)
+
+### Final Solution: Mathematical Optimization
+
+The breakthrough came when OpenEvolve discovered the power of mathematical optimization techniques. The final solution uses:
+
+```python
+# Final solution with scipy.optimize
+def construct_packing():
+    # ... initialization code ...
+    
+    # Objective function: Negative sum of radii (to maximize)
+    def objective(x):
+        centers = x[:2*n].reshape(n, 2)
+        radii = x[2*n:]
+        return -np.sum(radii)
+
+    # Constraint: No overlaps and circles stay within the unit square
+    def constraint(x):
+        centers = x[:2*n].reshape(n, 2)
+        radii = x[2*n:]
+        
+        # Overlap constraint
+        overlap_constraints = []
+        for i in range(n):
+            for j in range(i + 1, n):
+                dist = np.sqrt(np.sum((centers[i] - centers[j])**2))
+                overlap_constraints.append(dist - (radii[i] + radii[j]))
+        # ... boundary constraints ...
+        
+    # Optimization using SLSQP
+    result = minimize(objective, x0, method='SLSQP', bounds=bounds, constraints=constraints)
+```
+
+The key innovation in the final solution:
+- Using `scipy.optimize.minimize` with SLSQP method to find the optimal configuration
+- Formulating circle packing as a constrained optimization problem
+- Representing both circle positions and radii as optimization variables
+- Carefully crafted constraints to enforce non-overlap and boundary conditions
+
+This approach achieved a sum of radii of 2.634, matching the AlphaEvolve paper's result of 2.635 to within 0.04%!
+
+![Final Packing Solution](circle_packing_460.png)
+
+## Results
+
+Our final solution achieves:
+
+```
+Sum of radii: 2.634292402141039
+Target ratio: 0.9997314619131079 (99.97% of AlphaEvolve's result)
+```
+
+This demonstrates that OpenEvolve can successfully reproduce the results from the AlphaEvolve paper on this mathematical optimization problem.
+
+## Key Observations
+
+The evolution process demonstrated several interesting patterns:
+
+1. **Algorithm Transition**: OpenEvolve discovered increasingly sophisticated algorithms, from basic geometric constructions to advanced mathematical optimization techniques.
+
+2. **Exploration-Exploitation Balance**: The two-phase approach was crucial - initial exploration of different patterns followed by exploitation and refinement of the most promising approaches.
+
+3. **Breakthrough Discoveries**: The most significant improvements came from fundamental changes in approach (e.g., switching from manual construction to mathematical optimization), not just parameter tuning.
+
+4. **Code Complexity Evolution**: As the solutions improved, the code grew in complexity, adopting more sophisticated mathematical techniques.
+
+## Running the Example
+
+To reproduce our results:
+
+```bash
+# Phase 1: Initial exploration
+python openevolve-run.py examples/circle_packing/initial_program.py \
+  examples/circle_packing/evaluator.py \
+  --config examples/circle_packing/config_phase_1.yaml \
+  --iterations 100
+
+# Phase 2: Breaking through the plateau
+python openevolve-run.py examples/circle_packing/openevolve_output/checkpoints/checkpoint_100/best_program.py \
+  examples/circle_packing/evaluator.py \
+  --config examples/circle_packing/config_phase_2.yaml \
+  --iterations 100
+```
+
+To visualize the best solution:
+
+```python
+from examples.circle_packing.openevolve_output.best.best_program import run_packing, visualize
+
+centers, radii, sum_radii = run_packing()
+print(f"Sum of radii: {sum_radii}")
+visualize(centers, radii)
+```
+
+## Conclusion
+
+This example demonstrates OpenEvolve's ability to discover sophisticated algorithms for mathematical optimization problems. By evolving from simple constructive approaches to advanced numerical optimization techniques, OpenEvolve was able to match the results reported in the AlphaEvolve paper.
+
+The circle packing problem shows how OpenEvolve can discover not just improvements to existing algorithms, but entirely new algorithmic approaches, transitioning from manual geometric construction to principled mathematical optimization.

examples/circle_packing2/ablation_adaptive_exploration_gpt5_1_uniform/checkpoints/checkpoint_10/best_program.py

@@ -0,0 +1,95 @@
+# EVOLVE-BLOCK-START
+"""Constructor-based circle packing for n=26 circles (5 hex rows + 3 boundary fillers)"""
+import numpy as np
+
+def construct_packing():
+    # Base hex parameters: 5 rows with counts [5,4,5,4,5] at radius r≈0.1
+    eps = 1e-9
+    r = 0.1 - 1e-6
+    s = 2 * r
+    v = np.sqrt(3) * r
+
+    centers = []
+    radii = []
+
+    # 23 base circles: rows j=0..4; even rows have 5, odd rows have 4
+    for j in range(5):
+        y = r + j * v
+        if j % 2 == 0:
+            xs = r + s * np.arange(5)  # 5 circles
+        else:
+            xs = 2 * r + s * np.arange(4)  # 4 circles
+        for x in xs:
+            centers.append([x, y])
+            radii.append(r)
+
+    # Extra 1: top cap centered above the middle gap of the top row, tangent to top boundary and two neighbors
+    y_top = r + 4 * v
+    dy0 = 1.0 - y_top
+    r_top = (dy0 * dy0) / (2.0 * (dy0 + r)) - eps
+    centers.append([6.0 * r, 1.0 - r_top])
+    radii.append(r_top)
+
+    # Side fillers: tangent to a side wall and to two adjacent base circles in rows j=2 and j=3
+    # Closed-form for side radius Re = r * (9 - 6*sqrt(2))
+    r_side = r * (9.0 - 6.0 * np.sqrt(2.0)) - eps
+    y2 = r + 2 * v  # row j=2 (even)
+    y_side = y2 + 2.0 * np.sqrt(r * r_side)
+
+    # Extra 2: left wall filler
+    centers.append([r_side, y_side])
+    radii.append(r_side)
+
+    # Extra 3: right wall filler
+    centers.append([1.0 - r_side, y_side])
+    radii.append(r_side)
+
+    centers = np.array(centers, dtype=float)
+    radii = np.array(radii, dtype=float)
+    return centers, radii, float(np.sum(radii))
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii, sum_radii = construct_packing()
+    return centers, radii, sum_radii
+
+
+def visualize(centers, radii):
+    """
+    Visualize the circle packing
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates
+        radii: np.array of shape (n) with radius of each circle
+    """
+    import matplotlib.pyplot as plt
+    from matplotlib.patches import Circle
+
+    fig, ax = plt.subplots(figsize=(8, 8))
+
+    # Draw unit square
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.set_aspect("equal")
+    ax.grid(True)
+
+    # Draw circles
+    for i, (center, radius) in enumerate(zip(centers, radii)):
+        circle = Circle(center, radius, alpha=0.5)
+        ax.add_patch(circle)
+        ax.text(center[0], center[1], str(i), ha="center", va="center")
+
+    plt.title(f"Circle Packing (n={len(centers)}, sum={sum(radii):.6f})")
+    plt.show()
+
+
+if __name__ == "__main__":
+    centers, radii, sum_radii = run_packing()
+    print(f"Sum of radii: {sum_radii}")
+    # AlphaEvolve improved this to 2.635
+
+    # Uncomment to visualize:
+    visualize(centers, radii)

examples/circle_packing2/ablation_adaptive_exploration_gpt5_1_uniform/checkpoints/checkpoint_10/best_program_info.json

@@ -0,0 +1,16 @@
+{
+  "id": "081287e7-617c-4fbd-932c-566bc47827e6",
+  "generation": 2,
+  "iteration": 10,
+  "current_iteration": 10,
+  "metrics": {
+    "validity": 1.0,
+    "sum_radii": 2.4727904211504157,
+    "target_ratio": 0.9384403875333647,
+    "combined_score": 0.9384403875333647,
+    "eval_time": 0.10989785194396973
+  },
+  "language": "python",
+  "timestamp": 1764107953.884554,
+  "saved_at": 1764107953.903265
+}

examples/circle_packing2/ablation_adaptive_exploration_gpt5_1_uniform/checkpoints/checkpoint_10/metadata.json

@@ -0,0 +1 @@
+{"island_feature_maps": [{"5-0": "4729e582-068c-4351-bf48-ad07e9106ae8", "0-5": "bbc93d74-31ad-4b42-9fa3-47261dacd215", "0-0": "12218e4b-302c-45c4-8777-2ea0212b20cf", "7-0": "07a4c40f-72f0-40f1-892b-9b5455d1c286", "1-0": "a33bc75f-6e8f-4713-a03f-0100f8578774", "3-0": "081287e7-617c-4fbd-932c-566bc47827e6", "7-2": "17296b5b-f0e0-44d9-9df7-a5718801246a", "0-1": "c24543c7-3e77-4b14-aeb7-f053e3e86ac0"}, {}, {}, {}], "islands": [["c24543c7-3e77-4b14-aeb7-f053e3e86ac0", "081287e7-617c-4fbd-932c-566bc47827e6", "a33bc75f-6e8f-4713-a03f-0100f8578774", "12218e4b-302c-45c4-8777-2ea0212b20cf", "104bdb8e-4d64-479b-84c7-834258d289cf", "17296b5b-f0e0-44d9-9df7-a5718801246a", "c96b4c0b-2a34-4683-b4ca-cd4943d4ba63", "4d6844ef-73f8-4b22-bc30-920b8736a8aa", "bbc93d74-31ad-4b42-9fa3-47261dacd215", "07a4c40f-72f0-40f1-892b-9b5455d1c286", "4729e582-068c-4351-bf48-ad07e9106ae8"], ["a566ffe9-5599-4975-b096-5530385b4d60"], [], ["784810f9-7415-427b-850f-aed5a28d231a"]], "archive": ["c24543c7-3e77-4b14-aeb7-f053e3e86ac0", "081287e7-617c-4fbd-932c-566bc47827e6", "a33bc75f-6e8f-4713-a03f-0100f8578774", "12218e4b-302c-45c4-8777-2ea0212b20cf", "104bdb8e-4d64-479b-84c7-834258d289cf", "17296b5b-f0e0-44d9-9df7-a5718801246a", "c96b4c0b-2a34-4683-b4ca-cd4943d4ba63", "4d6844ef-73f8-4b22-bc30-920b8736a8aa", "bbc93d74-31ad-4b42-9fa3-47261dacd215", "07a4c40f-72f0-40f1-892b-9b5455d1c286", "4729e582-068c-4351-bf48-ad07e9106ae8"], "best_program_id": "081287e7-617c-4fbd-932c-566bc47827e6", "island_best_programs": ["081287e7-617c-4fbd-932c-566bc47827e6", null, null, null], "last_iteration": 10, "current_island": 2, "island_generations": [4, 4, 3, 2], "last_migration_generation": 0, "feature_stats": {"complexity": {"min": 2162.0, "max": 3873.0, "values": [3873.0, 2486.0, 2579.0, 3494.0, 3304.0, 2375.0, 3494.0, 2375.0, 2486.0, 3494.0, 3304.0, 3133.0, 2486.0, 2375.0, 3133.0, 2486.0, 3494.0, 3304.0, 2610.0, 2610.0, 2610.0, 2375.0, 3133.0, 2486.0, 3494.0, 3304.0, 2889.0, 3439.0, 2390.0, 2162.0, 2271.0, 2791.0]}, "diversity": {"min": 203.40666666666667, "max": 652.7, "values": [652.7, 337.84999999999997, 352.73333333333335, 286.3, 300.45, 352.73333333333335, 300.45, 652.7, 352.73333333333335, 286.3, 245.9, 652.7, 300.45, 245.9, 652.7, 352.73333333333335, 286.3, 228.0375, 228.0375, 228.0375, 300.45, 245.9, 652.7, 352.73333333333335, 286.3, 210.6888888888889, 302.4818181818182, 208.85833333333332, 284.6692307692308, 229.6357142857143, 203.40666666666667]}}}