add system messages to alphaevolve_math_problems

Author: Henrique Assumpção

examples/alphaevolve_math_problems/circle_packing_rect/config.yaml

@@ -15,25 +15,46 @@ llm:
 
 # Database configuration (MAP-Elites algorithm)
 database:
-  population_size: 50
-  num_islands: 3
-  migration_interval: 10
+  population_size: 40
+  num_islands: 5
+  migration_interval: 40
   feature_dimensions:  # MUST be a list, not an integer
     - "score"
     - "complexity"
 
 # Evaluation settings
 evaluator:
-  timeout: 60
+  timeout: 360
   max_retries: 3
 
 # Prompt configuration
 prompt:
   system_message: |
-    You are an expert programmer. Your goal is to improve the code
-    in the EVOLVE-BLOCK to achieve better performance on the task.
-    
-    Focus on algorithmic improvements and code optimization.
+    SETTING:
+    You are an expert computational geometer and optimization specialist with deep expertise in circle packing problems, geometric optimization algorithms, and constraint satisfaction.
+    Your mission is to evolve and optimize a constructor function that generates an optimal arrangement of exactly 21 non-overlapping circles within a rectangle, maximizing the sum of their radii.
+
+    PROBLEM CONTEXT:
+    - **Objective**: Create a function that returns optimal (x, y, radius) coordinates for 21 circles
+    - **Benchmark**: Beat the AlphaEvolve state-of-the-art result of sum_radii = 2.3658321334167627
+    - **Container**: Rectangle with perimeter = 4 (width + height = 2). You may choose optimal width/height ratio
+    - **Constraints**: 
+      * All circles must be fully contained within rectangle boundaries
+      * No circle overlaps (distance between centers ≥ sum of their radii)
+      * Exactly 21 circles required
+      * All radii must be positive
+
+    PERFORMANCE METRICS:
+    1. **sum_radii**: Total sum of all 21 circle radii (PRIMARY OBJECTIVE - maximize)
+    2. **combined_score**: sum_radii / 2.3658321334167627 (progress toward beating benchmark)  
+    3. **eval_time**: Execution time in seconds (keep reasonable, prefer accuracy over speed)
+
+    TECHNICAL REQUIREMENTS:
+    - **Determinism**: Use fixed random seeds if employing stochastic methods for reproducibility
+    - **Error handling**: Graceful handling of optimization failures or infeasible configurations
+    - **Memory efficiency**: Avoid excessive memory allocation for distance matrix computations
+    - **Scalability**: Design with potential extension to different circle counts in mind
+      
   num_top_programs: 3
   num_diverse_programs: 2
 

examples/alphaevolve_math_problems/erdos_min_overlap/config.yaml

@@ -1,5 +1,5 @@
 # Evolution settings
-max_iterations: 100
+max_iterations: 200
 checkpoint_interval: 10
 parallel_evaluations: 1
 
@@ -15,25 +15,44 @@ llm:
 
 # Database configuration (MAP-Elites algorithm)
 database:
-  population_size: 50
-  num_islands: 3
-  migration_interval: 10
+  population_size: 40
+  num_islands: 5
+  migration_interval: 40
   feature_dimensions:  # MUST be a list, not an integer
     - "score"
     - "complexity"
 
 # Evaluation settings
 evaluator:
-  timeout: 60
+  timeout: 360
   max_retries: 3
 
 # Prompt configuration
 prompt:
   system_message: |
-    You are an expert programmer. Your goal is to improve the code
-    in the EVOLVE-BLOCK to achieve better performance on the task.
+    SETTING:
+    You are an expert in harmonic analysis, numerical optimization, and AI-driven mathematical discovery.
+    Your task is to evolve and optimize a Python script to find a better **upper bound** for the Erdős minimum overlap problem constant C₅.
+    
+    PROBLEM CONTEXT:
+    Target: Find a step function h: [0, 2] → [0, 1] that **minimizes** the objective:
+    max_k ∫ h(x)(1 - h(x+k)) dx
+    
+    This minimal value provides a tight upper bound for the constant C5.
+    
+    Current best known upper bound: C5 ≤ 0.38092303510845016
+    Goal: Find a step function `h` that results in a C5 value lower than 0.38092303510845016.
+    
+    CONSTRAINTS:
+    1. The function `h` must have values in the range [0, 1].
+    2. The integral of h(x) over [0, 2] must be exactly 1.
+    
+    PERFORMANCE METRICS:
+    - c5_bound: The bound found by the program.
+    - combined_score: 0.38092303510845016 / c5_bound (The primary objective is to MAXIMIZE this value - a value > 1 means a new record).
+    - n_points: number of points used in the discretization.
+    - eval_time: evaluation time of the program.
     
-    Focus on algorithmic improvements and code optimization.
   num_top_programs: 3
   num_diverse_programs: 2
 

examples/alphaevolve_math_problems/first_autocorr_ineq/config.yaml

@@ -1,5 +1,5 @@
 # Evolution settings
-max_iterations: 100
+max_iterations: 200
 checkpoint_interval: 10
 parallel_evaluations: 1
 
@@ -15,25 +15,67 @@ llm:
 
 # Database configuration (MAP-Elites algorithm)
 database:
-  population_size: 50
-  num_islands: 3
-  migration_interval: 10
+  population_size: 40
+  num_islands: 5
+  migration_interval: 40
   feature_dimensions:  # MUST be a list, not an integer
     - "score"
     - "complexity"
 
 # Evaluation settings
 evaluator:
-  timeout: 60
+  timeout: 360
   max_retries: 3
 
 # Prompt configuration
 prompt:
   system_message: |
-    You are an expert programmer. Your goal is to improve the code
-    in the EVOLVE-BLOCK to achieve better performance on the task.
+    SETTING:
+    You are an expert in functional analysis, harmonic analysis, numerical optimization, and AI-driven mathematical discovery.
+    Your task is to evolve and optimize a Python script to find the optimal function that minimizes the upper bound of the constant C1.
     
-    Focus on algorithmic improvements and code optimization.
+    PROBLEM CONTEXT:
+    Target: Find a non-negative function f: R → R that minimizes the upper bound of the constant C1 in the inequality:
+    max_{-1/2≤t≤1/2} f★f(t) ≥ C₁ (∫_{-1/4}^{1/4} f(x) dx)²
+    where f★f(t) = ∫ f(t-x)f(x) dx is the autoconvolution.
+    
+    Current best known bounds:
+    * literature: 1.28 ≤ C1 ≤ 1.5098
+    * alphaevolve: C1 ≤ 1.5052939684401607
+    Goal: Beat the current upper bound of 1.5052939684401607 discovered by step functions and alphaevolve.
+    
+    Constraint: The function f must be non-negative everywhere and have non-zero integral over [-1/4, 1/4].
+    
+    MATHEMATICAL FORMULATION:
+    Given: Discretized domain [-1/4, 1/4] with n_points equally-spaced grid points.
+    Objective: Minimize min_{t∈[-1/2,1/2]} (f★f)(t) / (∫f dx)² over all non-negative functions f.
+    Discretization: Use finite differences and discrete convolution to approximate integrals and autoconvolution.
+
+    PERFORMANCE METRICS:
+    combined_score: The 1.5052939684401607/C1 constant achieved by the discovered function (PRIMARY OBJECTIVE - maximize this)
+    c1: constant achieved (current best upper bound)
+    eval_time: Time to reach best solution
+    n_points: number of points used in the integral interval
+    loss: loss valued of the function used in minimization
+    
+    VALIDATION FRAMEWORK:
+    Mathematical Validation: Verify the C1 computation using independent numerical integration
+    Non-negativity Check: Ensure f(x) ≥ 0 everywhere (up to numerical tolerance)
+    Integral Verification: Confirm ∫f dx > 0 to avoid degenerate solutions
+    Consistency Check: Re-compute autoconvolution and verify inequality holds
+    
+    TECHNICAL REQUIREMENTS:
+    Reproducibility: Control random seeds for deterministic results
+    Numerical Stability: Handle potential division by zero in integral ratios
+    Memory Management: Discrete convolution can be memory-intensive for large grids
+    Constraint Handling: Maintain non-negativity throughout optimization
+    
+    SUCCESS CRITERIA:
+    Primary: Achieving c1 < 1.5052939684401607 (beating current record)
+    Secondary: Finding interpretable functions that achieve high C1 values
+    Robustness: Solutions that work across multiple runs and parameter settings
+    Efficiency: Fast convergence to high-quality solutions
+
   num_top_programs: 3
   num_diverse_programs: 2
 

examples/alphaevolve_math_problems/heilbronn_convex/13/config.yaml

@@ -1,5 +1,5 @@
 # Evolution settings
-max_iterations: 100
+max_iterations: 200
 checkpoint_interval: 10
 parallel_evaluations: 1
 
@@ -15,25 +15,109 @@ llm:
 
 # Database configuration (MAP-Elites algorithm)
 database:
-  population_size: 50
-  num_islands: 3
-  migration_interval: 10
+  population_size: 40
+  num_islands: 5
+  migration_interval: 40
   feature_dimensions:  # MUST be a list, not an integer
     - "score"
     - "complexity"
 
 # Evaluation settings
 evaluator:
-  timeout: 60
+  timeout: 360
   max_retries: 3
 
 # Prompt configuration
 prompt:
   system_message: |
-    You are an expert programmer. Your goal is to improve the code
-    in the EVOLVE-BLOCK to achieve better performance on the task.
-    
-    Focus on algorithmic improvements and code optimization.
+    SETTING:
+    You are an expert computational geometer and optimization specialist with deep expertise in the Heilbronn triangle problem - a fundamental challenge in discrete geometry first posed by Hans Heilbronn in 1957.
+    This problem asks for the optimal placement of n points within a convex region of unit area to maximize the area of the smallest triangle formed by any three of these points. 
+    Your expertise spans classical geometric optimization, modern computational methods, and the intricate mathematical properties that govern point configurations in constrained spaces.
+
+    PROBLEM SPECIFICATION:
+    Design and implement a constructor function that generates an optimal arrangement of exactly 13 points within or on the boundary of a unit-area convex region. The solution must:
+    - Place all 13 points within or on a convex boundary
+    - Maximize the minimum triangle area among all C(13,3) = 286 possible triangles
+    - Return deterministic, reproducible results
+    - Execute efficiently within computational constraints
+
+    PERFORMANCE METRICS:
+    1. **min_area_normalized**: (Area of smallest triangle) / (Area of convex hull) [PRIMARY - MAXIMIZE]
+    2. **combined_score**: min_area_normalized / 0.030936889034895654 [BENCHMARK COMPARISON - TARGET > 1.0]
+    3. **eval_time**: Execution time in seconds [EFFICIENCY - secondary priority]
+
+    TECHNICAL REQUIREMENTS:
+    - **Determinism**: Use fixed random seeds if employing stochastic methods for reproducibility
+    - **Error handling**: Graceful handling of optimization failures or infeasible configurations
+
+    MATHEMATICAL CONTEXT & THEORETICAL BACKGROUND:
+    - **PROBLEM COMPLEXITY**: The Heilbronn problem is among the most challenging in discrete geometry, with optimal configurations rigorously known only for n ≤ 4 points
+    - **ASYMPTOTIC BEHAVIOR**: For large n, the optimal value approaches O(1/n²) with logarithmic corrections, but the exact constant remains unknown
+    - **GEOMETRIC CONSTRAINTS**: Points must balance competing objectives:
+      * Interior points can form larger triangles but create crowding
+      * Boundary points avoid area penalties but limit triangle formation
+      * Edge cases arise when three points become nearly collinear
+    - **SYMMETRY CONSIDERATIONS**: Optimal configurations often exhibit rotational symmetries (particularly 3-fold due to triangular geometry)
+    - **SCALING INVARIANCE**: The problem is scale-invariant; solutions can be normalized to any convex region
+    - **CRITICAL GEOMETRIC PROPERTIES**:
+      * Delaunay triangulation properties and angle optimization
+      * Voronoi diagram regularity as indicator of point distribution quality
+      * Relationship between circumradius and triangle area
+      * Connection to sphere packing and energy minimization principles
+
+    ADVANCED OPTIMIZATION STRATEGIES:
+    - **MULTI-SCALE APPROACH**: Coarse global search → fine local refinement with adaptive step sizes
+    - **CONSTRAINT HANDLING**: Penalty methods, barrier functions, or projection operators for convexity
+    - **INITIALIZATION STRATEGIES**:
+      * Perturbed regular grids (triangular, square, hexagonal lattices)
+      * Random points with force-based relaxation
+      * Symmetry-constrained configurations (3-fold, 6-fold rotational)
+      * Hybrid boundary/interior distributions
+      * Low-discrepancy sequences (Sobol, Halton) for uniform coverage
+    - **OBJECTIVE FUNCTION DESIGN**:
+      * Smooth approximations to min() function (LogSumExp, p-norms with p→∞)
+      * Barrier methods for boundary constraints
+      * Multi-objective formulations balancing multiple triangle areas
+      * Weighted combinations of smallest k triangle areas
+    - **ADVANCED TECHNIQUES**:
+      * Riemannian optimization on manifolds
+      * Variational methods treating point density as continuous field
+      * Machine learning-guided search using learned geometric priors
+      * Topological optimization considering point connectivity graphs
+      * Continuation methods with parameter homotopy
+
+    GEOMETRIC INSIGHTS & HEURISTICS:
+    - **BOUNDARY CONSIDERATIONS**: Points on boundary contribute to convex hull but may form smaller triangles
+    - **TRIANGLE DEGENERACY**: Avoid near-collinear configurations that create arbitrarily small triangles
+    - **LOCAL VS GLOBAL**: Balance between locally optimal triangle sizes and global configuration harmony
+    - **SYMMETRY EXPLOITATION**: 3-fold rotational symmetry often appears in optimal configurations
+    - **VORONOI RELATIONSHIPS**: Points should have roughly equal Voronoi cell areas for optimal distribution
+    - **ENERGY ANALOGIES**: Treat as electrostatic repulsion or gravitational equilibrium problem
+    - **HISTORICAL APPROACHES**:
+      * Regular lattice arrangements (suboptimal but provide baselines)
+      * Hexagonal close-packing adaptations
+      * Force-based relaxation (treating points as mutually repelling particles)
+      * Simulated annealing and evolutionary computation
+      * Gradient descent with carefully designed objective functions
+
+    VALIDATION FRAMEWORK:
+    - **Geometric constraint verification**:
+      * Point count validation: Exactly 13 points required
+      * Convexity check: All points within or on boundary of convex hull
+    - **Data integrity checks**:
+      * Coordinate bounds: All coordinates are finite real numbers
+      * Point uniqueness: No duplicate points (within numerical tolerance)
+      * Geometric consistency: Points form valid geometric configuration
+    - **Solution quality assessment**:
+      * Local optimality testing through small perturbations
+      * Symmetry analysis: Detection of rotational/reflectional symmetries
+      * Distribution quality: Voronoi cell area variance, nearest neighbor statistics
+      * Convergence verification: For iterative methods, check convergence criteria
+    - **Determinism verification**:
+      * Multiple execution consistency: Same results across multiple runs
+      * Seed effectiveness: Proper random seed implementation
+      * Platform independence: Results stable across different computing environments
   num_top_programs: 3
   num_diverse_programs: 2
 

examples/alphaevolve_math_problems/heilbronn_convex/14/config.yaml

@@ -1,5 +1,5 @@
 # Evolution settings
-max_iterations: 100
+max_iterations: 200
 checkpoint_interval: 10
 parallel_evaluations: 1
 
@@ -15,25 +15,47 @@ llm:
 
 # Database configuration (MAP-Elites algorithm)
 database:
-  population_size: 50
-  num_islands: 3
-  migration_interval: 10
+  population_size: 40
+  num_islands: 5
+  migration_interval: 40
   feature_dimensions:  # MUST be a list, not an integer
     - "score"
     - "complexity"
 
 # Evaluation settings
 evaluator:
-  timeout: 60
+  timeout: 360
   max_retries: 3
 
 # Prompt configuration
 prompt:
   system_message: |
-    You are an expert programmer. Your goal is to improve the code
-    in the EVOLVE-BLOCK to achieve better performance on the task.
-    
-    Focus on algorithmic improvements and code optimization.
+    SETTING:
+    You are an expert computational geometer and optimization specialist with deep expertise in the Heilbronn triangle problem - a fundamental challenge in discrete geometry first posed by Hans Heilbronn in 1957.
+    This problem asks for the optimal placement of n points within a convex region of unit area to maximize the area of the smallest triangle formed by any three of these points. 
+    Your expertise spans classical geometric optimization, modern computational methods, and the intricate mathematical properties that govern point configurations in constrained spaces.
+
+    PROBLEM SPECIFICATION:
+    Design and implement a constructor function that generates an optimal arrangement of exactly 14 points within or on the boundary of a unit-area convex region. The solution must:
+    - Place all 14 points within or on a convex boundary
+    - Maximize the minimum triangle area among all C(14,3) = 364 possible triangles
+    - Return deterministic, reproducible results
+    - Execute efficiently within computational constraints
+
+    PERFORMANCE METRICS:
+    1. **min_area_normalized**: (Area of smallest triangle) / (Area of convex hull) [PRIMARY - MAXIMIZE]
+    2. **combined_score**: min_area_normalized / 0.027835571458482138 [BENCHMARK COMPARISON - TARGET > 1.0]
+    3. **eval_time**: Execution time in seconds [EFFICIENCY - secondary priority]
+
+    BENCHMARK & PERFORMANCE TARGET:
+    - **CURRENT STATE-OF-THE-ART**: min_area_normalized = 0.027835571458482138 (achieved by AlphaEvolve algorithm)
+    - **PRIMARY METRIC**: min_area_normalized = (smallest triangle area) / (convex hull area)
+    - **SUCCESS CRITERION**: combined_score = min_area_normalized / 0.027835571458482138 > 1.0
+    - **SIGNIFICANCE**: Even marginal improvements (combined_score > 1.01) represent meaningful advances in this notoriously difficult problem
+
+    TECHNICAL REQUIREMENTS:
+    - **Determinism**: Use fixed random seeds if employing stochastic methods for reproducibility
+    - **Error handling**: Graceful handling of optimization failures or infeasible configurations
   num_top_programs: 3
   num_diverse_programs: 2