try evolving constuctors

Author: codelion

examples/circle_packing/README.md

@@ -1,4 +1,4 @@
-# Circle Packing Example (n=26)
+# Constructor-Based Circle Packing Example (n=26)
 
 This example attempts to replicate one of the specific results from the AlphaEvolve paper (Section B.12): packing 26 circles inside a unit square to maximize the sum of their radii.
 
@@ -8,35 +8,47 @@ The problem is to pack 26 disjoint circles inside a unit square so as to maximiz
 - Lie entirely within the unit square [0,1] × [0,1]
 - Not overlap with each other
 
-This is a well-studied problem in computational geometry with applications in various fields including material science, facility location, and computer graphics.
+According to the paper, AlphaEvolve improved the state of the art for n=26 from 2.634 to 2.635.
 
-## AlphaEvolve Result
+## Constructor-Based Approach
 
-According to the paper, AlphaEvolve improved the state of the art for n=26 from 2.634 to 2.635.
+Following insights from the AlphaEvolve paper, we use a constructor-based approach rather than a search algorithm:
+
+> "For problems with highly symmetric solutions it is advantageous to evolve constructor functions as these tend to be more concise." - AlphaEvolve paper, Section 2.1
+
+Instead of evolving a search algorithm that tries different configurations, we evolve a function that directly constructs a specific packing arrangement. This approach:
+
+1. Is more deterministic (produces the same output each time)
+2. Can leverage geometric knowledge about optimal packings
+3. Tends to be more concise and easier to evolve
+4. Works well for problems with inherent structure or symmetry
 
 ## Running the Example
 
 ```bash
-python openevolve-run.py examples/circle_packing/initial_program.py examples/circle_packing/evaluator.py --config examples/circle_packing/config.yaml --iterations 100
+python openevolve-run.py examples/circle_packing/initial_program.py examples/circle_packing/evaluator.py --config examples/circle_packing/config.yaml --iterations 200
 ```
 
+## Evolved Constructor Functions
+
+The evolution might discover various pattern-based approaches:
+
+1. **Concentric rings**: Placing circles in concentric rings around a central circle
+2. **Hexagonal patterns**: Portions of a hexagonal lattice (theoretically optimal for infinite packings)
+3. **Mixed-size arrangements**: Varying circle sizes to better utilize space near the boundaries
+4. **Specialized patterns**: Custom arrangements specific to n=26
+
 ## Evaluation Metrics
 
 The evaluator calculates several metrics:
-- `sum_radii`: The best sum of radii achieved across all trials
-- `avg_sum_radii`: Average sum of radii across successful trials
+- `sum_radii`: The sum of radii achieved by the constructor
 - `target_ratio`: Ratio of achieved sum to target (2.635)
-- `reliability`: Fraction of trials that produced valid solutions
-- `avg_time`: Average execution time
-- `combined_score`: A weighted combination of the above metrics (main fitness metric)
-
-## Expected Results
-
-A successful run should find a packing arrangement with sum of radii approaching or exceeding the value reported in the AlphaEvolve paper: 2.635 for n=26.
+- `validity`: Confirms circles don't overlap and stay within bounds
+- `combined_score`: A weighted combination of metrics (main fitness metric)
 
 ## Visualization
 
-The initial program includes a visualization function that you can use to see the packing arrangement:
+The program includes a visualization function to see the constructed packing:
 
 ```python
 # Add this to the end of the best program
@@ -45,3 +57,9 @@ if __name__ == "__main__":
     print(f"Sum of radii: {sum_radii}")
     visualize(centers, radii)
 ```
+
+## What to Expect
+
+The evolution process should discover increasingly better constructor functions, with several possible patterns emerging. Given enough iterations, it should approach or exceed the 2.635 value achieved in the paper.
+
+Different runs may converge to different packing strategies, as multiple near-optimal arrangements are possible for this problem.

examples/circle_packing/config.yaml

@@ -1,8 +1,7 @@
-# Configuration for circle packing example
-max_iterations: 100
+# Configuration for circle packing constructor evolution (n=26)
+max_iterations: 100  # Increased iterations
 checkpoint_interval: 10
 log_level: "INFO"
-max_code_length: 100000 
 
 # LLM configuration
 llm:
@@ -21,16 +20,27 @@ llm:
 
 # Prompt configuration
 prompt:
-  system_message: "You are an expert programmer specializing in optimization algorithms and computational geometry. Your task is to improve a circle packing algorithm to maximize the sum of radii when packing 26 circles in a unit square without overlaps. The AlphaEvolve paper achieved a sum of 2.635 for n=26, which is the target value to reach or exceed. Focus on finding better optimization strategies, leveraging geometric insights about optimal packing arrangements, and developing more effective search techniques."
+  system_message: |
+    You are an expert mathematician specializing in circle packing problems and computational geometry. Your task is to improve a constructor function that directly produces a specific arrangement of 26 circles in a unit square, maximizing the sum of their radii. The AlphaEvolve paper achieved a sum of 2.635 for n=26.
+
+    Key geometric insights:
+    - Circle packings often follow hexagonal patterns in the densest regions
+    - Maximum density for infinite circle packing is pi/(2*sqrt(3)) ≈ 0.9069
+    - Edge effects make square container packing harder than infinite packing
+    - Circles can be placed in layers or shells when confined to a square
+    - Similar radius circles often form regular patterns, while varied radii allow better space utilization
+    - Perfect symmetry may not yield the optimal packing due to edge effects
+
+    Focus on designing an explicit constructor that places each circle in a specific position, rather than an iterative search algorithm.
   num_top_programs: 3
   use_template_stochasticity: true
 
 # Database configuration
 database:
-  population_size: 50
-  archive_size: 20
-  num_islands: 3
-  elite_selection_ratio: 0.2
+  population_size: 60  # Increased population for more diversity
+  archive_size: 25
+  num_islands: 4
+  elite_selection_ratio: 0.3
   exploitation_ratio: 0.7
 
 # Evaluator configuration
@@ -42,5 +52,5 @@ evaluator:
   use_llm_feedback: false
 
 # Evolution settings
-diff_based_evolution: true
-allow_full_rewrites: false
+diff_based_evolution: false  # Use full rewrites instead of diffs
+allow_full_rewrites: true    # Allow full rewrites for constructor functions