Symbolic Equation

# LLM-SR Patterns

Extracted from LLM-SR codebase (llmsr/pipeline.py, sampler.py, buffer.py, evaluator.py, config.py).

## LLM Instruction Prompt

```
You are a helpful assistant tasked with discovering mathematical function structures for scientific systems. Complete the 'equation' function below, considering the physical meaning and relationships of inputs.
```

## Multi-Island Evolutionary Algorithm

### Architecture Overview
```
Pipeline:
  ├── ExperienceBuffer (multi-island)
  │   ├── Island 0 → Clusters → Programs
  │   ├── Island 1 → Clusters → Programs
  │   ├── ...
  │   └── Island N → Clusters → Programs
  ├── Samplers (parallel LLM callers)
  │   └── get_prompt() → LLM → draw_samples()
  └── Evaluators (parallel execution)
      └── analyse(sample) → score → register()
```

### Main Loop (sampler.py)
```python
def sample(self):
    """Continuously gets prompts, samples programs, sends them for analysis."""
    while True:
        if self._max_sample_nums and self._global_samples_nums >= self._max_sample_nums:
            break

        prompt = self._database.get_prompt()
        samples = self._llm.draw_samples(prompt.code, self.config)

        for sample in samples:
            chosen_evaluator = np.random.choice(self._evaluators)
            chosen_evaluator.analyse(
                sample, prompt.island_id, prompt.version_generated)
```

## Prompt Construction (buffer.py)

### Versioned Function Sequence
Programs from an island are formatted as an improving sequence:

```python
def equation_v0(x, v, params):
    """Describe the acceleration of a damped oscillator."""
    return params[0] * x

def equation_v1(x, v, params):
    """Improved version of equation_v0."""
    return params[0] * x + params[1] * v

def equation_v2(x, v, params):
    """Improved version of equation_v1."""
    return params[0] * x + params[1] * v + params[2] * x**2

def equation_v3(x, v, params):
    """Improved version of equation_v2."""
    # LLM completes this
```

### Cluster-Based Selection
```python
def get_prompt(self):
    """Constructs prompt from island clusters."""
    signatures = list(self._clusters.keys())
    cluster_scores = np.array(
        [self._clusters[sig].score for sig in signatures])

    # Temperature-scheduled softmax
    period = self._cluster_sampling_temperature_period
    temperature = self._cluster_sampling_temperature_init * (
        1 - (self._num_programs % period) / period)
    probabilities = _softmax(cluster_scores, temperature)

    # Sample clusters weighted by score
    functions_per_prompt = min(len(self._clusters), self._functions_per_prompt)
    idx = np.random.choice(len(signatures), size=functions_per_prompt, p=probabilities)

    # Sort by score ascending (worst to best)
    implementations = [self._clusters[signatures[i]].sample_program() for i in idx]
    indices = np.argsort([self._clusters[signatures[i]].score for i in idx])
    sorted_implementations = [implementations[i] for i in indices]

    return self._generate_prompt(sorted_implementations)
```

## Softmax Sampling (buffer.py)

```python
def _softmax(logits, temperature):
    """Returns tempered softmax of 1D finite logits."""
    if not np.all(np.isfinite(logits)):
        raise ValueError(f'logits contains non-finite values')
    result = scipy.special.softmax(logits / temperature, axis=-1)
    # Fix numerical precision: ensure probabilities sum to 1
    index = np.argmax(result)
    result[index] = 1 - np.sum(result[0:index]) - np.sum(result[index + 1:])
    return result
```

### Within-Cluster Sampling (Shorter Programs Preferred)
```python
def sample_program(self):
    """Samples a program, giving higher probability to shorter programs."""
    normalized_lengths = (np.array(self._lengths) - min(self._lengths)) / (
        max(self._lengths) + 1e-6)
    probabilities = _softmax(-normalized_lengths, temperature=1.0)
    return np.random.choice(self._programs, p=probabilities)
```

## Island Reset Mechanism (buffer.py)

```pyth