[Results] Function Minimization: Adaptive Hybrid Search achieves 0.9997 score

[eilamt]

Hey everyone! 👋

I'm new to OpenEvolve and just ran the function minimization example as my first experiment. I wanted to share my results because I got a different (and slightly better!) algorithm than what's documented in the README.

My Setup

• Example: function_minimization
• Iterations: 50
• LLM: Google Gemini (free tier)
• Python: 3.11

Results Comparison

Metric	README (Simulated Annealing)	My Result (Adaptive Hybrid)
Value Score	0.990	0.9997

The Evolved Algorithm

Instead of discovering Simulated Annealing (as shown in the README), OpenEvolve found a different approach - an Adaptive Hybrid Search with three search modes:

def search_algorithm(iterations=1000, bounds=(-5, 5)):
    # Initialize with a random point
    best_x = np.random.uniform(bounds[0], bounds[1])
    best_y = np.random.uniform(bounds[0], bounds[1])
    best_value = evaluate_function(best_x, best_y)

    # Parameters for hybrid search
    min_b, max_b = bounds
    search_range = max_b - min_b
    initial_local_search_prob = 0.8
    initial_step_scale = 0.1
    min_step_scale = 0.005
    global_jump_frequency = 10

    for i in range(iterations):
        x_candidate, y_candidate = best_x, best_y

        # Adaptive probability: decreases over time
        local_search_prob = max(0.1, initial_local_search_prob * (1 - i / iterations))
        rand_decision = np.random.rand()

        if rand_decision < local_search_prob and i % global_jump_frequency != 0:
            # MODE 1: Local Gaussian perturbation
            current_step_scale = max(min_step_scale, initial_step_scale * (1 - i / iterations)) * search_range
            x_candidate = np.clip(x_candidate + np.random.normal(0, current_step_scale), min_b, max_b)
            y_candidate = np.clip(y_candidate + np.random.normal(0, current_step_scale), min_b, max_b)
        else:
            if rand_decision < local_search_prob + 0.1:
                # MODE 2: Full random jump
                x_candidate = np.random.uniform(min_b, max_b)
                y_candidate = np.random.uniform(min_b, max_b)
            else:
                # MODE 3: Controlled wider jump from best point
                jump_step = search_range * 0.5 * (1 - i / iterations)
                x_candidate = np.clip(best_x + np.random.uniform(-jump_step, jump_step), min_b, max_b)
                y_candidate = np.clip(best_y + np.random.uniform(-jump_step, jump_step), min_b, max_b)

        value = evaluate_function(x_candidate, y_candidate)
        if value < best_value:
            best_value = value
            best_x, best_y = x_candidate, y_candidate

    return best_x, best_y, best_value
    
    
    Key Differences from the Documented SA Algorithm
    =======================================
  
Here is a comparison of both approaches:   
README (Simulated Annealing):

Accepts worse solutions: Yes (temperature-based)
Search modes: Single mode
Local search type: Uniform random
Escape local minima: Probabilistic uphill moves

My Result (Adaptive Hybrid):

Accepts worse solutions: No (greedy)
Search modes: Three modes
Local search type: Gaussian perturbation
Escape local minima: Scheduled global jumps every 10 iterations
Observations
Different but effective: My algorithm doesn't use temperature or accept worse solutions, but compensates with forced global jumps every 10 iterations. 

Three search modes: Local Gaussian, full random, and controlled jumps provide flexibility.

Greedy works here: Despite being greedy (only accepting improvements), it still found a better solution!

Questions for the Community: 

Has anyone else gotten different algorithms from the function minimization example?
Is there interest in collecting/comparing evolved algorithms from different runs?
Would it be valuable to add a "community results" section to the README?
Thanks for building this awesome project! Looking forward to trying more examples.