Adapting TTT-Discover Initial Program and Prompt for OpenEvolve (Erdős Problem)

[passing2961]

Hi,

I am currently focusing on the Erdős problem, and I noticed that the initial_program and prompt template used in TTT-Discover (https://github.com/test-time-training/discover/blob/main/examples/erdos_min_overlap/env.py) are different from those in OpenEvolve. For example, OpenEvolve’s initial program uses JAX, whereas TTT-Discover does not.

I would like to run the TTT-Discover-style version within the OpenEvolve framework. Do you have any tips or suggestions on how I could best adapt or integrate it?

[codelion]

Hi @passing2961, thanks for the great question!

I took help from @claude to do a breakdown of the key differences and how to adapt:

Key Differences

1. JAX/Optax vs. pure NumPy/SciPy

Our current OpenEvolve example (initial_program.py) uses JAX + optax for gradient-based optimization with sigmoid parameterization. The TTT-Discover version allows the LLM to generate code using any of numpy, scipy, cvxpy, math, etc. without requiring JAX at all.

2. Code evolution vs. code generation

OpenEvolve evolves a fixed initial program (marked with EVOLVE-BLOCK-START/END). TTT-Discover generates fresh code each iteration, passing in the best construction found so far via an initial_h_values global variable. This means the LLM can try completely different algorithmic strategies between iterations rather than incrementally modifying one approach.

3. Construction passing

TTT-Discover uses an explicit State with a construction field that carries the best h_values found so far into the next generation's prompt. This is powerful because the LLM can refine a known-good construction while also being free to start from scratch.

4. Prompt detail

The TTT-Discover prompt is significantly more detailed - it specifies time budgets, available libraries, the exact discretization scheme, and a run(seed=42, budget_s=1000) function signature that's more flexible than the rigid class-based structure in our example.

How to Adapt

The simplest way to run a TTT-Discover-style version within OpenEvolve:

Step 1: Replace initial_program.py with a pure NumPy version

# EVOLVE-BLOCK-START
import numpy as np
from scipy.optimize import minimize


def run():
    """
    Optimize step function h: [0,2] -> [0,1] to minimize C5 upper bound.
    Returns (h_values, c5_bound, n_points)
    """
    n_points = 200
    dx = 2.0 / n_points

    # Start with a simple symmetric construction
    h = np.ones(n_points) * 0.5

    def objective(h_flat):
        h_vals = np.clip(h_flat, 0, 1)
        # Enforce integral constraint via normalization
        target_sum = n_points / 2.0
        h_vals = h_vals * (target_sum / (np.sum(h_vals) + 1e-12))
        h_vals = np.clip(h_vals, 0, 1)

        j_vals = 1.0 - h_vals
        correlation = np.correlate(h_vals, j_vals, mode="full") * dx
        return np.max(correlation)

    result = minimize(
        objective,
        h,
        method='L-BFGS-B',
        bounds=[(0, 1)] * n_points,
        options={'maxiter': 5000}
    )

    h_opt = np.clip(result.x, 0, 1)
    target_sum = n_points / 2.0
    h_opt = h_opt * (target_sum / (np.sum(h_opt) + 1e-12))
    h_opt = np.clip(h_opt, 0, 1)

    j_opt = 1.0 - h_opt
    correlation = np.correlate(h_opt, j_opt, mode="full") * dx
    c5_bound = float(np.max(correlation))

    return h_opt, c5_bound, n_points

# EVOLVE-BLOCK-END

Step 2: Update the system prompt in config.yaml to match the more detailed TTT-Discover-style prompt:

prompt:
  system_message: |
    You are an expert in harmonic analysis, numerical optimization, and mathematical discovery.
    Your task is to find an improved upper bound for the Erdős minimum overlap problem constant C₅.

    Find a step function h: [0, 2] → [0, 1] that minimizes:
      C₅ = max_k ∫ h(x)(1 - h(x+k)) dx

    Constraints:
    1. h(x) ∈ [0, 1] for all x
    2. ∫₀² h(x) dx = 1

    Discretization: Represent h as n_points samples over [0, 2].
    With dx = 2.0 / n_points: sum(h) * dx = 1

    The evaluation computes: C₅ = max(np.correlate(h, 1-h, mode="full") * dx)

    You may use numpy, scipy, or other standard optimization libraries.
    Lower C₅ values are better. Current record: C₅ ≤ 0.38092.

    The `run()` function must return (h_values, c5_bound, n_points).
    Try fundamentally different optimization strategies between iterations:
    multi-start local search, genetic algorithms, simulated annealing,
    convex relaxations, Fourier-based methods, or hybrid approaches.

Step 3: The evaluator can stay the same - it already validates solutions correctly using pure NumPy and the same verification logic that TTT-Discover uses.

This should give you a much more flexible starting point that allows OpenEvolve to explore diverse algorithmic strategies, similar to what TTT-Discover does. The key insight from their approach is that removing JAX as a hard dependency opens up the search space considerably.

[passing2961]

@codelion Thank you for very detailed response. As you said, it seems that TTT-discover generates fresh program at every iteration which is similar to "full rewrite" mutation approach in OpenEvolve. In addition, compared to OpenEvolve which uses multiple top programs and inspiration programs from archive in order to construct the next input prompt, TTT-Discover only uses top-2 programs (or top-2 initial h values, well I need to check more about this). So, now I am try to set up the config.yaml as follows:

# Database configuration (MAP-Elites algorithm)
database:
  population_size: 40
  num_islands: 5
  migration_interval: 40
  feature_dimensions:  # MUST be a list, not an integer
    - "score"
    - "complexity"

# Prompt configuration
prompt:
  system_message: |
    You are an expert in harmonic analysis, numerical optimization, and mathematical discovery.
    Your task is to find an improved upper bound for the Erdős minimum overlap problem constant C₅.

    Find a step function h: [0, 2] → [0, 1] that minimizes:
      C₅ = max_k ∫ h(x)(1 - h(x+k)) dx

    Constraints:
    1. h(x) ∈ [0, 1] for all x
    2. ∫₀² h(x) dx = 1

    Discretization: Represent h as n_points samples over [0, 2].
    With dx = 2.0 / n_points: sum(h) * dx = 1

    The evaluation computes: C₅ = max(np.correlate(h, 1-h, mode="full") * dx)

    You may use numpy, scipy, or other standard optimization libraries.
    Lower C₅ values are better. Current record: C₅ ≤ 0.38092.

    The `run()` function must return (h_values, c5_bound, n_points).
    Try fundamentally different optimization strategies between iterations:
    multi-start local search, genetic algorithms, simulated annealing,
    convex relaxations, Fourier-based methods, or hybrid approaches.
    
  num_top_programs: 2
  num_diverse_programs: 0

# Logging
log_level: "INFO"


# Evolution trace configuration
# Logs detailed traces of program evolution for RL training and analysis
evolution_trace:
  enabled: true                      # Enable evolution trace logging
  format: 'json'                     # Output format: 'jsonl', 'json', or 'hdf5'
  include_code: true                 # Include full program code in traces
  include_prompts: true               # Include prompts and LLM responses
  output_path: "evolution_trace.json"                   # Path for trace output (defaults to output_dir/evolution_trace.{format})
  buffer_size: 10                     # Number of traces to buffer before writing
  compress: false                     # Compress output file (jsonl only)

Keep the database setting, but only changes num_top_programs (3 -> 2) and num_diverse_programs (2 -> 0). For keep similar setting with TTT-Discover as much as possible. Would it be okay? May I know your opinion?

By the way, I sent an email to you regarding "research collaboration".