Add files using upload-large-folder tool

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/best/edit.diff

@@ -0,0 +1,212 @@
+--- a/original.py
++++ b/original.py
+@@ -1,203 +1,203 @@
+ # EVOLVE-BLOCK-START
+ """
+ Implements a long-run, highly adaptive Langevin-dynamics-inspired Simulated
+ Annealing (SA) algorithm for the circle packing problem. This hybrid version
+ combines the long search of one parent with the proven parameter set of a
+ higher-performing parent to achieve a superior result.
+ """
+ 
+ import numpy as np
+ 
+ def _compute_forces(centers, radii, sensitivity, max_force):
+     """Calculates repulsion forces based on gaps between circles and walls."""
+     n = centers.shape[0]
+     force_vectors = np.zeros_like(centers)
+ 
+     # Inter-circle forces
+     pdiff = centers[:, np.newaxis, :] - centers[np.newaxis, :, :]
+     pdist = np.sqrt(np.sum(pdiff**2, axis=-1))
+     np.fill_diagonal(pdist, np.inf)
+ 
+     radii_sum = radii[:, np.newaxis] + radii[np.newaxis, :]
+     gaps = pdist - radii_sum
+     force_magnitudes = np.exp(-sensitivity * gaps)
+ 
+     # Add a small epsilon to avoid division by zero
+     direction_vectors = pdiff / (pdist[..., np.newaxis] + 1e-12)
+     force_vectors += np.sum(force_magnitudes[..., np.newaxis] * direction_vectors, axis=1)
+ 
+     # Wall forces
+     gaps_walls = np.array([centers[:, 0] - radii, (1 - centers[:, 0]) - radii, centers[:, 1] - radii, (1 - centers[:, 1]) - radii]).T
+     force_magnitudes_walls = np.exp(-sensitivity * gaps_walls)
+     force_vectors[:, 0] += force_magnitudes_walls[:, 0]
+     force_vectors[:, 0] -= force_magnitudes_walls[:, 1]
+     force_vectors[:, 1] += force_magnitudes_walls[:, 2]
+     force_vectors[:, 1] -= force_magnitudes_walls[:, 3]
+ 
+     # Cap forces for stability
+     norms = np.linalg.norm(force_vectors, axis=1)
+     large_force_mask = norms > max_force
+     if np.any(large_force_mask):
+         force_vectors[large_force_mask] *= (max_force / (norms[large_force_mask, np.newaxis] + 1e-12))
+ 
+     return force_vectors
+ 
+ def construct_packing():
+     """
+     Constructs an optimized arrangement of 26 circles using a hybrid
+     Langevin-dynamics-inspired Simulated Annealing (SA) algorithm.
+     """
+     n = 26
+ 
+     # 1. Initial State: Proven 5x5 grid with two-stage perturbation.
+     centers = np.zeros((n, 2))
+     d = 0.09525
+     grid_coords = np.linspace(d, 1 - d, 5)
+     idx = 0
+     for x in grid_coords:
+         for y in grid_coords:
+             centers[idx] = [x, y]
+             idx += 1
+     centers[25] = [0.39, 0.41] # Key asymmetric perturbation
+ 
+     # Add a small random perturbation to break any remaining symmetries
+     perturbation_scale = 0.005
+     centers += np.random.uniform(-perturbation_scale, perturbation_scale, centers.shape)
+     centers = np.clip(centers, 0.01, 0.99)
+ 
+     # 2. Algorithm Parameters: Hybrid of long-run and proven parameters
+     max_steps = 150000
+     T_initial = 0.005
+     T_final = 1e-10  # Lower final temperature for the long run
+     alpha = (T_final / T_initial)**(1.0 / max_steps)
+ 
+     # Langevin Dynamics Parameters (from high-performing parent)
+     step_size_initial = 1.8e-3
+     noise_initial = 4.5e-3
+ 
+     # Force Calculation Parameter Schedules (from high-performing parent)
+     sensitivity_start = 180.0
+-    sensitivity_end = 250.0
++    sensitivity_end = 350.0 # Increased for sharper forces at end, closer to 2.61 ancestor (380.0)
+     max_force_start = 75.0
+-    max_force_end = 40.0
++    max_force_end = 30.0    # Reduced for finer control at end, closer to 2.61 ancestor (25.0)
+ 
+     # Radius Solver Parameter Schedules (long-run base with proven tweaks)
+-    q_iter_start, q_iter_end = 120, 500
++    q_iter_start, q_iter_end = 120, 400 # Aligned with 2.61 ancestor
+     q_init_uf_start, q_init_uf_end = 0.85, 0.6
+     q_final_uf_start, q_final_uf_end = 0.65, 0.4
+     q_switch_start, q_switch_end = 0.25, 0.5 # From high-performing parent
+ 
+     # 3. Initialization of State Variables and Schedules
+     current_centers = np.copy(centers)
+     best_centers = np.copy(centers)
+ 
+     # Pre-generate schedules for efficiency inside the loop
+     sensitivities = np.linspace(sensitivity_start, sensitivity_end, max_steps)
+     max_forces = np.linspace(max_force_start, max_force_end, max_steps)
+     q_iters = np.linspace(q_iter_start, q_iter_end, max_steps, dtype=int)
+     q_init_ufs = np.linspace(q_init_uf_start, q_init_uf_end, max_steps)
+     q_final_ufs = np.linspace(q_final_uf_start, q_final_uf_end, max_steps)
+     q_switches = np.linspace(q_switch_start, q_switch_end, max_steps)
+ 
+     # Initial evaluation
+     initial_solver_params = (q_init_ufs[0], q_final_ufs[0], q_switches[0])
+     current_radii = compute_max_radii(current_centers, iterations=q_iters[0], update_factor=initial_solver_params)
+     current_sum_radii = np.sum(current_radii)
+     best_sum_radii = current_sum_radii
+ 
+     T = T_initial
+ 
+     # 4. Main Langevin SA Loop
+     for step in range(max_steps):
+         # Anneal parameters based on temperature
+         anneal_factor = (T / T_initial)
+         step_sz = step_size_initial * anneal_factor**0.5
+-        noise_magnitude = noise_initial * anneal_factor
++        noise_magnitude = noise_initial * anneal_factor**0.5 # Aligned with 2.61 ancestor's scaling
+ 
+         # Get scheduled parameters for this step
+         sensitivity = sensitivities[step]
+         max_f = max_forces[step]
+         solver_params = (q_init_ufs[step], q_final_ufs[step], q_switches[step])
+         q_iter = q_iters[step]
+ 
+         # Propose a new state using Langevin dynamics
+         forces = _compute_forces(current_centers, current_radii, sensitivity, max_f)
+         noise = np.random.randn(n, 2) * noise_magnitude
+         move_vector = step_sz * forces + noise
+ 
+         candidate_centers = current_centers + move_vector
+         candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+ 
+         # Evaluate the new state
+         candidate_radii = compute_max_radii(candidate_centers, iterations=q_iter, update_factor=solver_params)
+         candidate_sum_radii = np.sum(candidate_radii)
+ 
+         # Metropolis-Hastings acceptance criterion (objective is to MAXIMIZE sum of radii)
+         delta_sum = candidate_sum_radii - current_sum_radii
+         if delta_sum > 0 or (T > 1e-12 and np.random.rand() < np.exp(delta_sum / T)):
+             current_centers = candidate_centers
+             current_sum_radii = candidate_sum_radii
+             current_radii = candidate_radii
+ 
+         # Update the best-ever found solution
+         if current_sum_radii > best_sum_radii:
+             best_sum_radii = current_sum_radii
+             best_centers = np.copy(current_centers)
+ 
+         # Cool down
+         T *= alpha
+ 
+-    # 5. Enhanced Final Polish (from high-performing parent)
+-    final_radii = compute_max_radii(best_centers, iterations=35000, update_factor=(0.7, 0.2, 0.5))
++    # 5. Enhanced Final Polish (from high-performing parent, adjusted to 2.61 ancestor)
++    final_radii = compute_max_radii(best_centers, iterations=35000, update_factor=(0.7, 0.3, 0.4))
+ 
+     return best_centers, final_radii
+ 
+ 
+ def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+     """
+     Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+     This version supports an adaptive damping schedule for the update factor.
+     """
+     n = centers.shape[0]
+     radii = np.full(n, 1e-6)
+ 
+     dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+     np.fill_diagonal(dist_matrix, np.inf)
+ 
+     wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+ 
+     if isinstance(update_factor, (float, int)):
+         initial_uf, final_uf, switch_ratio = float(update_factor), float(update_factor), 0.0
+     else:
+         initial_uf, final_uf, switch_ratio = update_factor
+ 
+     for k in range(iterations):
+         radii_old = np.copy(radii)
+ 
+         current_uf = initial_uf
+         if switch_ratio > 0 and k < iterations * switch_ratio:
+             progress = k / (iterations * switch_ratio)
+             current_uf = initial_uf + (final_uf - initial_uf) * progress
+         elif switch_ratio > 0:
+             current_uf = final_uf
+ 
+         potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+         potential_r = np.minimum(wall_dists, potential_r_circles)
+         new_r = np.maximum(0.0, potential_r)
+ 
+         radii = radii_old + current_uf * (new_r - radii_old)
+ 
+         if np.max(np.abs(radii - radii_old)) < 1e-9:
+             break
+ 
+     return radii
+ # EVOLVE-BLOCK-END
+ 
+ 
+ # This part remains fixed (not evolved)
+ def run_packing():
+     """Run the circle packing constructor for n=26"""
+     centers, radii = construct_packing()
+     # Calculate the sum of radii
+     sum_radii = np.sum(radii)
+     return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/best/main.py

@@ -0,0 +1,203 @@
+# EVOLVE-BLOCK-START
+"""
+Implements a long-run, highly adaptive Langevin-dynamics-inspired Simulated
+Annealing (SA) algorithm for the circle packing problem. This hybrid version
+combines the long search of one parent with the proven parameter set of a
+higher-performing parent to achieve a superior result.
+"""
+
+import numpy as np
+
+def _compute_forces(centers, radii, sensitivity, max_force):
+    """Calculates repulsion forces based on gaps between circles and walls."""
+    n = centers.shape[0]
+    force_vectors = np.zeros_like(centers)
+
+    # Inter-circle forces
+    pdiff = centers[:, np.newaxis, :] - centers[np.newaxis, :, :]
+    pdist = np.sqrt(np.sum(pdiff**2, axis=-1))
+    np.fill_diagonal(pdist, np.inf)
+
+    radii_sum = radii[:, np.newaxis] + radii[np.newaxis, :]
+    gaps = pdist - radii_sum
+    force_magnitudes = np.exp(-sensitivity * gaps)
+
+    # Add a small epsilon to avoid division by zero
+    direction_vectors = pdiff / (pdist[..., np.newaxis] + 1e-12)
+    force_vectors += np.sum(force_magnitudes[..., np.newaxis] * direction_vectors, axis=1)
+
+    # Wall forces
+    gaps_walls = np.array([centers[:, 0] - radii, (1 - centers[:, 0]) - radii, centers[:, 1] - radii, (1 - centers[:, 1]) - radii]).T
+    force_magnitudes_walls = np.exp(-sensitivity * gaps_walls)
+    force_vectors[:, 0] += force_magnitudes_walls[:, 0]
+    force_vectors[:, 0] -= force_magnitudes_walls[:, 1]
+    force_vectors[:, 1] += force_magnitudes_walls[:, 2]
+    force_vectors[:, 1] -= force_magnitudes_walls[:, 3]
+
+    # Cap forces for stability
+    norms = np.linalg.norm(force_vectors, axis=1)
+    large_force_mask = norms > max_force
+    if np.any(large_force_mask):
+        force_vectors[large_force_mask] *= (max_force / (norms[large_force_mask, np.newaxis] + 1e-12))
+
+    return force_vectors
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles using a hybrid
+    Langevin-dynamics-inspired Simulated Annealing (SA) algorithm.
+    """
+    n = 26
+
+    # 1. Initial State: Proven 5x5 grid with two-stage perturbation.
+    centers = np.zeros((n, 2))
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+    centers[25] = [0.39, 0.41] # Key asymmetric perturbation
+
+    # Add a small random perturbation to break any remaining symmetries
+    perturbation_scale = 0.005
+    centers += np.random.uniform(-perturbation_scale, perturbation_scale, centers.shape)
+    centers = np.clip(centers, 0.01, 0.99)
+
+    # 2. Algorithm Parameters: Hybrid of long-run and proven parameters
+    max_steps = 150000
+    T_initial = 0.005
+    T_final = 1e-10  # Lower final temperature for the long run
+    alpha = (T_final / T_initial)**(1.0 / max_steps)
+
+    # Langevin Dynamics Parameters (from high-performing parent)
+    step_size_initial = 1.8e-3
+    noise_initial = 4.5e-3
+
+    # Force Calculation Parameter Schedules (from high-performing parent)
+    sensitivity_start = 180.0
+    sensitivity_end = 350.0 # Increased for sharper forces at end, closer to 2.61 ancestor (380.0)
+    max_force_start = 75.0
+    max_force_end = 30.0    # Reduced for finer control at end, closer to 2.61 ancestor (25.0)
+
+    # Radius Solver Parameter Schedules (long-run base with proven tweaks)
+    q_iter_start, q_iter_end = 120, 400 # Aligned with 2.61 ancestor
+    q_init_uf_start, q_init_uf_end = 0.85, 0.6
+    q_final_uf_start, q_final_uf_end = 0.65, 0.4
+    q_switch_start, q_switch_end = 0.25, 0.5 # From high-performing parent
+
+    # 3. Initialization of State Variables and Schedules
+    current_centers = np.copy(centers)
+    best_centers = np.copy(centers)
+
+    # Pre-generate schedules for efficiency inside the loop
+    sensitivities = np.linspace(sensitivity_start, sensitivity_end, max_steps)
+    max_forces = np.linspace(max_force_start, max_force_end, max_steps)
+    q_iters = np.linspace(q_iter_start, q_iter_end, max_steps, dtype=int)
+    q_init_ufs = np.linspace(q_init_uf_start, q_init_uf_end, max_steps)
+    q_final_ufs = np.linspace(q_final_uf_start, q_final_uf_end, max_steps)
+    q_switches = np.linspace(q_switch_start, q_switch_end, max_steps)
+
+    # Initial evaluation
+    initial_solver_params = (q_init_ufs[0], q_final_ufs[0], q_switches[0])
+    current_radii = compute_max_radii(current_centers, iterations=q_iters[0], update_factor=initial_solver_params)
+    current_sum_radii = np.sum(current_radii)
+    best_sum_radii = current_sum_radii
+
+    T = T_initial
+
+    # 4. Main Langevin SA Loop
+    for step in range(max_steps):
+        # Anneal parameters based on temperature
+        anneal_factor = (T / T_initial)
+        step_sz = step_size_initial * anneal_factor**0.5
+        noise_magnitude = noise_initial * anneal_factor**0.5 # Aligned with 2.61 ancestor's scaling
+
+        # Get scheduled parameters for this step
+        sensitivity = sensitivities[step]
+        max_f = max_forces[step]
+        solver_params = (q_init_ufs[step], q_final_ufs[step], q_switches[step])
+        q_iter = q_iters[step]
+
+        # Propose a new state using Langevin dynamics
+        forces = _compute_forces(current_centers, current_radii, sensitivity, max_f)
+        noise = np.random.randn(n, 2) * noise_magnitude
+        move_vector = step_sz * forces + noise
+
+        candidate_centers = current_centers + move_vector
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+
+        # Evaluate the new state
+        candidate_radii = compute_max_radii(candidate_centers, iterations=q_iter, update_factor=solver_params)
+        candidate_sum_radii = np.sum(candidate_radii)
+
+        # Metropolis-Hastings acceptance criterion (objective is to MAXIMIZE sum of radii)
+        delta_sum = candidate_sum_radii - current_sum_radii
+        if delta_sum > 0 or (T > 1e-12 and np.random.rand() < np.exp(delta_sum / T)):
+            current_centers = candidate_centers
+            current_sum_radii = candidate_sum_radii
+            current_radii = candidate_radii
+
+        # Update the best-ever found solution
+        if current_sum_radii > best_sum_radii:
+            best_sum_radii = current_sum_radii
+            best_centers = np.copy(current_centers)
+
+        # Cool down
+        T *= alpha
+
+    # 5. Enhanced Final Polish (from high-performing parent, adjusted to 2.61 ancestor)
+    final_radii = compute_max_radii(best_centers, iterations=35000, update_factor=(0.7, 0.3, 0.4))
+
+    return best_centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an adaptive damping schedule for the update factor.
+    """
+    n = centers.shape[0]
+    radii = np.full(n, 1e-6)
+
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    if isinstance(update_factor, (float, int)):
+        initial_uf, final_uf, switch_ratio = float(update_factor), float(update_factor), 0.0
+    else:
+        initial_uf, final_uf, switch_ratio = update_factor
+
+    for k in range(iterations):
+        radii_old = np.copy(radii)
+
+        current_uf = initial_uf
+        if switch_ratio > 0 and k < iterations * switch_ratio:
+            progress = k / (iterations * switch_ratio)
+            current_uf = initial_uf + (final_uf - initial_uf) * progress
+        elif switch_ratio > 0:
+            current_uf = final_uf
+
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+        new_r = np.maximum(0.0, potential_r)
+
+        radii = radii_old + current_uf * (new_r - radii_old)
+
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/best/original.py

@@ -0,0 +1,203 @@
+# EVOLVE-BLOCK-START
+"""
+Implements a long-run, highly adaptive Langevin-dynamics-inspired Simulated
+Annealing (SA) algorithm for the circle packing problem. This hybrid version
+combines the long search of one parent with the proven parameter set of a
+higher-performing parent to achieve a superior result.
+"""
+
+import numpy as np
+
+def _compute_forces(centers, radii, sensitivity, max_force):
+    """Calculates repulsion forces based on gaps between circles and walls."""
+    n = centers.shape[0]
+    force_vectors = np.zeros_like(centers)
+
+    # Inter-circle forces
+    pdiff = centers[:, np.newaxis, :] - centers[np.newaxis, :, :]
+    pdist = np.sqrt(np.sum(pdiff**2, axis=-1))
+    np.fill_diagonal(pdist, np.inf)
+
+    radii_sum = radii[:, np.newaxis] + radii[np.newaxis, :]
+    gaps = pdist - radii_sum
+    force_magnitudes = np.exp(-sensitivity * gaps)
+
+    # Add a small epsilon to avoid division by zero
+    direction_vectors = pdiff / (pdist[..., np.newaxis] + 1e-12)
+    force_vectors += np.sum(force_magnitudes[..., np.newaxis] * direction_vectors, axis=1)
+
+    # Wall forces
+    gaps_walls = np.array([centers[:, 0] - radii, (1 - centers[:, 0]) - radii, centers[:, 1] - radii, (1 - centers[:, 1]) - radii]).T
+    force_magnitudes_walls = np.exp(-sensitivity * gaps_walls)
+    force_vectors[:, 0] += force_magnitudes_walls[:, 0]
+    force_vectors[:, 0] -= force_magnitudes_walls[:, 1]
+    force_vectors[:, 1] += force_magnitudes_walls[:, 2]
+    force_vectors[:, 1] -= force_magnitudes_walls[:, 3]
+
+    # Cap forces for stability
+    norms = np.linalg.norm(force_vectors, axis=1)
+    large_force_mask = norms > max_force
+    if np.any(large_force_mask):
+        force_vectors[large_force_mask] *= (max_force / (norms[large_force_mask, np.newaxis] + 1e-12))
+
+    return force_vectors
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles using a hybrid
+    Langevin-dynamics-inspired Simulated Annealing (SA) algorithm.
+    """
+    n = 26
+
+    # 1. Initial State: Proven 5x5 grid with two-stage perturbation.
+    centers = np.zeros((n, 2))
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+    centers[25] = [0.39, 0.41] # Key asymmetric perturbation
+
+    # Add a small random perturbation to break any remaining symmetries
+    perturbation_scale = 0.005
+    centers += np.random.uniform(-perturbation_scale, perturbation_scale, centers.shape)
+    centers = np.clip(centers, 0.01, 0.99)
+
+    # 2. Algorithm Parameters: Hybrid of long-run and proven parameters
+    max_steps = 150000
+    T_initial = 0.005
+    T_final = 1e-10  # Lower final temperature for the long run
+    alpha = (T_final / T_initial)**(1.0 / max_steps)
+
+    # Langevin Dynamics Parameters (from high-performing parent)
+    step_size_initial = 1.8e-3
+    noise_initial = 4.5e-3
+
+    # Force Calculation Parameter Schedules (from high-performing parent)
+    sensitivity_start = 180.0
+    sensitivity_end = 250.0
+    max_force_start = 75.0
+    max_force_end = 40.0
+
+    # Radius Solver Parameter Schedules (long-run base with proven tweaks)
+    q_iter_start, q_iter_end = 120, 500
+    q_init_uf_start, q_init_uf_end = 0.85, 0.6
+    q_final_uf_start, q_final_uf_end = 0.65, 0.4
+    q_switch_start, q_switch_end = 0.25, 0.5 # From high-performing parent
+
+    # 3. Initialization of State Variables and Schedules
+    current_centers = np.copy(centers)
+    best_centers = np.copy(centers)
+
+    # Pre-generate schedules for efficiency inside the loop
+    sensitivities = np.linspace(sensitivity_start, sensitivity_end, max_steps)
+    max_forces = np.linspace(max_force_start, max_force_end, max_steps)
+    q_iters = np.linspace(q_iter_start, q_iter_end, max_steps, dtype=int)
+    q_init_ufs = np.linspace(q_init_uf_start, q_init_uf_end, max_steps)
+    q_final_ufs = np.linspace(q_final_uf_start, q_final_uf_end, max_steps)
+    q_switches = np.linspace(q_switch_start, q_switch_end, max_steps)
+
+    # Initial evaluation
+    initial_solver_params = (q_init_ufs[0], q_final_ufs[0], q_switches[0])
+    current_radii = compute_max_radii(current_centers, iterations=q_iters[0], update_factor=initial_solver_params)
+    current_sum_radii = np.sum(current_radii)
+    best_sum_radii = current_sum_radii
+
+    T = T_initial
+
+    # 4. Main Langevin SA Loop
+    for step in range(max_steps):
+        # Anneal parameters based on temperature
+        anneal_factor = (T / T_initial)
+        step_sz = step_size_initial * anneal_factor**0.5
+        noise_magnitude = noise_initial * anneal_factor
+
+        # Get scheduled parameters for this step
+        sensitivity = sensitivities[step]
+        max_f = max_forces[step]
+        solver_params = (q_init_ufs[step], q_final_ufs[step], q_switches[step])
+        q_iter = q_iters[step]
+
+        # Propose a new state using Langevin dynamics
+        forces = _compute_forces(current_centers, current_radii, sensitivity, max_f)
+        noise = np.random.randn(n, 2) * noise_magnitude
+        move_vector = step_sz * forces + noise
+
+        candidate_centers = current_centers + move_vector
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+
+        # Evaluate the new state
+        candidate_radii = compute_max_radii(candidate_centers, iterations=q_iter, update_factor=solver_params)
+        candidate_sum_radii = np.sum(candidate_radii)
+
+        # Metropolis-Hastings acceptance criterion (objective is to MAXIMIZE sum of radii)
+        delta_sum = candidate_sum_radii - current_sum_radii
+        if delta_sum > 0 or (T > 1e-12 and np.random.rand() < np.exp(delta_sum / T)):
+            current_centers = candidate_centers
+            current_sum_radii = candidate_sum_radii
+            current_radii = candidate_radii
+
+        # Update the best-ever found solution
+        if current_sum_radii > best_sum_radii:
+            best_sum_radii = current_sum_radii
+            best_centers = np.copy(current_centers)
+
+        # Cool down
+        T *= alpha
+
+    # 5. Enhanced Final Polish (from high-performing parent)
+    final_radii = compute_max_radii(best_centers, iterations=35000, update_factor=(0.7, 0.2, 0.5))
+
+    return best_centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an adaptive damping schedule for the update factor.
+    """
+    n = centers.shape[0]
+    radii = np.full(n, 1e-6)
+
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    if isinstance(update_factor, (float, int)):
+        initial_uf, final_uf, switch_ratio = float(update_factor), float(update_factor), 0.0
+    else:
+        initial_uf, final_uf, switch_ratio = update_factor
+
+    for k in range(iterations):
+        radii_old = np.copy(radii)
+
+        current_uf = initial_uf
+        if switch_ratio > 0 and k < iterations * switch_ratio:
+            progress = k / (iterations * switch_ratio)
+            current_uf = initial_uf + (final_uf - initial_uf) * progress
+        elif switch_ratio > 0:
+            current_uf = final_uf
+
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+        new_r = np.maximum(0.0, potential_r)
+
+        radii = radii_old + current_uf * (new_r - radii_old)
+
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/best/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/best/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 2.6094239779362547,
+  "correct": true,
+  "primary": {
+    "combined_score": 2.6094239779362547,
+    "public": {
+      "centers_str": "  centers[0] = (0.1147, 0.1147)\n  centers[1] = (0.0675, 0.2907)\n  centers[2] = (0.0957, 0.4517)\n  centers[3] = (0.1064, 0.6536)\n  centers[4] = (0.1208, 0.8798)\n  centers[5] = (0.3267, 0.0977)\n  centers[6] = (0.2560, 0.3052)\n  centers[7] = (0.2765, 0.5326)\n  centers[8] = (0.3055, 0.7418)\n  centers[9] = (0.3134, 0.9254)\n  centers[10] = (0.4838, 0.0628)\n  centers[11] = (0.4842, 0.2406)\n  centers[12] = (0.5673, 0.4119)\n  centers[13] = (0.5011, 0.6054)\n  centers[14] = (0.5143, 0.8672)\n  centers[15] = (0.6418, 0.0966)\n  centers[16] = (0.6983, 0.2892)\n  centers[17] = (0.7229, 0.4907)\n  centers[18] = (0.7347, 0.7201)\n  centers[19] = (0.7164, 0.9251)\n  centers[20] = (0.8700, 0.1299)\n  centers[21] = (0.8942, 0.3643)\n  centers[22] = (0.9033, 0.5665)\n  centers[23] = (0.9329, 0.7276)\n  centers[24] = (0.8949, 0.8952)\n  centers[25] = (0.4168, 0.4187)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 2.6094239779362547
+    },
+    "execution_time_mean": 645.0352613227442,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770418650.434517,
+  "generation": 194
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/best/search_replace.txt

@@ -0,0 +1,91 @@
+<NAME>
+align_langevin_params_fix
+</NAME>
+
+<DESCRIPTION>
+This is a corrected attempt to align the Langevin dynamics and final polish parameters with a higher-performing ancestor. The previous attempt failed due to an indentation mismatch in the `SEARCH` block.
+
+This edit precisely applies the following changes:
+
+1.  **Noise Magnitude Scaling:** Adjusts `noise_magnitude` to scale with `anneal_factor**0.5` instead of `anneal_factor`. This matches the successful scaling behavior observed in a higher-performing ancestor (score 2.61), providing a more balanced exploration/exploitation.
+2.  **Force Calculation & Radius Solver Parameters:** Updates `sensitivity_end`, `max_force_end`, and `q_iter_end` to tune the annealing process. `sensitivity_end` is increased for sharper forces at the end, `max_force_end` is reduced for finer control, and `q_iter_end` is slightly reduced to balance performance with the increased `max_steps`. These values are derived from successful ancestors.
+3.  **Final Polish Parameters:** Changes the `update_factor` for the final high-precision polish to `(0.7, 0.3, 0.4)`. This specific tuple for the update factor in `_compute_max_radii` was part of a robust final polish in a high-scoring prior program, and is expected to provide better local optimization.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+        # Anneal parameters based on temperature
+        anneal_factor = (T / T_initial)
+        step_sz = step_size_initial * anneal_factor**0.5
+        noise_magnitude = noise_initial * anneal_factor
+
+        # Get scheduled parameters for this step
+        sensitivity = sensitivities[step]
+        max_f = max_forces[step]
+        solver_params = (q_init_ufs[step], q_final_ufs[step], q_switches[step])
+        q_iter = q_iters[step]
+
+        # Propose a new state using Langevin dynamics
+        forces = _compute_forces(current_centers, current_radii, sensitivity, max_f)
+        noise = np.random.randn(n, 2) * noise_magnitude
+        move_vector = step_sz * forces + noise
+
+        candidate_centers = current_centers + move_vector
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+=======
+        # Anneal parameters based on temperature
+        anneal_factor = (T / T_initial)
+        step_sz = step_size_initial * anneal_factor**0.5
+        noise_magnitude = noise_initial * anneal_factor**0.5 # Aligned with 2.61 ancestor's scaling
+
+        # Get scheduled parameters for this step
+        sensitivity = sensitivities[step]
+        max_f = max_forces[step]
+        solver_params = (q_init_ufs[step], q_final_ufs[step], q_switches[step])
+        q_iter = q_iters[step]
+
+        # Propose a new state using Langevin dynamics
+        forces = _compute_forces(current_centers, current_radii, sensitivity, max_f)
+        noise = np.random.randn(n, 2) * noise_magnitude
+        move_vector = step_sz * forces + noise
+
+        candidate_centers = current_centers + move_vector
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+>>>>>>> REPLACE
+</DIFF>
+
+<DIFF>
+<<<<<<< SEARCH
+    sensitivity_start = 180.0
+    sensitivity_end = 250.0
+    max_force_start = 75.0
+    max_force_end = 40.0
+
+    # Radius Solver Parameter Schedules (long-run base with proven tweaks)
+    q_iter_start, q_iter_end = 120, 500
+    q_init_uf_start, q_init_uf_end = 0.85, 0.6
+    q_final_uf_start, q_final_uf_end = 0.65, 0.4
+    q_switch_start, q_switch_end = 0.25, 0.5 # From high-performing parent
+=======
+    sensitivity_start = 180.0
+    sensitivity_end = 350.0 # Increased for sharper forces at end, closer to 2.61 ancestor (380.0)
+    max_force_start = 75.0
+    max_force_end = 30.0    # Reduced for finer control at end, closer to 2.61 ancestor (25.0)
+
+    # Radius Solver Parameter Schedules (long-run base with proven tweaks)
+    q_iter_start, q_iter_end = 120, 400 # Aligned with 2.61 ancestor
+    q_init_uf_start, q_init_uf_end = 0.85, 0.6
+    q_final_uf_start, q_final_uf_end = 0.65, 0.4
+    q_switch_start, q_switch_end = 0.25, 0.5 # From high-performing parent
+>>>>>>> REPLACE
+</DIFF>
+
+<DIFF>
+<<<<<<< SEARCH
+    # 5. Enhanced Final Polish (from high-performing parent)
+    final_radii = compute_max_radii(best_centers, iterations=35000, update_factor=(0.7, 0.2, 0.5))
+=======
+    # 5. Enhanced Final Polish (from high-performing parent, adjusted to 2.61 ancestor)
+    final_radii = compute_max_radii(best_centers, iterations=35000, update_factor=(0.7, 0.3, 0.4))
+>>>>>>> REPLACE
+</DIFF>

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/job_log.err

@@ -0,0 +1,9 @@
+/home/tengxiao/pj/ShinkaEvolve/.venv/lib/python3.13/site-packages/instructor/providers/gemini/client.py:5: FutureWarning: 
+
+All support for the `google.generativeai` package has ended. It will no longer be receiving 
+updates or bug fixes. Please switch to the `google.genai` package as soon as possible.
+See README for more details:
+
+https://github.com/google-gemini/deprecated-generative-ai-python/blob/main/README.md
+
+  import google.generativeai as genai  # type: ignore[import-not-found]

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/job_log.out

@@ -0,0 +1,16 @@
+Evaluating program: examples/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/main.py
+Saving results to: examples/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results
+Run 1/1 completed in 0.00 seconds
+Detailed packing data saved to examples/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/extra.npz
+Correctness and error status saved to examples/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/correct.json
+Metrics saved to examples/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/metrics.json
+Evaluation and Validation completed successfully.
+Metrics:
+  combined_score: 0.9597642169962064
+  public: {'centers_str': '  centers[0] = (0.5000, 0.5000)\n  centers[1] = (0.8000, 0.5000)\n  centers[2] = (0.7121, 0.7121)\n  centers[3] = (0.5000, 0.8000)\n  centers[4] = (0.2879, 0.7121)\n  centers[5] = (0.2000, 0.5000)\n  centers[6] = (0.2879, 0.2879)\n  centers[7] = (0.5000, 0.2000)\n  centers[8] = (0.7121, 0.2879)\n  centers[9] = (0.9900, 0.5000)\n  centers[10] = (0.9900, 0.7679)\n  centers[11] = (0.9900, 0.9900)\n  centers[12] = (0.7679, 0.9900)\n  centers[13] = (0.5000, 0.9900)\n  centers[14] = (0.2321, 0.9900)\n  centers[15] = (0.0100, 0.9900)\n  centers[16] = (0.0100, 0.7679)\n  centers[17] = (0.0100, 0.5000)\n  centers[18] = (0.0100, 0.2321)\n  centers[19] = (0.0100, 0.0100)\n  centers[20] = (0.2321, 0.0100)\n  centers[21] = (0.5000, 0.0100)\n  centers[22] = (0.7679, 0.0100)\n  centers[23] = (0.9900, 0.0100)\n  centers[24] = (0.9900, 0.2321)\n  centers[25] = (0.0100, 0.0100)', 'num_circles': 26}
+  private: {'reported_sum_of_radii': 0.9597642169962064}
+  execution_time_mean: 0.0021205758675932884
+  execution_time_std: 0.0
+  num_valid_runs: 1
+  num_invalid_runs: 0
+  all_validation_errors: []

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_0/results/metrics.json

@@ -0,0 +1,15 @@
+{
+    "combined_score": 0.9597642169962064,
+    "public": {
+        "centers_str": "  centers[0] = (0.5000, 0.5000)\n  centers[1] = (0.8000, 0.5000)\n  centers[2] = (0.7121, 0.7121)\n  centers[3] = (0.5000, 0.8000)\n  centers[4] = (0.2879, 0.7121)\n  centers[5] = (0.2000, 0.5000)\n  centers[6] = (0.2879, 0.2879)\n  centers[7] = (0.5000, 0.2000)\n  centers[8] = (0.7121, 0.2879)\n  centers[9] = (0.9900, 0.5000)\n  centers[10] = (0.9900, 0.7679)\n  centers[11] = (0.9900, 0.9900)\n  centers[12] = (0.7679, 0.9900)\n  centers[13] = (0.5000, 0.9900)\n  centers[14] = (0.2321, 0.9900)\n  centers[15] = (0.0100, 0.9900)\n  centers[16] = (0.0100, 0.7679)\n  centers[17] = (0.0100, 0.5000)\n  centers[18] = (0.0100, 0.2321)\n  centers[19] = (0.0100, 0.0100)\n  centers[20] = (0.2321, 0.0100)\n  centers[21] = (0.5000, 0.0100)\n  centers[22] = (0.7679, 0.0100)\n  centers[23] = (0.9900, 0.0100)\n  centers[24] = (0.9900, 0.2321)\n  centers[25] = (0.0100, 0.0100)",
+        "num_circles": 26
+    },
+    "private": {
+        "reported_sum_of_radii": 0.9597642169962064
+    },
+    "execution_time_mean": 0.0021205758675932884,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": []
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_1/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_1/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 1.9200929312704162,
+  "correct": true,
+  "primary": {
+    "combined_score": 1.9200929312704162,
+    "public": {
+      "centers_str": "  centers[0] = (0.1000, 0.1000)\n  centers[1] = (0.1000, 0.3000)\n  centers[2] = (0.1000, 0.5000)\n  centers[3] = (0.1000, 0.7000)\n  centers[4] = (0.1000, 0.9000)\n  centers[5] = (0.3000, 0.1000)\n  centers[6] = (0.3000, 0.3000)\n  centers[7] = (0.3000, 0.5000)\n  centers[8] = (0.3000, 0.7000)\n  centers[9] = (0.3000, 0.9000)\n  centers[10] = (0.5000, 0.1000)\n  centers[11] = (0.5000, 0.3000)\n  centers[12] = (0.5000, 0.5000)\n  centers[13] = (0.5000, 0.7000)\n  centers[14] = (0.5000, 0.9000)\n  centers[15] = (0.7000, 0.1000)\n  centers[16] = (0.7000, 0.3000)\n  centers[17] = (0.7000, 0.5000)\n  centers[18] = (0.7000, 0.7000)\n  centers[19] = (0.7000, 0.9000)\n  centers[20] = (0.9000, 0.1000)\n  centers[21] = (0.9000, 0.3000)\n  centers[22] = (0.9000, 0.5000)\n  centers[23] = (0.9000, 0.7000)\n  centers[24] = (0.9000, 0.9000)\n  centers[25] = (0.4000, 0.4000)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 1.9200929312704162
+    },
+    "execution_time_mean": 0.002143661491572857,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770396777.592588,
+  "generation": 1
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_10/edit.diff

@@ -0,0 +1,137 @@
+--- a/original.py
++++ b/original.py
+@@ -1,122 +1,129 @@
+ # EVOLVE-BLOCK-START
+ """Constructor-based circle packing for n=26 circles combining 5x5 grid layout
+ with iterative radius relaxation solver."""
+ 
+ import numpy as np
+ 
+ 
+ def construct_packing():
+     """
+     Constructs an arrangement of 26 circles in a unit square based on a
+     5x5 grid pattern plus one extra circle, using an iterative radius
+     relaxation solver to maximize the sum of their radii.
+ 
+     Returns:
+         Tuple of (centers, radii)
+         centers: np.array of shape (26, 2) with (x, y) coordinates
+         radii: np.array of shape (26) with the radius of each circle
+     """
+     n = 26
+     centers = np.zeros((n, 2))
+ 
+     # Place 25 circles in a 5x5 grid pattern.
+     # Centers are spaced such that they can initially have radius 0.1 each,
+     # fitting perfectly within the unit square if they all had r=0.1.
+     x_coords = np.linspace(0.1, 0.9, 5) # [0.1, 0.3, 0.5, 0.7, 0.9]
+     y_coords = np.linspace(0.1, 0.9, 5) # [0.1, 0.3, 0.5, 0.7, 0.9]
+ 
+     idx = 0
++    # Place 24 circles from the 5x5 grid, skipping the center point
+     for i in range(5):
+         for j in range(5):
++            # Use np.isclose for robust float comparison of the center point
++            if np.isclose(x_coords[i], 0.5) and np.isclose(y_coords[j], 0.5):
++                continue
+             centers[idx] = [x_coords[i], y_coords[j]]
+             idx += 1
+ 
+-    # Place the 26th circle in a different "hole" of the grid.
+-    # Instead of (0.4, 0.4), place it centrally along one of the vertical lines
+-    # of the grid, e.g., between (0.5, 0.1) and (0.5, 0.3). This might allow
+-    # for a larger radius for the 26th circle or better overall distribution.
+-    centers[idx] = [0.5, 0.2] # idx will be 25 here, for the 26th circle
++    # Place two circles symmetrically in the central hole created. This hole
++    # is larger than the standard grid holes. The original grid points
++    # at (0.3, 0.5) and (0.7, 0.5) are 0.4 apart. We place two circles
++    # in between. Placing them at 0.45 and 0.55 balances the space.
++    delta = 0.05
++    centers[idx] = [0.5 - delta, 0.5] # idx is 24
++    idx += 1
++    centers[idx] = [0.5 + delta, 0.5] # idx is 25
+ 
+     # Compute maximum valid radii for this configuration using the iterative solver.
+     radii = compute_max_radii(centers, iterations=200)
+     return centers, radii
+ 
+ 
+ def compute_max_radii(centers, iterations=200):
+     """
+     Computes maximum radii using an iterative relaxation method.
+     This method is robust for resolving overlaps and maintaining boundary constraints.
+ 
+     Args:
+         centers: np.array of shape (n, 2) with (x, y) coordinates
+         iterations: The number of relaxation iterations to perform.
+ 
+     Returns:
+         np.array of shape (n) with the radius of each circle
+     """
+     n = centers.shape[0]
+     radii = np.zeros(n)
+ 
+     # 1. Initialize radii based on wall distances
+     for i in range(n):
+         x, y = centers[i]
+         radii[i] = min(x, 1 - x, y, 1 - y)
+ 
+     # 2. Iteratively resolve overlaps
+     for _ in range(iterations):
+         max_change = 0.0
+         # Check for overlaps between pairs of circles
+         for i in range(n):
+             for j in range(i + 1, n):
+                 dist = np.linalg.norm(centers[i] - centers[j])
+ 
+                 # Handle extremely close or coincident centers gracefully
+                 if dist < 1e-9:
+                     radii[i] = 0.0
+                     radii[j] = 0.0
+                     max_change = float('inf') # Indicate a significant change occurred
+                     continue
+ 
+                 overlap = radii[i] + radii[j] - dist
+                 if overlap > 0:
+                     # Resolve overlap by shrinking radii proportionally to their current size.
+                     total_radii_sum = radii[i] + radii[j]
+ 
+                     # Handle case where total_radii_sum is near zero to avoid division by zero
+                     if total_radii_sum < 1e-9:
+                         radii[i] = 0.0
+                         radii[j] = 0.0
+                         continue
+ 
+                     reduction_i = overlap * (radii[i] / total_radii_sum)
+                     reduction_j = overlap * (radii[j] / total_radii_sum)
+ 
+                     radii[i] -= reduction_i
+                     radii[j] -= reduction_j
+                     max_change = max(max_change, reduction_i, reduction_j)
+ 
+         # Enforce wall constraints after each pass.
+         # This is important as shrinking due to overlaps might allow expansion towards walls.
+         for i in range(n):
+             x, y = centers[i]
+             wall_rad = min(x, 1 - x, y, 1 - y)
+             if radii[i] > wall_rad:
+                 change = radii[i] - wall_rad
+                 radii[i] = wall_rad
+                 max_change = max(max_change, change)
+ 
+         # If radii have stabilized (change is very small), we can exit early.
+         if max_change < 1e-7:
+             break
+ 
+     return radii
+ # EVOLVE-BLOCK-END
+ 
+ 
+ # This part remains fixed (not evolved)
+ def run_packing():
+     """Run the circle packing constructor for n=26"""
+     centers, radii = construct_packing()
+     # Calculate the sum of radii
+     sum_radii = np.sum(radii)
+     return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_10/main.py

@@ -0,0 +1,129 @@
+# EVOLVE-BLOCK-START
+"""Constructor-based circle packing for n=26 circles combining 5x5 grid layout
+with iterative radius relaxation solver."""
+
+import numpy as np
+
+
+def construct_packing():
+    """
+    Constructs an arrangement of 26 circles in a unit square based on a
+    5x5 grid pattern plus one extra circle, using an iterative radius
+    relaxation solver to maximize the sum of their radii.
+
+    Returns:
+        Tuple of (centers, radii)
+        centers: np.array of shape (26, 2) with (x, y) coordinates
+        radii: np.array of shape (26) with the radius of each circle
+    """
+    n = 26
+    centers = np.zeros((n, 2))
+
+    # Place 25 circles in a 5x5 grid pattern.
+    # Centers are spaced such that they can initially have radius 0.1 each,
+    # fitting perfectly within the unit square if they all had r=0.1.
+    x_coords = np.linspace(0.1, 0.9, 5) # [0.1, 0.3, 0.5, 0.7, 0.9]
+    y_coords = np.linspace(0.1, 0.9, 5) # [0.1, 0.3, 0.5, 0.7, 0.9]
+
+    idx = 0
+    # Place 24 circles from the 5x5 grid, skipping the center point
+    for i in range(5):
+        for j in range(5):
+            # Use np.isclose for robust float comparison of the center point
+            if np.isclose(x_coords[i], 0.5) and np.isclose(y_coords[j], 0.5):
+                continue
+            centers[idx] = [x_coords[i], y_coords[j]]
+            idx += 1
+
+    # Place two circles symmetrically in the central hole created. This hole
+    # is larger than the standard grid holes. The original grid points
+    # at (0.3, 0.5) and (0.7, 0.5) are 0.4 apart. We place two circles
+    # in between. Placing them at 0.45 and 0.55 balances the space.
+    delta = 0.05
+    centers[idx] = [0.5 - delta, 0.5] # idx is 24
+    idx += 1
+    centers[idx] = [0.5 + delta, 0.5] # idx is 25
+
+    # Compute maximum valid radii for this configuration using the iterative solver.
+    radii = compute_max_radii(centers, iterations=200)
+    return centers, radii
+
+
+def compute_max_radii(centers, iterations=200):
+    """
+    Computes maximum radii using an iterative relaxation method.
+    This method is robust for resolving overlaps and maintaining boundary constraints.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates
+        iterations: The number of relaxation iterations to perform.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle
+    """
+    n = centers.shape[0]
+    radii = np.zeros(n)
+
+    # 1. Initialize radii based on wall distances
+    for i in range(n):
+        x, y = centers[i]
+        radii[i] = min(x, 1 - x, y, 1 - y)
+
+    # 2. Iteratively resolve overlaps
+    for _ in range(iterations):
+        max_change = 0.0
+        # Check for overlaps between pairs of circles
+        for i in range(n):
+            for j in range(i + 1, n):
+                dist = np.linalg.norm(centers[i] - centers[j])
+
+                # Handle extremely close or coincident centers gracefully
+                if dist < 1e-9:
+                    radii[i] = 0.0
+                    radii[j] = 0.0
+                    max_change = float('inf') # Indicate a significant change occurred
+                    continue
+
+                overlap = radii[i] + radii[j] - dist
+                if overlap > 0:
+                    # Resolve overlap by shrinking radii proportionally to their current size.
+                    total_radii_sum = radii[i] + radii[j]
+
+                    # Handle case where total_radii_sum is near zero to avoid division by zero
+                    if total_radii_sum < 1e-9:
+                        radii[i] = 0.0
+                        radii[j] = 0.0
+                        continue
+
+                    reduction_i = overlap * (radii[i] / total_radii_sum)
+                    reduction_j = overlap * (radii[j] / total_radii_sum)
+
+                    radii[i] -= reduction_i
+                    radii[j] -= reduction_j
+                    max_change = max(max_change, reduction_i, reduction_j)
+
+        # Enforce wall constraints after each pass.
+        # This is important as shrinking due to overlaps might allow expansion towards walls.
+        for i in range(n):
+            x, y = centers[i]
+            wall_rad = min(x, 1 - x, y, 1 - y)
+            if radii[i] > wall_rad:
+                change = radii[i] - wall_rad
+                radii[i] = wall_rad
+                max_change = max(max_change, change)
+
+        # If radii have stabilized (change is very small), we can exit early.
+        if max_change < 1e-7:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_10/original.py

@@ -0,0 +1,122 @@
+# EVOLVE-BLOCK-START
+"""Constructor-based circle packing for n=26 circles combining 5x5 grid layout
+with iterative radius relaxation solver."""
+
+import numpy as np
+
+
+def construct_packing():
+    """
+    Constructs an arrangement of 26 circles in a unit square based on a
+    5x5 grid pattern plus one extra circle, using an iterative radius
+    relaxation solver to maximize the sum of their radii.
+
+    Returns:
+        Tuple of (centers, radii)
+        centers: np.array of shape (26, 2) with (x, y) coordinates
+        radii: np.array of shape (26) with the radius of each circle
+    """
+    n = 26
+    centers = np.zeros((n, 2))
+
+    # Place 25 circles in a 5x5 grid pattern.
+    # Centers are spaced such that they can initially have radius 0.1 each,
+    # fitting perfectly within the unit square if they all had r=0.1.
+    x_coords = np.linspace(0.1, 0.9, 5) # [0.1, 0.3, 0.5, 0.7, 0.9]
+    y_coords = np.linspace(0.1, 0.9, 5) # [0.1, 0.3, 0.5, 0.7, 0.9]
+
+    idx = 0
+    for i in range(5):
+        for j in range(5):
+            centers[idx] = [x_coords[i], y_coords[j]]
+            idx += 1
+
+    # Place the 26th circle in a different "hole" of the grid.
+    # Instead of (0.4, 0.4), place it centrally along one of the vertical lines
+    # of the grid, e.g., between (0.5, 0.1) and (0.5, 0.3). This might allow
+    # for a larger radius for the 26th circle or better overall distribution.
+    centers[idx] = [0.5, 0.2] # idx will be 25 here, for the 26th circle
+
+    # Compute maximum valid radii for this configuration using the iterative solver.
+    radii = compute_max_radii(centers, iterations=200)
+    return centers, radii
+
+
+def compute_max_radii(centers, iterations=200):
+    """
+    Computes maximum radii using an iterative relaxation method.
+    This method is robust for resolving overlaps and maintaining boundary constraints.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates
+        iterations: The number of relaxation iterations to perform.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle
+    """
+    n = centers.shape[0]
+    radii = np.zeros(n)
+
+    # 1. Initialize radii based on wall distances
+    for i in range(n):
+        x, y = centers[i]
+        radii[i] = min(x, 1 - x, y, 1 - y)
+
+    # 2. Iteratively resolve overlaps
+    for _ in range(iterations):
+        max_change = 0.0
+        # Check for overlaps between pairs of circles
+        for i in range(n):
+            for j in range(i + 1, n):
+                dist = np.linalg.norm(centers[i] - centers[j])
+
+                # Handle extremely close or coincident centers gracefully
+                if dist < 1e-9:
+                    radii[i] = 0.0
+                    radii[j] = 0.0
+                    max_change = float('inf') # Indicate a significant change occurred
+                    continue
+
+                overlap = radii[i] + radii[j] - dist
+                if overlap > 0:
+                    # Resolve overlap by shrinking radii proportionally to their current size.
+                    total_radii_sum = radii[i] + radii[j]
+
+                    # Handle case where total_radii_sum is near zero to avoid division by zero
+                    if total_radii_sum < 1e-9:
+                        radii[i] = 0.0
+                        radii[j] = 0.0
+                        continue
+
+                    reduction_i = overlap * (radii[i] / total_radii_sum)
+                    reduction_j = overlap * (radii[j] / total_radii_sum)
+
+                    radii[i] -= reduction_i
+                    radii[j] -= reduction_j
+                    max_change = max(max_change, reduction_i, reduction_j)
+
+        # Enforce wall constraints after each pass.
+        # This is important as shrinking due to overlaps might allow expansion towards walls.
+        for i in range(n):
+            x, y = centers[i]
+            wall_rad = min(x, 1 - x, y, 1 - y)
+            if radii[i] > wall_rad:
+                change = radii[i] - wall_rad
+                radii[i] = wall_rad
+                max_change = max(max_change, change)
+
+        # If radii have stabilized (change is very small), we can exit early.
+        if max_change < 1e-7:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_10/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_10/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 1.826354003799491,
+  "correct": true,
+  "primary": {
+    "combined_score": 1.826354003799491,
+    "public": {
+      "centers_str": "  centers[0] = (0.1000, 0.1000)\n  centers[1] = (0.1000, 0.3000)\n  centers[2] = (0.1000, 0.5000)\n  centers[3] = (0.1000, 0.7000)\n  centers[4] = (0.1000, 0.9000)\n  centers[5] = (0.3000, 0.1000)\n  centers[6] = (0.3000, 0.3000)\n  centers[7] = (0.3000, 0.5000)\n  centers[8] = (0.3000, 0.7000)\n  centers[9] = (0.3000, 0.9000)\n  centers[10] = (0.5000, 0.1000)\n  centers[11] = (0.5000, 0.3000)\n  centers[12] = (0.5000, 0.7000)\n  centers[13] = (0.5000, 0.9000)\n  centers[14] = (0.7000, 0.1000)\n  centers[15] = (0.7000, 0.3000)\n  centers[16] = (0.7000, 0.5000)\n  centers[17] = (0.7000, 0.7000)\n  centers[18] = (0.7000, 0.9000)\n  centers[19] = (0.9000, 0.1000)\n  centers[20] = (0.9000, 0.3000)\n  centers[21] = (0.9000, 0.5000)\n  centers[22] = (0.9000, 0.7000)\n  centers[23] = (0.9000, 0.9000)\n  centers[24] = (0.4500, 0.5000)\n  centers[25] = (0.5500, 0.5000)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 1.826354003799491
+    },
+    "execution_time_mean": 0.003152531571686268,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770397837.0687263,
+  "generation": 10
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_10/search_replace.txt

@@ -0,0 +1,50 @@
+<NAME>
+replace_center_with_dimer
+</NAME>
+
+<DESCRIPTION>
+The existing best-performing solutions are based on a 5x5 grid with an additional circle placed in one of the grid 'holes'. This suggests the grid structure is promising but needs modification for N=26. The current implementation scores lower (1.88) than the best-seen score (1.92) by placing the 26th circle in a suboptimal position.
+
+Instead of simply reverting to the previous best position `(0.4, 0.4)`, this edit proposes a more fundamental and geometrically-motivated change. I will modify the `construct_packing` function to create a known "defect" structure often seen in sphere packing, which might yield a better overall sum of radii.
+
+The change is as follows:
+1.  The 5x5 grid is created, but the centermost circle at `(0.5, 0.5)` is omitted. This creates a larger central empty space (a 'vacancy') compared to the standard grid holes.
+2.  Into this larger vacancy, two circles are placed symmetrically instead of one. The horizontal space between grid points `(0.3, 0.5)` and `(0.7, 0.5)` is `0.4`. Placing two circles in this gap requires careful positioning. I've chosen to place them at `(0.45, 0.5)` and `(0.55, 0.5)`. This balances the distance between the two new circles (`0.1`) and their distance to the nearest grid neighbors (`0.15`).
+
+This "dimer-in-vacancy" approach breaks the perfect grid symmetry in a controlled way, which can lead to more efficient packing and is a common strategy for accommodating non-matching numbers in lattice-based packing. I also made the floating-point comparison more robust by using `np.isclose`.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+    idx = 0
+    for i in range(5):
+        for j in range(5):
+            centers[idx] = [x_coords[i], y_coords[j]]
+            idx += 1
+
+    # Place the 26th circle in a different "hole" of the grid.
+    # Instead of (0.4, 0.4), place it centrally along one of the vertical lines
+    # of the grid, e.g., between (0.5, 0.1) and (0.5, 0.3). This might allow
+    # for a larger radius for the 26th circle or better overall distribution.
+    centers[idx] = [0.5, 0.2] # idx will be 25 here, for the 26th circle
+=======
+    idx = 0
+    # Place 24 circles from the 5x5 grid, skipping the center point
+    for i in range(5):
+        for j in range(5):
+            # Use np.isclose for robust float comparison of the center point
+            if np.isclose(x_coords[i], 0.5) and np.isclose(y_coords[j], 0.5):
+                continue
+            centers[idx] = [x_coords[i], y_coords[j]]
+            idx += 1
+
+    # Place two circles symmetrically in the central hole created. This hole
+    # is larger than the standard grid holes. The original grid points
+    # at (0.3, 0.5) and (0.7, 0.5) are 0.4 apart. We place two circles
+    # in between. Placing them at 0.45 and 0.55 balances the space.
+    delta = 0.05
+    centers[idx] = [0.5 - delta, 0.5] # idx is 24
+    idx += 1
+    centers[idx] = [0.5 + delta, 0.5] # idx is 25
+>>>>>>> REPLACE
+</DIFF>

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_100/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_100/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 2.535779246674928,
+  "correct": true,
+  "primary": {
+    "combined_score": 2.535779246674928,
+    "public": {
+      "centers_str": "  centers[0] = (0.1097, 0.1087)\n  centers[1] = (0.0811, 0.2964)\n  centers[2] = (0.1174, 0.4812)\n  centers[3] = (0.1123, 0.7007)\n  centers[4] = (0.0939, 0.9061)\n  centers[5] = (0.2985, 0.0817)\n  centers[6] = (0.2546, 0.2550)\n  centers[7] = (0.2926, 0.5329)\n  centers[8] = (0.3008, 0.6849)\n  centers[9] = (0.3039, 0.8795)\n  centers[10] = (0.4734, 0.0936)\n  centers[11] = (0.5042, 0.2915)\n  centers[12] = (0.4926, 0.4887)\n  centers[13] = (0.4950, 0.6974)\n  centers[14] = (0.5125, 0.9072)\n  centers[15] = (0.6730, 0.1065)\n  centers[16] = (0.7122, 0.3116)\n  centers[17] = (0.6804, 0.5095)\n  centers[18] = (0.7152, 0.7072)\n  centers[19] = (0.7007, 0.9046)\n  centers[20] = (0.8853, 0.1058)\n  centers[21] = (0.9076, 0.3027)\n  centers[22] = (0.8889, 0.5047)\n  centers[23] = (0.9089, 0.7052)\n  centers[24] = (0.8980, 0.8980)\n  centers[25] = (0.3548, 0.3955)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 2.535779246674928
+    },
+    "execution_time_mean": 47.51581493206322,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770405446.6050518,
+  "generation": 100
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_101/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_101/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 2.5307582777428874,
+  "correct": true,
+  "primary": {
+    "combined_score": 2.5307582777428874,
+    "public": {
+      "centers_str": "  centers[0] = (0.1014, 0.1013)\n  centers[1] = (0.0949, 0.2973)\n  centers[2] = (0.1231, 0.5127)\n  centers[3] = (0.0859, 0.7176)\n  centers[4] = (0.0986, 0.9015)\n  centers[5] = (0.3038, 0.1011)\n  centers[6] = (0.2877, 0.2994)\n  centers[7] = (0.3098, 0.5117)\n  centers[8] = (0.2813, 0.6854)\n  centers[9] = (0.2989, 0.8982)\n  centers[10] = (0.5091, 0.1035)\n  centers[11] = (0.5086, 0.3027)\n  centers[12] = (0.5253, 0.5202)\n  centers[13] = (0.4924, 0.7186)\n  centers[14] = (0.4901, 0.9103)\n  centers[15] = (0.7160, 0.1018)\n  centers[16] = (0.6947, 0.2928)\n  centers[17] = (0.7090, 0.4733)\n  centers[18] = (0.7013, 0.6786)\n  centers[19] = (0.6833, 0.8959)\n  centers[20] = (0.9087, 0.0912)\n  centers[21] = (0.8924, 0.2890)\n  centers[22] = (0.8990, 0.4972)\n  centers[23] = (0.9058, 0.6923)\n  centers[24] = (0.8936, 0.8926)\n  centers[25] = (0.3978, 0.4182)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 2.5307582777428874
+    },
+    "execution_time_mean": 60.76680243201554,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770405497.4442744,
+  "generation": 101
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_102/edit.diff

@@ -0,0 +1,216 @@
+--- a/original.py
++++ b/original.py
+@@ -1,164 +1,202 @@
+ # EVOLVE-BLOCK-START
+ """Constructor-based circle packing for n=26 circles combining 5x5 grid layout
+ with iterative radius relaxation solver."""
+ 
+ import numpy as np
+ 
+ 
+ def construct_packing():
+     """
+     Constructs an optimized arrangement of 26 circles by starting with a strong
+     grid-based pattern and refining center positions using a coordinate ascent
+     method with a rich neighborhood and dynamic solver parameters.
+ 
+     Returns:
+         A tuple containing:
+         centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+         radii: np.array of shape (26) with the final radius of each circle
+     """
+     n = 26
+     centers = np.zeros((n, 2))
+ 
+     # 1. Initial Placement: Start with a 5x5 grid + central circle pattern.
+     # Adopt the optimized margin 'd' from a successful prior for a potentially better
+     # initial grid configuration. This value is known to be effective for dense packings.
+     d = 0.09525
+     grid_coords = np.linspace(d, 1 - d, 5)
+     idx = 0
+     for x in grid_coords:
+         for y in grid_coords:
+             centers[idx] = [x, y]
+             idx += 1
+ 
+     # Perturb the 26th circle to break initial symmetry. This is critical for escaping local optima.
+     # Revert to the fixed, proven value instead of a random one for a stable, high-quality start.
+     centers[25] = [0.39, 0.41]
+ 
++    # Apply small random perturbations to all centers to help escape local optima
++    # by introducing slight initial asymmetry and exploring varied starting points.
++    # These scales are based on successful prior implementations.
++    perturbation_scale_grid = 0.005 # For the 5x5 grid circles
++    perturbation_scale_26th = 0.01  # For the 26th central circle
++
++    centers[:25, 0] += np.random.uniform(-perturbation_scale_grid, perturbation_scale_grid, 25)
++    centers[:25, 1] += np.random.uniform(-perturbation_scale_grid, perturbation_scale_grid, 25)
++    centers[25, 0] += np.random.uniform(-perturbation_scale_26th, perturbation_scale_26th)
++    centers[25, 1] += np.random.uniform(-perturbation_scale_26th, perturbation_scale_26th)
++
++    # Ensure centers remain within the unit square after perturbation.
++    # Clipping to 0.01 and 0.99 prevents centers from being exactly on the boundary,
++    # which can sometimes lead to issues with radius calculation near walls.
++    centers = np.clip(centers, 0.01, 0.99)
++
+     # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+-    refinement_steps = 30
++    # Increased refinement steps for a more thorough annealing process.
++    refinement_steps = 100 # Increased from 30
+     step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+ 
+     # A richer 5x5 neighborhood for moves allows for finer adjustments. `(0,0)` is included.
+     move_multipliers = [-1.0, -0.5, 0.0, 0.5, 1.0]
+     moves = [(dx, dy) for dx in move_multipliers for dy in move_multipliers]
+ 
+     # Temperature schedule for the SA-like acceptance criterion.
+     T_initial = 0.0005  # Tuned to be sensitive to small changes in sum_radii
+     T_final = 1e-9
+     # Exponential cooling schedule based on the number of refinement steps.
++    # Recalculated for increased refinement_steps.
+     cooling_rate = (T_final / T_initial)**(1.0 / refinement_steps)
+     T = T_initial
+ 
+     for step_idx in range(refinement_steps):
+         step_size = step_schedule[step_idx]
+ 
+         # Dynamically adjust quick solve parameters for an efficient search.
+         if step_idx < refinement_steps // 3:
+             quick_solve_iterations = 80
+-            quick_solve_update_factor = 0.7
++            quick_solve_adaptive_schedule = (0.7, 0.4, 0.5) # Initial (high), Final (low), Transition Ratio
+         elif step_idx < 2 * refinement_steps // 3:
+             quick_solve_iterations = 130
+-            quick_solve_update_factor = 0.65
++            quick_solve_adaptive_schedule = (0.65, 0.4, 0.5) # Slightly lower initial, same final
+         else:
+             quick_solve_iterations = 200
+-            quick_solve_update_factor = 0.6
++            quick_solve_adaptive_schedule = (0.6, 0.4, 0.5) # Even lower initial, same final
+ 
+         # Iterate through circles, applying a probabilistically chosen move.
+         for i in np.random.permutation(n):
+             original_center = centers[i]
+ 
+             # Generate all 25 potential positions from the move set and evaluate their scores.
+             potential_positions = [np.clip(original_center + step_size * np.array(m), 0.0, 1.0) for m in moves]
+             scores = np.zeros(len(moves))
+ 
+             for idx, pos in enumerate(potential_positions):
+                 test_centers = np.copy(centers)
+                 test_centers[i] = pos
+-                test_radii = compute_max_radii(test_centers, iterations=quick_solve_iterations, update_factor=quick_solve_update_factor)
++                # Pass the adaptive damping schedule to the quick solver
++                test_radii = compute_max_radii(test_centers, iterations=quick_solve_iterations, adaptive_damping_schedule=quick_solve_adaptive_schedule)
+                 scores[idx] = np.sum(test_radii)
+ 
+             # Select a move using a Boltzmann distribution (numerically stable softmax).
+             scores_shifted = scores - np.max(scores)
+             if T > 1e-12:
+                 probs = np.exp(scores_shifted / T)
+             else: # At negligible temperature, behave greedily.
+                 probs = np.zeros_like(scores)
+                 probs[np.argmax(scores)] = 1.0
+ 
+             probs_sum = np.sum(probs)
+             if probs_sum > 0:
+                 probs /= probs_sum
+             else: # Failsafe for underflow: behave greedily.
+                 probs = np.zeros_like(scores)
+                 probs[np.argmax(scores)] = 1.0
+ 
+             # Choose and apply one move based on the calculated probabilities.
+             chosen_idx = np.random.choice(len(potential_positions), p=probs)
+             centers[i] = potential_positions[chosen_idx]
+ 
+         # Cool the temperature for the next refinement step.
+         T *= cooling_rate
+ 
+     # 3. Final high-precision radius calculation on the optimized centers.
+-    # Use a proven stable update_factor and many iterations for the final solve.
+-    final_radii = compute_max_radii(centers, iterations=10000, update_factor=0.55)
++    # Use an adaptive damping schedule and many iterations for the final solve for maximum accuracy.
++    # The schedule (0.65, 0.5, 0.2) is based on successful prior implementations.
++    final_radii = compute_max_radii(centers, iterations=10000, adaptive_damping_schedule=(0.65, 0.5, 0.2))
+ 
+     return centers, final_radii
+ 
+ 
+-def compute_max_radii(centers, iterations=5000, update_factor=0.6):
++def compute_max_radii(centers, iterations=5000, update_factor=0.6, adaptive_damping_schedule=None):
+     """
+     Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
++    This version supports an optional adaptive damping schedule.
+ 
+     Args:
+         centers: np.array of shape (n, 2) with (x, y) coordinates.
+         iterations: The number of relaxation iterations to perform.
+-        update_factor: Damping factor for radius updates.
++        update_factor: Base damping factor for radius updates (used if adaptive_damping_schedule is None).
++        adaptive_damping_schedule: A tuple (initial_factor, final_factor, transition_ratio)
++                                   to linearly decay the damping factor over iterations.
++                                   If None, a fixed `update_factor` is used.
+ 
+     Returns:
+         np.array of shape (n) with the radius of each circle.
+     """
+     n = centers.shape[0]
+     # Small non-zero start to prevent issues on the first iteration.
+     radii = np.full(n, 1e-6)
+ 
+     # Pre-calculate distances between centers.
+     dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+     # Set diagonal to infinity so a circle isn't constrained by itself.
+     np.fill_diagonal(dist_matrix, np.inf)
+ 
+     # Pre-calculate wall distances for all circles.
+     wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+ 
+-    for _ in range(iterations):
++    for iter_idx in range(iterations): # Changed loop variable to iter_idx
+         radii_old = np.copy(radii)
++
++        # Determine current damping factor based on adaptive schedule or fixed value
++        if adaptive_damping_schedule is not None:
++            initial_uf, final_uf, transition_ratio = adaptive_damping_schedule
++            if iterations == 0: # Avoid division by zero
++                current_update_factor = final_uf
++            elif iter_idx < iterations * transition_ratio:
++                # Linearly decay from initial_uf to final_uf over the transition_ratio of iterations
++                current_update_factor = initial_uf - (initial_uf - final_uf) * (iter_idx / (iterations * transition_ratio))
++            else:
++                # Maintain final_uf for the remaining iterations
++                current_update_factor = final_uf
++        else:
++            current_update_factor = update_factor
+ 
+         # Calculate all potential radii based on other circles in a vectorized way.
+         # `dist_matrix - radii_old` gives a matrix of potential radii from each other circle.
+         # Taking `min(axis=1)` finds the tightest constraint for each circle.
+         potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+ 
+         # Combine with wall constraints.
+         potential_r = np.minimum(wall_dists, potential_r_circles)
+ 
+         # New radii for this iteration (must be non-negative).
+         new_r = np.maximum(0.0, potential_r)
+ 
+         # Dampen the update to prevent oscillations.
+-        radii = radii_old + update_factor * (new_r - radii_old)
++        radii = radii_old + current_update_factor * (new_r - radii_old)
+ 
+         # Early exit condition if radii have converged.
+         if np.max(np.abs(radii - radii_old)) < 1e-9:
+             break
+ 
+     return radii
+ # EVOLVE-BLOCK-END
+ 
+ 
+ # This part remains fixed (not evolved)
+ def run_packing():
+     """Run the circle packing constructor for n=26"""
+     centers, radii = construct_packing()
+     # Calculate the sum of radii
+     sum_radii = np.sum(radii)
+     return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_102/main.py

@@ -0,0 +1,202 @@
+# EVOLVE-BLOCK-START
+"""Constructor-based circle packing for n=26 circles combining 5x5 grid layout
+with iterative radius relaxation solver."""
+
+import numpy as np
+
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles by starting with a strong
+    grid-based pattern and refining center positions using a coordinate ascent
+    method with a rich neighborhood and dynamic solver parameters.
+
+    Returns:
+        A tuple containing:
+        centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+        radii: np.array of shape (26) with the final radius of each circle
+    """
+    n = 26
+    centers = np.zeros((n, 2))
+
+    # 1. Initial Placement: Start with a 5x5 grid + central circle pattern.
+    # Adopt the optimized margin 'd' from a successful prior for a potentially better
+    # initial grid configuration. This value is known to be effective for dense packings.
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+
+    # Perturb the 26th circle to break initial symmetry. This is critical for escaping local optima.
+    # Revert to the fixed, proven value instead of a random one for a stable, high-quality start.
+    centers[25] = [0.39, 0.41]
+
+    # Apply small random perturbations to all centers to help escape local optima
+    # by introducing slight initial asymmetry and exploring varied starting points.
+    # These scales are based on successful prior implementations.
+    perturbation_scale_grid = 0.005 # For the 5x5 grid circles
+    perturbation_scale_26th = 0.01  # For the 26th central circle
+
+    centers[:25, 0] += np.random.uniform(-perturbation_scale_grid, perturbation_scale_grid, 25)
+    centers[:25, 1] += np.random.uniform(-perturbation_scale_grid, perturbation_scale_grid, 25)
+    centers[25, 0] += np.random.uniform(-perturbation_scale_26th, perturbation_scale_26th)
+    centers[25, 1] += np.random.uniform(-perturbation_scale_26th, perturbation_scale_26th)
+
+    # Ensure centers remain within the unit square after perturbation.
+    # Clipping to 0.01 and 0.99 prevents centers from being exactly on the boundary,
+    # which can sometimes lead to issues with radius calculation near walls.
+    centers = np.clip(centers, 0.01, 0.99)
+
+    # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+    # Increased refinement steps for a more thorough annealing process.
+    refinement_steps = 100 # Increased from 30
+    step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+
+    # A richer 5x5 neighborhood for moves allows for finer adjustments. `(0,0)` is included.
+    move_multipliers = [-1.0, -0.5, 0.0, 0.5, 1.0]
+    moves = [(dx, dy) for dx in move_multipliers for dy in move_multipliers]
+
+    # Temperature schedule for the SA-like acceptance criterion.
+    T_initial = 0.0005  # Tuned to be sensitive to small changes in sum_radii
+    T_final = 1e-9
+    # Exponential cooling schedule based on the number of refinement steps.
+    # Recalculated for increased refinement_steps.
+    cooling_rate = (T_final / T_initial)**(1.0 / refinement_steps)
+    T = T_initial
+
+    for step_idx in range(refinement_steps):
+        step_size = step_schedule[step_idx]
+
+        # Dynamically adjust quick solve parameters for an efficient search.
+        if step_idx < refinement_steps // 3:
+            quick_solve_iterations = 80
+            quick_solve_adaptive_schedule = (0.7, 0.4, 0.5) # Initial (high), Final (low), Transition Ratio
+        elif step_idx < 2 * refinement_steps // 3:
+            quick_solve_iterations = 130
+            quick_solve_adaptive_schedule = (0.65, 0.4, 0.5) # Slightly lower initial, same final
+        else:
+            quick_solve_iterations = 200
+            quick_solve_adaptive_schedule = (0.6, 0.4, 0.5) # Even lower initial, same final
+
+        # Iterate through circles, applying a probabilistically chosen move.
+        for i in np.random.permutation(n):
+            original_center = centers[i]
+
+            # Generate all 25 potential positions from the move set and evaluate their scores.
+            potential_positions = [np.clip(original_center + step_size * np.array(m), 0.0, 1.0) for m in moves]
+            scores = np.zeros(len(moves))
+
+            for idx, pos in enumerate(potential_positions):
+                test_centers = np.copy(centers)
+                test_centers[i] = pos
+                # Pass the adaptive damping schedule to the quick solver
+                test_radii = compute_max_radii(test_centers, iterations=quick_solve_iterations, adaptive_damping_schedule=quick_solve_adaptive_schedule)
+                scores[idx] = np.sum(test_radii)
+
+            # Select a move using a Boltzmann distribution (numerically stable softmax).
+            scores_shifted = scores - np.max(scores)
+            if T > 1e-12:
+                probs = np.exp(scores_shifted / T)
+            else: # At negligible temperature, behave greedily.
+                probs = np.zeros_like(scores)
+                probs[np.argmax(scores)] = 1.0
+
+            probs_sum = np.sum(probs)
+            if probs_sum > 0:
+                probs /= probs_sum
+            else: # Failsafe for underflow: behave greedily.
+                probs = np.zeros_like(scores)
+                probs[np.argmax(scores)] = 1.0
+
+            # Choose and apply one move based on the calculated probabilities.
+            chosen_idx = np.random.choice(len(potential_positions), p=probs)
+            centers[i] = potential_positions[chosen_idx]
+
+        # Cool the temperature for the next refinement step.
+        T *= cooling_rate
+
+    # 3. Final high-precision radius calculation on the optimized centers.
+    # Use an adaptive damping schedule and many iterations for the final solve for maximum accuracy.
+    # The schedule (0.65, 0.5, 0.2) is based on successful prior implementations.
+    final_radii = compute_max_radii(centers, iterations=10000, adaptive_damping_schedule=(0.65, 0.5, 0.2))
+
+    return centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=0.6, adaptive_damping_schedule=None):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an optional adaptive damping schedule.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Base damping factor for radius updates (used if adaptive_damping_schedule is None).
+        adaptive_damping_schedule: A tuple (initial_factor, final_factor, transition_ratio)
+                                   to linearly decay the damping factor over iterations.
+                                   If None, a fixed `update_factor` is used.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    for iter_idx in range(iterations): # Changed loop variable to iter_idx
+        radii_old = np.copy(radii)
+
+        # Determine current damping factor based on adaptive schedule or fixed value
+        if adaptive_damping_schedule is not None:
+            initial_uf, final_uf, transition_ratio = adaptive_damping_schedule
+            if iterations == 0: # Avoid division by zero
+                current_update_factor = final_uf
+            elif iter_idx < iterations * transition_ratio:
+                # Linearly decay from initial_uf to final_uf over the transition_ratio of iterations
+                current_update_factor = initial_uf - (initial_uf - final_uf) * (iter_idx / (iterations * transition_ratio))
+            else:
+                # Maintain final_uf for the remaining iterations
+                current_update_factor = final_uf
+        else:
+            current_update_factor = update_factor
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        # `dist_matrix - radii_old` gives a matrix of potential radii from each other circle.
+        # Taking `min(axis=1)` finds the tightest constraint for each circle.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + current_update_factor * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_102/original.py

@@ -0,0 +1,164 @@
+# EVOLVE-BLOCK-START
+"""Constructor-based circle packing for n=26 circles combining 5x5 grid layout
+with iterative radius relaxation solver."""
+
+import numpy as np
+
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles by starting with a strong
+    grid-based pattern and refining center positions using a coordinate ascent
+    method with a rich neighborhood and dynamic solver parameters.
+
+    Returns:
+        A tuple containing:
+        centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+        radii: np.array of shape (26) with the final radius of each circle
+    """
+    n = 26
+    centers = np.zeros((n, 2))
+
+    # 1. Initial Placement: Start with a 5x5 grid + central circle pattern.
+    # Adopt the optimized margin 'd' from a successful prior for a potentially better
+    # initial grid configuration. This value is known to be effective for dense packings.
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+
+    # Perturb the 26th circle to break initial symmetry. This is critical for escaping local optima.
+    # Revert to the fixed, proven value instead of a random one for a stable, high-quality start.
+    centers[25] = [0.39, 0.41]
+
+    # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+    refinement_steps = 30
+    step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+
+    # A richer 5x5 neighborhood for moves allows for finer adjustments. `(0,0)` is included.
+    move_multipliers = [-1.0, -0.5, 0.0, 0.5, 1.0]
+    moves = [(dx, dy) for dx in move_multipliers for dy in move_multipliers]
+
+    # Temperature schedule for the SA-like acceptance criterion.
+    T_initial = 0.0005  # Tuned to be sensitive to small changes in sum_radii
+    T_final = 1e-9
+    # Exponential cooling schedule based on the number of refinement steps.
+    cooling_rate = (T_final / T_initial)**(1.0 / refinement_steps)
+    T = T_initial
+
+    for step_idx in range(refinement_steps):
+        step_size = step_schedule[step_idx]
+
+        # Dynamically adjust quick solve parameters for an efficient search.
+        if step_idx < refinement_steps // 3:
+            quick_solve_iterations = 80
+            quick_solve_update_factor = 0.7
+        elif step_idx < 2 * refinement_steps // 3:
+            quick_solve_iterations = 130
+            quick_solve_update_factor = 0.65
+        else:
+            quick_solve_iterations = 200
+            quick_solve_update_factor = 0.6
+
+        # Iterate through circles, applying a probabilistically chosen move.
+        for i in np.random.permutation(n):
+            original_center = centers[i]
+
+            # Generate all 25 potential positions from the move set and evaluate their scores.
+            potential_positions = [np.clip(original_center + step_size * np.array(m), 0.0, 1.0) for m in moves]
+            scores = np.zeros(len(moves))
+
+            for idx, pos in enumerate(potential_positions):
+                test_centers = np.copy(centers)
+                test_centers[i] = pos
+                test_radii = compute_max_radii(test_centers, iterations=quick_solve_iterations, update_factor=quick_solve_update_factor)
+                scores[idx] = np.sum(test_radii)
+
+            # Select a move using a Boltzmann distribution (numerically stable softmax).
+            scores_shifted = scores - np.max(scores)
+            if T > 1e-12:
+                probs = np.exp(scores_shifted / T)
+            else: # At negligible temperature, behave greedily.
+                probs = np.zeros_like(scores)
+                probs[np.argmax(scores)] = 1.0
+
+            probs_sum = np.sum(probs)
+            if probs_sum > 0:
+                probs /= probs_sum
+            else: # Failsafe for underflow: behave greedily.
+                probs = np.zeros_like(scores)
+                probs[np.argmax(scores)] = 1.0
+
+            # Choose and apply one move based on the calculated probabilities.
+            chosen_idx = np.random.choice(len(potential_positions), p=probs)
+            centers[i] = potential_positions[chosen_idx]
+
+        # Cool the temperature for the next refinement step.
+        T *= cooling_rate
+
+    # 3. Final high-precision radius calculation on the optimized centers.
+    # Use a proven stable update_factor and many iterations for the final solve.
+    final_radii = compute_max_radii(centers, iterations=10000, update_factor=0.55)
+
+    return centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=0.6):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Damping factor for radius updates.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    for _ in range(iterations):
+        radii_old = np.copy(radii)
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        # `dist_matrix - radii_old` gives a matrix of potential radii from each other circle.
+        # Taking `min(axis=1)` finds the tightest constraint for each circle.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + update_factor * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_102/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_102/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 2.5235511803567197,
+  "correct": true,
+  "primary": {
+    "combined_score": 2.5235511803567197,
+    "public": {
+      "centers_str": "  centers[0] = (0.0883, 0.0883)\n  centers[1] = (0.1180, 0.2924)\n  centers[2] = (0.0934, 0.5023)\n  centers[3] = (0.0973, 0.6929)\n  centers[4] = (0.1242, 0.8942)\n  centers[5] = (0.3013, 0.1279)\n  centers[6] = (0.2995, 0.3217)\n  centers[7] = (0.2691, 0.5199)\n  centers[8] = (0.2959, 0.7028)\n  centers[9] = (0.3291, 0.9008)\n  centers[10] = (0.5016, 0.0784)\n  centers[11] = (0.5025, 0.2788)\n  centers[12] = (0.5164, 0.5183)\n  centers[13] = (0.4966, 0.7146)\n  centers[14] = (0.5221, 0.9062)\n  centers[15] = (0.6876, 0.1103)\n  centers[16] = (0.7166, 0.3134)\n  centers[17] = (0.7085, 0.5030)\n  centers[18] = (0.6989, 0.7029)\n  centers[19] = (0.7130, 0.9029)\n  centers[20] = (0.8969, 0.0962)\n  centers[21] = (0.9048, 0.2874)\n  centers[22] = (0.9011, 0.4814)\n  centers[23] = (0.9005, 0.6799)\n  centers[24] = (0.9041, 0.8753)\n  centers[25] = (0.3829, 0.4236)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 2.5235511803567197
+    },
+    "execution_time_mean": 32.92109573353082,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770405591.7633276,
+  "generation": 102
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_102/search_replace.txt

@@ -0,0 +1,326 @@
+<NAME>
+adaptive_damping_in_solver
+</NAME>
+
+<DESCRIPTION>
+The `compute_max_radii` function is the core solver for determining circle radii.
+Currently, it uses a single, fixed `update_factor` throughout its iterations.
+This edit enhances `compute_max_radii` by allowing an optional `adaptive_damping_schedule`
+tuple `(initial_factor, final_factor, transition_ratio)`. If provided, the damping
+factor will linearly decay from `initial_factor` to `final_factor` over a
+fraction `transition_ratio` of the total iterations, and then remain at `final_factor`.
+This provides more nuanced control over convergence, preventing oscillations
+early on and promoting stability in later stages, which can lead to higher precision
+and better overall radii sums.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+def compute_max_radii(centers, iterations=5000, update_factor=0.6):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Damping factor for radius updates.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    for _ in range(iterations):
+        radii_old = np.copy(radii)
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        # `dist_matrix - radii_old` gives a matrix of potential radii from each other circle.
+        # Taking `min(axis=1)` finds the tightest constraint for each circle.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + update_factor * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+=======
+def compute_max_radii(centers, iterations=5000, update_factor=0.6, adaptive_damping_schedule=None):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an optional adaptive damping schedule.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Base damping factor for radius updates (used if adaptive_damping_schedule is None).
+        adaptive_damping_schedule: A tuple (initial_factor, final_factor, transition_ratio)
+                                   to linearly decay the damping factor over iterations.
+                                   If None, a fixed `update_factor` is used.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    for iter_idx in range(iterations): # Changed loop variable to iter_idx
+        radii_old = np.copy(radii)
+
+        # Determine current damping factor based on adaptive schedule or fixed value
+        if adaptive_damping_schedule is not None:
+            initial_uf, final_uf, transition_ratio = adaptive_damping_schedule
+            if iterations == 0: # Avoid division by zero
+                current_update_factor = final_uf
+            elif iter_idx < iterations * transition_ratio:
+                # Linearly decay from initial_uf to final_uf over the transition_ratio of iterations
+                current_update_factor = initial_uf - (initial_uf - final_uf) * (iter_idx / (iterations * transition_ratio))
+            else:
+                # Maintain final_uf for the remaining iterations
+                current_update_factor = final_uf
+        else:
+            current_update_factor = update_factor
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        # `dist_matrix - radii_old` gives a matrix of potential radii from each other circle.
+        # Taking `min(axis=1)` finds the tightest constraint for each circle.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + current_update_factor * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+>>>>>>> REPLACE
+</DIFF>
+
+<NAME>
+initial_random_perturbations
+</NAME>
+
+<DESCRIPTION>
+To enhance the exploration of the solution space and prevent premature convergence
+to a local optimum, small random perturbations are reintroduced to all circle
+centers immediately after their initial grid placement. This slightly breaks
+the initial symmetry and provides a diverse set of starting configurations for
+the subsequent refinement process. Different perturbation scales are applied
+to the main grid circles and the 26th central circle to reflect their distinct roles.
+Centers are clipped to ensure they remain within the unit square. This strategy
+was present in prior successful programs and can improve the final sum of radii.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+    # Perturb the 26th circle to break initial symmetry. This is critical for escaping local optima.
+    # Revert to the fixed, proven value instead of a random one for a stable, high-quality start.
+    centers[25] = [0.39, 0.41]
+
+    # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+    refinement_steps = 30
+    step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+=======
+    # Perturb the 26th circle to break initial symmetry. This is critical for escaping local optima.
+    # Revert to the fixed, proven value instead of a random one for a stable, high-quality start.
+    centers[25] = [0.39, 0.41]
+
+    # Apply small random perturbations to all centers to help escape local optima
+    # by introducing slight initial asymmetry and exploring varied starting points.
+    # These scales are based on successful prior implementations.
+    perturbation_scale_grid = 0.005 # For the 5x5 grid circles
+    perturbation_scale_26th = 0.01  # For the 26th central circle
+
+    centers[:25, 0] += np.random.uniform(-perturbation_scale_grid, perturbation_scale_grid, 25)
+    centers[:25, 1] += np.random.uniform(-perturbation_scale_grid, perturbation_scale_grid, 25)
+    centers[25, 0] += np.random.uniform(-perturbation_scale_26th, perturbation_scale_26th)
+    centers[25, 1] += np.random.uniform(-perturbation_scale_26th, perturbation_scale_26th)
+
+    # Ensure centers remain within the unit square after perturbation.
+    # Clipping to 0.01 and 0.99 prevents centers from being exactly on the boundary,
+    # which can sometimes lead to issues with radius calculation near walls.
+    centers = np.clip(centers, 0.01, 0.99)
+
+    # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+    refinement_steps = 30
+    step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+>>>>>>> REPLACE
+</DIFF>
+
+<NAME>
+slower_annealing_schedule
+</NAME>
+
+<DESCRIPTION>
+The current simulated annealing component cools very rapidly, potentially leading
+to premature convergence to local optima. This edit proposes to increase the
+number of `refinement_steps` from 30 to 100 and re-calculate the `cooling_rate`
+accordingly. This change allows for a significantly slower cooling process and
+more iterations at higher "temperatures," enabling broader exploration of the
+solution space and a greater chance to escape local optima. While increasing
+computation, the improved search quality is expected to yield a higher sum of radii.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+    # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+    refinement_steps = 30
+    step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+
+    # A richer 5x5 neighborhood for moves allows for finer adjustments. `(0,0)` is included.
+    move_multipliers = [-1.0, -0.5, 0.0, 0.5, 1.0]
+    moves = [(dx, dy) for dx in move_multipliers for dy in move_multipliers]
+
+    # Temperature schedule for the SA-like acceptance criterion.
+    T_initial = 0.0005  # Tuned to be sensitive to small changes in sum_radii
+    T_final = 1e-9
+    # Exponential cooling schedule based on the number of refinement steps.
+    cooling_rate = (T_final / T_initial)**(1.0 / refinement_steps)
+    T = T_initial
+=======
+    # 2. Iterative Center Refinement using a Hybrid SA-Coordinate Ascent.
+    # Increased refinement steps for a more thorough annealing process.
+    refinement_steps = 100 # Increased from 30
+    step_schedule = np.logspace(np.log10(0.05), np.log10(0.00001), refinement_steps)
+
+    # A richer 5x5 neighborhood for moves allows for finer adjustments. `(0,0)` is included.
+    move_multipliers = [-1.0, -0.5, 0.0, 0.5, 1.0]
+    moves = [(dx, dy) for dx in move_multipliers for dy in move_multipliers]
+
+    # Temperature schedule for the SA-like acceptance criterion.
+    T_initial = 0.0005  # Tuned to be sensitive to small changes in sum_radii
+    T_final = 1e-9
+    # Exponential cooling schedule based on the number of refinement steps.
+    # Recalculated for increased refinement_steps.
+    cooling_rate = (T_final / T_initial)**(1.0 / refinement_steps)
+    T = T_initial
+>>>>>>> REPLACE
+</DIFF>
+
+<NAME>
+adaptive_quick_solve_damping
+</NAME>
+
+<DESCRIPTION>
+The intermediate `compute_max_radii` calls are now enhanced by using
+an adaptive damping schedule rather than a fixed `update_factor`. This allows
+the radius solver to be more aggressive early in its own iterations (higher
+initial damping) and then settle into a more stable convergence (lower final damping).
+This change makes the quick radius evaluations more accurate and robust, which
+can better guide the center refinement process. The schedule for each stage
+is tuned based on the fixed factors previously used, ensuring a smooth transition
+and potentially better overall convergence for the main optimization loop.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+        if step_idx < refinement_steps // 3:
+            quick_solve_iterations = 80
+            quick_solve_update_factor = 0.7
+        elif step_idx < 2 * refinement_steps // 3:
+            quick_solve_iterations = 130
+            quick_solve_update_factor = 0.65
+        else:
+            quick_solve_iterations = 200
+            quick_solve_update_factor = 0.6
+
+        # Iterate through circles, applying a probabilistically chosen move.
+        for i in np.random.permutation(n):
+            original_center = centers[i]
+
+            # Generate all 25 potential positions from the move set and evaluate their scores.
+            potential_positions = [np.clip(original_center + step_size * np.array(m), 0.0, 1.0) for m in moves]
+            scores = np.zeros(len(moves))
+
+            for idx, pos in enumerate(potential_positions):
+                test_centers = np.copy(centers)
+                test_centers[i] = pos
+                test_radii = compute_max_radii(test_centers, iterations=quick_solve_iterations, update_factor=quick_solve_update_factor)
+                scores[idx] = np.sum(test_radii)
+=======
+        if step_idx < refinement_steps // 3:
+            quick_solve_iterations = 80
+            quick_solve_adaptive_schedule = (0.7, 0.4, 0.5) # Initial (high), Final (low), Transition Ratio
+        elif step_idx < 2 * refinement_steps // 3:
+            quick_solve_iterations = 130
+            quick_solve_adaptive_schedule = (0.65, 0.4, 0.5) # Slightly lower initial, same final
+        else:
+            quick_solve_iterations = 200
+            quick_solve_adaptive_schedule = (0.6, 0.4, 0.5) # Even lower initial, same final
+
+        # Iterate through circles, applying a probabilistically chosen move.
+        for i in np.random.permutation(n):
+            original_center = centers[i]
+
+            # Generate all 25 potential positions from the move set and evaluate their scores.
+            potential_positions = [np.clip(original_center + step_size * np.array(m), 0.0, 1.0) for m in moves]
+            scores = np.zeros(len(moves))
+
+            for idx, pos in enumerate(potential_positions):
+                test_centers = np.copy(centers)
+                test_centers[i] = pos
+                # Pass the adaptive damping schedule to the quick solver
+                test_radii = compute_max_radii(test_centers, iterations=quick_solve_iterations, adaptive_damping_schedule=quick_solve_adaptive_schedule)
+                scores[idx] = np.sum(test_radii)
+>>>>>>> REPLACE
+</DIFF>
+
+<NAME>
+adaptive_final_solve_damping
+</NAME>
+
+<DESCRIPTION>
+The final high-precision radius calculation is crucial for the overall sum of radii.
+By applying an adaptive damping schedule to this step, the solver can achieve
+a more stable and accurate convergence. The `(0.65, 0.5, 0.2)` schedule (initial, final, transition_ratio)
+is derived from previously successful implementations, allowing for faster updates
+early in the final solve and very precise fine-tuning towards the end.
+This ensures the reported sum of radii is as accurate as possible for the optimized centers.
+</DESCRIPTION>
+
+<DIFF>
+<<<<<<< SEARCH
+    # 3. Final high-precision radius calculation on the optimized centers.
+    # Use a proven stable update_factor and many iterations for the final solve.
+    final_radii = compute_max_radii(centers, iterations=10000, update_factor=0.55)
+=======
+    # 3. Final high-precision radius calculation on the optimized centers.
+    # Use an adaptive damping schedule and many iterations for the final solve for maximum accuracy.
+    # The schedule (0.65, 0.5, 0.2) is based on successful prior implementations.
+    final_radii = compute_max_radii(centers, iterations=10000, adaptive_damping_schedule=(0.65, 0.5, 0.2))
+>>>>>>> REPLACE
+</DIFF>

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_103/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": false,
+    "error": "operands could not be broadcast together with shapes (3,) (26,) "
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_103/results/metrics.json

@@ -0,0 +1,19 @@
+{
+  "combined_score": 0.0,
+  "correct": false,
+  "primary": {
+    "combined_score": 0.0,
+    "execution_time_mean": 0.0,
+    "execution_time_std": 0.0,
+    "num_successful_runs": 0,
+    "num_valid_runs": 0,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": false,
+    "validation_error": "operands could not be broadcast together with shapes (3,) (26,) "
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770405617.0551147,
+  "generation": 103
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_104/edit.diff

@@ -0,0 +1,206 @@
+--- a/original.py
++++ b/original.py
+@@ -1,185 +1,196 @@
+ # EVOLVE-BLOCK-START
+ import numpy as np
+ 
+ def construct_packing():
+     """
+     Constructs an optimized arrangement of 26 circles using Simulated Annealing (SA),
+-    enhanced with adaptive radius computation parameters, to find a high-quality packing.
++    enhanced with adaptive radius computation parameters, an adaptive move strategy,
++    and a longer cooling schedule to find a high-quality packing.
+ 
+     Returns:
+         A tuple containing:
+         centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+         radii: np.array of shape (26) with the final radius of each circle
+     """
+     n = 26
+ 
+     # 1. Initial State and SA Parameters
+     # Start with a proven high-quality initial grid configuration (from prior successful programs).
+     centers = np.zeros((n, 2))
+     d = 0.09525
+     grid_coords = np.linspace(d, 1 - d, 5)
+     idx = 0
+     for x in grid_coords:
+         for y in grid_coords:
+             centers[idx] = [x, y]
+             idx += 1
+-    # Perturbation to break symmetry, a key element from successful priors.
+-    centers[25] = [0.39, 0.41]
++    # Perturbation to break symmetry, now with a small random component for diversity.
++    centers[25] = [0.39 + np.random.uniform(-0.01, 0.01), 0.41 + np.random.uniform(-0.01, 0.01)]
+ 
+-    # SA Parameters - tuned for thorough search.
++    # SA Parameters - tuned for a longer, more thorough search (from a high-performing prior).
+     T_initial = 0.01          # Initial temperature (allows large uphill moves)
+     T_final = 1e-7            # Final temperature (near deterministic local search)
+-    alpha = 0.9998            # Cooling rate (slow, for deeper exploration)
+-    max_steps = 150000        # Increased steps for more thorough annealing.
++    alpha = 0.99985           # Slower cooling rate for more steps
++    max_steps = 200000        # Increased steps for a deeper search
+ 
+     # Move generation parameters
+     initial_move_dist = 0.08  # Max move distance at T_initial
+-    num_circles_to_move = 3   # Number of circles to perturb each step
++    # num_circles_to_move will now be adaptive, based on temperature.
+ 
+     current_centers = np.copy(centers)
+     best_centers = np.copy(centers)
+ 
+     # Pre-compute schedules for adaptive quick_solve parameters, inspired by Coordinate Ascent.
+     # These will provide smoother transitions for evaluation accuracy.
+     quick_iter_schedule = np.linspace(80, 250, max_steps, dtype=int)
+     quick_update_schedule = np.linspace(0.75, 0.55, max_steps)
+ 
+     # Initial energy calculation (Energy = -Sum of Radii)
+     # Use the adaptive compute_max_radii, but with constant factor for initial quick evaluation.
+     initial_quick_solve_iter = quick_iter_schedule[0]
+     initial_quick_solve_uf = quick_update_schedule[0]
+     current_radii = compute_max_radii(current_centers, iterations=initial_quick_solve_iter, 
+                                       update_factor=(initial_quick_solve_uf, initial_quick_solve_uf, 0.0))
+     current_energy = -np.sum(current_radii)
+     best_energy = current_energy
+ 
+     T = T_initial
+     step = 0
+ 
+     # 2. Annealing Loop
+     while T > T_final and step < max_steps:
+         # Generate a new candidate configuration
+         candidate_centers = np.copy(current_centers)
+         
+         # Anneal the move distance based on temperature for adaptive step size.
+         move_dist = initial_move_dist * (T / T_initial)**0.5
++
++        # Adaptive number of circles to move (crossover from another SA program)
++        if T > T_initial * 0.1:
++            num_circles_to_move = 4
++        elif T > T_initial * 0.01:
++            num_circles_to_move = 3
++        elif T > T_initial * 0.001:
++            num_circles_to_move = 2
++        else:
++            num_circles_to_move = 1
+ 
+         # Randomly pick a few circles to perturb for diverse exploration.
+         circles_to_move_indices = np.random.choice(n, num_circles_to_move, replace=False)
+         
+         # Create random move vectors and apply them.
+         move_vectors = np.random.uniform(-move_dist, move_dist, size=(num_circles_to_move, 2))
+         candidate_centers[circles_to_move_indices] += move_vectors
+         
+         # Clip all centers to ensure they stay within the unit square.
+         candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+         
+         # Determine current quick_solve parameters from schedules for adaptive evaluation.
+         current_quick_solve_iter = quick_iter_schedule[step]
+         current_quick_solve_uf = quick_update_schedule[step]
+ 
+         # Calculate the energy of the new candidate using adaptive solver.
+         candidate_radii = compute_max_radii(candidate_centers, iterations=current_quick_solve_iter, 
+                                             update_factor=(current_quick_solve_uf, current_quick_solve_uf, 0.0))
+         candidate_energy = -np.sum(candidate_radii)
+ 
+         # Metropolis-Hastings acceptance criterion: allows "uphill" moves to escape local optima.
+         delta_E = candidate_energy - current_energy
+         if delta_E < 0 or np.random.rand() < np.exp(-delta_E / T):
+             current_centers = candidate_centers
+             current_energy = candidate_energy
+ 
+         # Update the best-ever found solution.
+         if current_energy < best_energy:
+             best_energy = current_energy
+             best_centers = np.copy(current_centers)
+         
+         # Cool down the temperature.
+         T *= alpha
+         step += 1
+ 
+     # 3. Finalization
+     # Run a final high-precision radius calculation on the best configuration found.
+     # Uses a sophisticated adaptive damping schedule for maximum accuracy and stability.
+     final_radii = compute_max_radii(best_centers, iterations=10000, update_factor=(0.65, 0.45, 0.25))
+     
+     return best_centers, final_radii
+ 
+ 
+ def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+     """
+     Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+     This version supports an adaptive damping schedule for the update factor.
+ 
+     Args:
+         centers: np.array of shape (n, 2) with (x, y) coordinates.
+         iterations: The number of relaxation iterations to perform.
+         update_factor: Can be:
+                        - A single float: constant damping factor.
+                        - A tuple (initial_uf, final_uf, switch_ratio): adaptive damping.
+                          `initial_uf` is used at the start, decaying linearly to `final_uf`
+                          over `iterations * switch_ratio` steps, then `final_uf` for the rest.
+ 
+     Returns:
+         np.array of shape (n) with the radius of each circle.
+     """
+     n = centers.shape[0]
+     # Small non-zero start to prevent issues on the first iteration.
+     radii = np.full(n, 1e-6)
+ 
+     # Pre-calculate distances between centers.
+     dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+     # Set diagonal to infinity so a circle isn't constrained by itself.
+     np.fill_diagonal(dist_matrix, np.inf)
+ 
+     # Pre-calculate wall distances for all circles.
+     wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+ 
+     # Interpret update_factor parameter for adaptive damping.
+     if isinstance(update_factor, (float, int)):
+         initial_uf = float(update_factor)
+         final_uf = float(update_factor)
+         switch_ratio = 0.0 # No adaptive schedule if a single float is provided
+     else: # Expecting a tuple (initial_uf, final_uf, switch_ratio)
+         initial_uf, final_uf, switch_ratio = update_factor
+ 
+     for k in range(iterations):
+         radii_old = np.copy(radii)
+ 
+         # Determine current damping factor based on iteration progress and schedule.
+         current_uf = initial_uf
+         if switch_ratio > 0 and k < iterations * switch_ratio:
+             # Linear interpolation from initial_uf to final_uf over the switch_ratio duration
+             current_uf = initial_uf + (final_uf - initial_uf) * (k / (iterations * switch_ratio))
+         elif switch_ratio > 0 and k >= iterations * switch_ratio:
+             # After the switch point, use the final damping factor
+             current_uf = final_uf
+         # If switch_ratio is 0, current_uf remains initial_uf as initialized above.
+ 
+         # Calculate all potential radii based on other circles in a vectorized way.
+         potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+ 
+         # Combine with wall constraints.
+         potential_r = np.minimum(wall_dists, potential_r_circles)
+ 
+         # New radii for this iteration (must be non-negative).
+         new_r = np.maximum(0.0, potential_r)
+ 
+         # Dampen the update to prevent oscillations.
+         radii = radii_old + current_uf * (new_r - radii_old)
+ 
+         # Early exit condition if radii have converged.
+         if np.max(np.abs(radii - radii_old)) < 1e-9:
+             break
+ 
+     return radii
+ # EVOLVE-BLOCK-END
+ 
+ 
+ # This part remains fixed (not evolved)
+ def run_packing():
+     """Run the circle packing constructor for n=26"""
+     centers, radii = construct_packing()
+     # Calculate the sum of radii
+     sum_radii = np.sum(radii)
+     return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_104/main.py

@@ -0,0 +1,196 @@
+# EVOLVE-BLOCK-START
+import numpy as np
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles using Simulated Annealing (SA),
+    enhanced with adaptive radius computation parameters, an adaptive move strategy,
+    and a longer cooling schedule to find a high-quality packing.
+
+    Returns:
+        A tuple containing:
+        centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+        radii: np.array of shape (26) with the final radius of each circle
+    """
+    n = 26
+
+    # 1. Initial State and SA Parameters
+    # Start with a proven high-quality initial grid configuration (from prior successful programs).
+    centers = np.zeros((n, 2))
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+    # Perturbation to break symmetry, now with a small random component for diversity.
+    centers[25] = [0.39 + np.random.uniform(-0.01, 0.01), 0.41 + np.random.uniform(-0.01, 0.01)]
+
+    # SA Parameters - tuned for a longer, more thorough search (from a high-performing prior).
+    T_initial = 0.01          # Initial temperature (allows large uphill moves)
+    T_final = 1e-7            # Final temperature (near deterministic local search)
+    alpha = 0.99985           # Slower cooling rate for more steps
+    max_steps = 200000        # Increased steps for a deeper search
+
+    # Move generation parameters
+    initial_move_dist = 0.08  # Max move distance at T_initial
+    # num_circles_to_move will now be adaptive, based on temperature.
+
+    current_centers = np.copy(centers)
+    best_centers = np.copy(centers)
+
+    # Pre-compute schedules for adaptive quick_solve parameters, inspired by Coordinate Ascent.
+    # These will provide smoother transitions for evaluation accuracy.
+    quick_iter_schedule = np.linspace(80, 250, max_steps, dtype=int)
+    quick_update_schedule = np.linspace(0.75, 0.55, max_steps)
+
+    # Initial energy calculation (Energy = -Sum of Radii)
+    # Use the adaptive compute_max_radii, but with constant factor for initial quick evaluation.
+    initial_quick_solve_iter = quick_iter_schedule[0]
+    initial_quick_solve_uf = quick_update_schedule[0]
+    current_radii = compute_max_radii(current_centers, iterations=initial_quick_solve_iter, 
+                                      update_factor=(initial_quick_solve_uf, initial_quick_solve_uf, 0.0))
+    current_energy = -np.sum(current_radii)
+    best_energy = current_energy
+
+    T = T_initial
+    step = 0
+
+    # 2. Annealing Loop
+    while T > T_final and step < max_steps:
+        # Generate a new candidate configuration
+        candidate_centers = np.copy(current_centers)
+        
+        # Anneal the move distance based on temperature for adaptive step size.
+        move_dist = initial_move_dist * (T / T_initial)**0.5
+
+        # Adaptive number of circles to move (crossover from another SA program)
+        if T > T_initial * 0.1:
+            num_circles_to_move = 4
+        elif T > T_initial * 0.01:
+            num_circles_to_move = 3
+        elif T > T_initial * 0.001:
+            num_circles_to_move = 2
+        else:
+            num_circles_to_move = 1
+
+        # Randomly pick a few circles to perturb for diverse exploration.
+        circles_to_move_indices = np.random.choice(n, num_circles_to_move, replace=False)
+        
+        # Create random move vectors and apply them.
+        move_vectors = np.random.uniform(-move_dist, move_dist, size=(num_circles_to_move, 2))
+        candidate_centers[circles_to_move_indices] += move_vectors
+        
+        # Clip all centers to ensure they stay within the unit square.
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+        
+        # Determine current quick_solve parameters from schedules for adaptive evaluation.
+        current_quick_solve_iter = quick_iter_schedule[step]
+        current_quick_solve_uf = quick_update_schedule[step]
+
+        # Calculate the energy of the new candidate using adaptive solver.
+        candidate_radii = compute_max_radii(candidate_centers, iterations=current_quick_solve_iter, 
+                                            update_factor=(current_quick_solve_uf, current_quick_solve_uf, 0.0))
+        candidate_energy = -np.sum(candidate_radii)
+
+        # Metropolis-Hastings acceptance criterion: allows "uphill" moves to escape local optima.
+        delta_E = candidate_energy - current_energy
+        if delta_E < 0 or np.random.rand() < np.exp(-delta_E / T):
+            current_centers = candidate_centers
+            current_energy = candidate_energy
+
+        # Update the best-ever found solution.
+        if current_energy < best_energy:
+            best_energy = current_energy
+            best_centers = np.copy(current_centers)
+        
+        # Cool down the temperature.
+        T *= alpha
+        step += 1
+
+    # 3. Finalization
+    # Run a final high-precision radius calculation on the best configuration found.
+    # Uses a sophisticated adaptive damping schedule for maximum accuracy and stability.
+    final_radii = compute_max_radii(best_centers, iterations=10000, update_factor=(0.65, 0.45, 0.25))
+    
+    return best_centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an adaptive damping schedule for the update factor.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Can be:
+                       - A single float: constant damping factor.
+                       - A tuple (initial_uf, final_uf, switch_ratio): adaptive damping.
+                         `initial_uf` is used at the start, decaying linearly to `final_uf`
+                         over `iterations * switch_ratio` steps, then `final_uf` for the rest.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    # Interpret update_factor parameter for adaptive damping.
+    if isinstance(update_factor, (float, int)):
+        initial_uf = float(update_factor)
+        final_uf = float(update_factor)
+        switch_ratio = 0.0 # No adaptive schedule if a single float is provided
+    else: # Expecting a tuple (initial_uf, final_uf, switch_ratio)
+        initial_uf, final_uf, switch_ratio = update_factor
+
+    for k in range(iterations):
+        radii_old = np.copy(radii)
+
+        # Determine current damping factor based on iteration progress and schedule.
+        current_uf = initial_uf
+        if switch_ratio > 0 and k < iterations * switch_ratio:
+            # Linear interpolation from initial_uf to final_uf over the switch_ratio duration
+            current_uf = initial_uf + (final_uf - initial_uf) * (k / (iterations * switch_ratio))
+        elif switch_ratio > 0 and k >= iterations * switch_ratio:
+            # After the switch point, use the final damping factor
+            current_uf = final_uf
+        # If switch_ratio is 0, current_uf remains initial_uf as initialized above.
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + current_uf * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_104/original.py

@@ -0,0 +1,185 @@
+# EVOLVE-BLOCK-START
+import numpy as np
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles using Simulated Annealing (SA),
+    enhanced with adaptive radius computation parameters, to find a high-quality packing.
+
+    Returns:
+        A tuple containing:
+        centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+        radii: np.array of shape (26) with the final radius of each circle
+    """
+    n = 26
+
+    # 1. Initial State and SA Parameters
+    # Start with a proven high-quality initial grid configuration (from prior successful programs).
+    centers = np.zeros((n, 2))
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+    # Perturbation to break symmetry, a key element from successful priors.
+    centers[25] = [0.39, 0.41]
+
+    # SA Parameters - tuned for thorough search.
+    T_initial = 0.01          # Initial temperature (allows large uphill moves)
+    T_final = 1e-7            # Final temperature (near deterministic local search)
+    alpha = 0.9998            # Cooling rate (slow, for deeper exploration)
+    max_steps = 150000        # Increased steps for more thorough annealing.
+
+    # Move generation parameters
+    initial_move_dist = 0.08  # Max move distance at T_initial
+    num_circles_to_move = 3   # Number of circles to perturb each step
+
+    current_centers = np.copy(centers)
+    best_centers = np.copy(centers)
+
+    # Pre-compute schedules for adaptive quick_solve parameters, inspired by Coordinate Ascent.
+    # These will provide smoother transitions for evaluation accuracy.
+    quick_iter_schedule = np.linspace(80, 250, max_steps, dtype=int)
+    quick_update_schedule = np.linspace(0.75, 0.55, max_steps)
+
+    # Initial energy calculation (Energy = -Sum of Radii)
+    # Use the adaptive compute_max_radii, but with constant factor for initial quick evaluation.
+    initial_quick_solve_iter = quick_iter_schedule[0]
+    initial_quick_solve_uf = quick_update_schedule[0]
+    current_radii = compute_max_radii(current_centers, iterations=initial_quick_solve_iter, 
+                                      update_factor=(initial_quick_solve_uf, initial_quick_solve_uf, 0.0))
+    current_energy = -np.sum(current_radii)
+    best_energy = current_energy
+
+    T = T_initial
+    step = 0
+
+    # 2. Annealing Loop
+    while T > T_final and step < max_steps:
+        # Generate a new candidate configuration
+        candidate_centers = np.copy(current_centers)
+        
+        # Anneal the move distance based on temperature for adaptive step size.
+        move_dist = initial_move_dist * (T / T_initial)**0.5
+
+        # Randomly pick a few circles to perturb for diverse exploration.
+        circles_to_move_indices = np.random.choice(n, num_circles_to_move, replace=False)
+        
+        # Create random move vectors and apply them.
+        move_vectors = np.random.uniform(-move_dist, move_dist, size=(num_circles_to_move, 2))
+        candidate_centers[circles_to_move_indices] += move_vectors
+        
+        # Clip all centers to ensure they stay within the unit square.
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+        
+        # Determine current quick_solve parameters from schedules for adaptive evaluation.
+        current_quick_solve_iter = quick_iter_schedule[step]
+        current_quick_solve_uf = quick_update_schedule[step]
+
+        # Calculate the energy of the new candidate using adaptive solver.
+        candidate_radii = compute_max_radii(candidate_centers, iterations=current_quick_solve_iter, 
+                                            update_factor=(current_quick_solve_uf, current_quick_solve_uf, 0.0))
+        candidate_energy = -np.sum(candidate_radii)
+
+        # Metropolis-Hastings acceptance criterion: allows "uphill" moves to escape local optima.
+        delta_E = candidate_energy - current_energy
+        if delta_E < 0 or np.random.rand() < np.exp(-delta_E / T):
+            current_centers = candidate_centers
+            current_energy = candidate_energy
+
+        # Update the best-ever found solution.
+        if current_energy < best_energy:
+            best_energy = current_energy
+            best_centers = np.copy(current_centers)
+        
+        # Cool down the temperature.
+        T *= alpha
+        step += 1
+
+    # 3. Finalization
+    # Run a final high-precision radius calculation on the best configuration found.
+    # Uses a sophisticated adaptive damping schedule for maximum accuracy and stability.
+    final_radii = compute_max_radii(best_centers, iterations=10000, update_factor=(0.65, 0.45, 0.25))
+    
+    return best_centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an adaptive damping schedule for the update factor.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Can be:
+                       - A single float: constant damping factor.
+                       - A tuple (initial_uf, final_uf, switch_ratio): adaptive damping.
+                         `initial_uf` is used at the start, decaying linearly to `final_uf`
+                         over `iterations * switch_ratio` steps, then `final_uf` for the rest.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    # Interpret update_factor parameter for adaptive damping.
+    if isinstance(update_factor, (float, int)):
+        initial_uf = float(update_factor)
+        final_uf = float(update_factor)
+        switch_ratio = 0.0 # No adaptive schedule if a single float is provided
+    else: # Expecting a tuple (initial_uf, final_uf, switch_ratio)
+        initial_uf, final_uf, switch_ratio = update_factor
+
+    for k in range(iterations):
+        radii_old = np.copy(radii)
+
+        # Determine current damping factor based on iteration progress and schedule.
+        current_uf = initial_uf
+        if switch_ratio > 0 and k < iterations * switch_ratio:
+            # Linear interpolation from initial_uf to final_uf over the switch_ratio duration
+            current_uf = initial_uf + (final_uf - initial_uf) * (k / (iterations * switch_ratio))
+        elif switch_ratio > 0 and k >= iterations * switch_ratio:
+            # After the switch point, use the final damping factor
+            current_uf = final_uf
+        # If switch_ratio is 0, current_uf remains initial_uf as initialized above.
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + current_uf * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END
+
+
+# This part remains fixed (not evolved)
+def run_packing():
+    """Run the circle packing constructor for n=26"""
+    centers, radii = construct_packing()
+    # Calculate the sum of radii
+    sum_radii = np.sum(radii)
+    return centers, radii, sum_radii

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_104/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_104/results/metrics.json

@@ -0,0 +1,25 @@
+{
+  "combined_score": 2.5368049435910565,
+  "correct": true,
+  "primary": {
+    "combined_score": 2.5368049435910565,
+    "public": {
+      "centers_str": "  centers[0] = (0.1099, 0.1236)\n  centers[1] = (0.0707, 0.3000)\n  centers[2] = (0.1128, 0.4787)\n  centers[3] = (0.0988, 0.6938)\n  centers[4] = (0.1037, 0.8962)\n  centers[5] = (0.3104, 0.0928)\n  centers[6] = (0.2609, 0.2991)\n  centers[7] = (0.2872, 0.5195)\n  centers[8] = (0.2879, 0.6832)\n  centers[9] = (0.3208, 0.8852)\n  centers[10] = (0.4911, 0.0880)\n  centers[11] = (0.4930, 0.2886)\n  centers[12] = (0.5326, 0.5010)\n  centers[13] = (0.4947, 0.7079)\n  centers[14] = (0.5188, 0.9104)\n  centers[15] = (0.7014, 0.1256)\n  centers[16] = (0.6840, 0.3343)\n  centers[17] = (0.7089, 0.4999)\n  centers[18] = (0.7335, 0.7044)\n  centers[19] = (0.6901, 0.9144)\n  centers[20] = (0.9125, 0.0874)\n  centers[21] = (0.8815, 0.2909)\n  centers[22] = (0.8961, 0.5141)\n  centers[23] = (0.9270, 0.6884)\n  centers[24] = (0.8865, 0.8823)\n  centers[25] = (0.3886, 0.4340)",
+      "num_circles": 26
+    },
+    "private": {
+      "reported_sum_of_radii": 2.5368049435910565
+    },
+    "execution_time_mean": 43.77116736583412,
+    "execution_time_std": 0.0,
+    "num_valid_runs": 1,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": true,
+    "validation_error": null
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770405697.9377902,
+  "generation": 104
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_104/rewrite.txt

@@ -0,0 +1,187 @@
+# EVOLVE-BLOCK-START
+import numpy as np
+
+def construct_packing():
+    """
+    Constructs an optimized arrangement of 26 circles using Simulated Annealing (SA),
+    enhanced with adaptive radius computation parameters, an adaptive move strategy,
+    and a longer cooling schedule to find a high-quality packing.
+
+    Returns:
+        A tuple containing:
+        centers: np.array of shape (26, 2) with the final optimized (x, y) coordinates
+        radii: np.array of shape (26) with the final radius of each circle
+    """
+    n = 26
+
+    # 1. Initial State and SA Parameters
+    # Start with a proven high-quality initial grid configuration (from prior successful programs).
+    centers = np.zeros((n, 2))
+    d = 0.09525
+    grid_coords = np.linspace(d, 1 - d, 5)
+    idx = 0
+    for x in grid_coords:
+        for y in grid_coords:
+            centers[idx] = [x, y]
+            idx += 1
+    # Perturbation to break symmetry, now with a small random component for diversity.
+    centers[25] = [0.39 + np.random.uniform(-0.01, 0.01), 0.41 + np.random.uniform(-0.01, 0.01)]
+
+    # SA Parameters - tuned for a longer, more thorough search (from a high-performing prior).
+    T_initial = 0.01          # Initial temperature (allows large uphill moves)
+    T_final = 1e-7            # Final temperature (near deterministic local search)
+    alpha = 0.99985           # Slower cooling rate for more steps
+    max_steps = 200000        # Increased steps for a deeper search
+
+    # Move generation parameters
+    initial_move_dist = 0.08  # Max move distance at T_initial
+    # num_circles_to_move will now be adaptive, based on temperature.
+
+    current_centers = np.copy(centers)
+    best_centers = np.copy(centers)
+
+    # Pre-compute schedules for adaptive quick_solve parameters, inspired by Coordinate Ascent.
+    # These will provide smoother transitions for evaluation accuracy.
+    quick_iter_schedule = np.linspace(80, 250, max_steps, dtype=int)
+    quick_update_schedule = np.linspace(0.75, 0.55, max_steps)
+
+    # Initial energy calculation (Energy = -Sum of Radii)
+    # Use the adaptive compute_max_radii, but with constant factor for initial quick evaluation.
+    initial_quick_solve_iter = quick_iter_schedule[0]
+    initial_quick_solve_uf = quick_update_schedule[0]
+    current_radii = compute_max_radii(current_centers, iterations=initial_quick_solve_iter, 
+                                      update_factor=(initial_quick_solve_uf, initial_quick_solve_uf, 0.0))
+    current_energy = -np.sum(current_radii)
+    best_energy = current_energy
+
+    T = T_initial
+    step = 0
+
+    # 2. Annealing Loop
+    while T > T_final and step < max_steps:
+        # Generate a new candidate configuration
+        candidate_centers = np.copy(current_centers)
+        
+        # Anneal the move distance based on temperature for adaptive step size.
+        move_dist = initial_move_dist * (T / T_initial)**0.5
+
+        # Adaptive number of circles to move (crossover from another SA program)
+        if T > T_initial * 0.1:
+            num_circles_to_move = 4
+        elif T > T_initial * 0.01:
+            num_circles_to_move = 3
+        elif T > T_initial * 0.001:
+            num_circles_to_move = 2
+        else:
+            num_circles_to_move = 1
+
+        # Randomly pick a few circles to perturb for diverse exploration.
+        circles_to_move_indices = np.random.choice(n, num_circles_to_move, replace=False)
+        
+        # Create random move vectors and apply them.
+        move_vectors = np.random.uniform(-move_dist, move_dist, size=(num_circles_to_move, 2))
+        candidate_centers[circles_to_move_indices] += move_vectors
+        
+        # Clip all centers to ensure they stay within the unit square.
+        candidate_centers = np.clip(candidate_centers, 0.0, 1.0)
+        
+        # Determine current quick_solve parameters from schedules for adaptive evaluation.
+        current_quick_solve_iter = quick_iter_schedule[step]
+        current_quick_solve_uf = quick_update_schedule[step]
+
+        # Calculate the energy of the new candidate using adaptive solver.
+        candidate_radii = compute_max_radii(candidate_centers, iterations=current_quick_solve_iter, 
+                                            update_factor=(current_quick_solve_uf, current_quick_solve_uf, 0.0))
+        candidate_energy = -np.sum(candidate_radii)
+
+        # Metropolis-Hastings acceptance criterion: allows "uphill" moves to escape local optima.
+        delta_E = candidate_energy - current_energy
+        if delta_E < 0 or np.random.rand() < np.exp(-delta_E / T):
+            current_centers = candidate_centers
+            current_energy = candidate_energy
+
+        # Update the best-ever found solution.
+        if current_energy < best_energy:
+            best_energy = current_energy
+            best_centers = np.copy(current_centers)
+        
+        # Cool down the temperature.
+        T *= alpha
+        step += 1
+
+    # 3. Finalization
+    # Run a final high-precision radius calculation on the best configuration found.
+    # Uses a sophisticated adaptive damping schedule for maximum accuracy and stability.
+    final_radii = compute_max_radii(best_centers, iterations=10000, update_factor=(0.65, 0.45, 0.25))
+    
+    return best_centers, final_radii
+
+
+def compute_max_radii(centers, iterations=5000, update_factor=(0.6, 0.6, 0.0)):
+    """
+    Computes maximum radii using a fast, vectorized, damped Jacobi-style solver.
+    This version supports an adaptive damping schedule for the update factor.
+
+    Args:
+        centers: np.array of shape (n, 2) with (x, y) coordinates.
+        iterations: The number of relaxation iterations to perform.
+        update_factor: Can be:
+                       - A single float: constant damping factor.
+                       - A tuple (initial_uf, final_uf, switch_ratio): adaptive damping.
+                         `initial_uf` is used at the start, decaying linearly to `final_uf`
+                         over `iterations * switch_ratio` steps, then `final_uf` for the rest.
+
+    Returns:
+        np.array of shape (n) with the radius of each circle.
+    """
+    n = centers.shape[0]
+    # Small non-zero start to prevent issues on the first iteration.
+    radii = np.full(n, 1e-6)
+
+    # Pre-calculate distances between centers.
+    dist_matrix = np.sqrt(((centers[:, np.newaxis, :] - centers[np.newaxis, :, :])**2).sum(axis=2))
+    # Set diagonal to infinity so a circle isn't constrained by itself.
+    np.fill_diagonal(dist_matrix, np.inf)
+
+    # Pre-calculate wall distances for all circles.
+    wall_dists = np.min(np.hstack([centers, 1.0 - centers]), axis=1)
+
+    # Interpret update_factor parameter for adaptive damping.
+    if isinstance(update_factor, (float, int)):
+        initial_uf = float(update_factor)
+        final_uf = float(update_factor)
+        switch_ratio = 0.0 # No adaptive schedule if a single float is provided
+    else: # Expecting a tuple (initial_uf, final_uf, switch_ratio)
+        initial_uf, final_uf, switch_ratio = update_factor
+
+    for k in range(iterations):
+        radii_old = np.copy(radii)
+
+        # Determine current damping factor based on iteration progress and schedule.
+        current_uf = initial_uf
+        if switch_ratio > 0 and k < iterations * switch_ratio:
+            # Linear interpolation from initial_uf to final_uf over the switch_ratio duration
+            current_uf = initial_uf + (final_uf - initial_uf) * (k / (iterations * switch_ratio))
+        elif switch_ratio > 0 and k >= iterations * switch_ratio:
+            # After the switch point, use the final damping factor
+            current_uf = final_uf
+        # If switch_ratio is 0, current_uf remains initial_uf as initialized above.
+
+        # Calculate all potential radii based on other circles in a vectorized way.
+        potential_r_circles = np.min(dist_matrix - radii_old, axis=1)
+
+        # Combine with wall constraints.
+        potential_r = np.minimum(wall_dists, potential_r_circles)
+
+        # New radii for this iteration (must be non-negative).
+        new_r = np.maximum(0.0, potential_r)
+
+        # Dampen the update to prevent oscillations.
+        radii = radii_old + current_uf * (new_r - radii_old)
+
+        # Early exit condition if radii have converged.
+        if np.max(np.abs(radii - radii_old)) < 1e-9:
+            break
+
+    return radii
+# EVOLVE-BLOCK-END

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_105/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": false,
+    "error": "operands could not be broadcast together with shapes (3,) (26,) "
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_105/results/metrics.json

@@ -0,0 +1,19 @@
+{
+  "combined_score": 0.0,
+  "correct": false,
+  "primary": {
+    "combined_score": 0.0,
+    "execution_time_mean": 0.0,
+    "execution_time_std": 0.0,
+    "num_successful_runs": 0,
+    "num_valid_runs": 0,
+    "num_invalid_runs": 0,
+    "all_validation_errors": [],
+    "correct": false,
+    "validation_error": "operands could not be broadcast together with shapes (3,) (26,) "
+  },
+  "auxiliary": {},
+  "auxiliary_descriptions": {},
+  "timestamp": 1770405677.2668953,
+  "generation": 105
+}

examples_deprecated/circle_packing/results/results_full_gen200_period1000_20260206_165141/gen_106/results/correct.json

@@ -0,0 +1,4 @@
+{
+    "correct": true,
+    "error": null
+}