### Install Dependencies

Source: https://github.com/lucidrains/nim-genetic-algorithm/blob/main/Readme.md

Install the required malebolgia package using the nimble package manager.

```bash
$ nimble install malebolgia
```

--------------------------------

### Initialize Population Configuration

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Define the target goal and mutation parameters for a genetic algorithm population.

```nim
let mutator = MutateOperatorRef(
  kind: FastMutateOperator,
  beta: 1.2
)

let population = PopulationRef(
  goal: "Attention is all you need",
  size: 25,                  # 25 individuals per generation
  keep_fittest_frac: 0.25,   # Keep top 25% (6-7 individuals)
  mutate_prob: 0.9,          # 90% chance to mutate each gene
  mutate_operator: mutator
)
```

--------------------------------

### Run Genetic Algorithm

Source: https://github.com/lucidrains/nim-genetic-algorithm/blob/main/Readme.md

Compile and execute the genetic algorithm with thread pool configuration and release optimizations.

```bash
$ nim c -d:ThreadPoolSize=8 -d:release -r ga.nim
```

--------------------------------

### Execute Evolution Cycle

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Define the next_generation procedure to handle selection, crossover, mutation, and parallel fitness evaluation, followed by a loop to run the evolution.

```nim
proc next_generation(pop: PopulationRef) =
  if pop.solved:
    return
  if pop.generation == 0:
    init_population(pop)  # Initialize random genes on first call
  pop.keep_fittest()      # Select fittest individuals
  pop.breed_fittest()     # Crossover to restore population size
  # Apply mutation
  for gene in pop.pool:
    if rand(1.0) < pop.mutate_prob:
      pop.mutate_operator.mutate(gene)
  # Parallel fitness calculation using Malebolgia
  var master = create_master()
  var costs = new_seq[int](pop.pool.len)
  master.await_all:
    for i in 0..<pop.pool.len:
      master.spawn calc_cost(pop.pool[i].code, pop.goal) -> costs[i]
  for i in 0..<pop.pool.len:
    pop.pool[i].cost = costs[i]
  pop.sort_by_fitness()
  pop.solved = pop.pool[0].cost == 0
  pop.generation += 1

# Run until solved
let population = PopulationRef(
  goal: "Hello World",
  size: 25,
  keep_fittest_frac: 0.25,
  mutate_prob: 0.9,
  mutate_operator: MutateOperatorRef(kind: FastMutateOperator, beta: 1.2)
)

while not population.solved:
  population.next_generation()

echo "Solved in ", population.generation, " generations"
echo "Best gene: ", population.pool[0].code  # "Hello World"
```

--------------------------------

### Run Multiple Evolution Trials

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Execute multiple trials to calculate the average number of generations required to reach the target solution.

```nim
# Compile and run with:
# nim c -d:ThreadPoolSize=8 -d:release -r ga.nim

import malebolgia
import std/[math, random, strformat]

randomize()

proc main() =
  let trials = 100
  let use_fast_mutate = true
  var avg_generation = 0.0

  var mutate_operator: MutateOperatorRef

  if use_fast_mutate:
    mutate_operator = MutateOperatorRef(
      kind: FastMutateOperator,
      beta: 1.2
    )
  else:
    mutate_operator = MutateOperatorRef(
      kind: DefaultMutateOperator,
      mutate_rate: 0.1
    )

  for trial in 1..trials:
    let population = PopulationRef(
      goal: "Attention is all you need",
      size: 25,
      keep_fittest_frac: 0.25,
      mutate_prob: 0.9,
      mutate_operator: mutate_operator
    )

    while not population.solved:
      population.next_generation()

    avg_generation += population.generation / trials
    echo &"trial {trial} completed at generation {population.generation}"

  echo &"average generation: {avg_generation.int}"

# Output:
# trial 1 completed at generation 1247
# trial 2 completed at generation 1089
# ...
# trial 100 completed at generation 1156
# average generation: 1134
```

--------------------------------

### Initialize Gene Type and Random Code

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Defines the Gene object structure and demonstrates initializing a gene with random ASCII characters.

```nim
type
  Gene = object
    code: string
    cost: int = 1e7.int
  GeneRef = ref Gene

# Create a new gene and initialize with random characters
let gene = GeneRef()
gene.init_random_code(27)  # Length matches "Attention is all you need"

echo gene.code  # Random string like "kX#9@mP..."
echo gene.cost  # 10000000 (initial high cost)
```

--------------------------------

### Citation

Source: https://github.com/lucidrains/nim-genetic-algorithm/blob/main/Readme.md

BibTeX citation for the Fast Genetic Algorithms research paper.

```bibtex
@misc{doerr2017fastgeneticalgorithms,
  title   = {Fast Genetic Algorithms}, 
  author  = {Benjamin Doerr and Huu Phuoc Le and Régis Makhmara and Ta Duy Nguyen},
  year    = {2017},
  eprint  = {1703.03334},
  archivePrefix = {arXiv},
  primaryClass = {cs.NE},
  url     = {https://arxiv.org/abs/1703.03334}, 
}
```

--------------------------------

### Perform Gene Recombination with mate

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Executes single-point crossover between two parent genes at a random pivot point.

```nim
proc mate(gene1, gene2: GeneRef): GeneRef =
  assert gene1.code.len == gene2.code.len
  let pivot = rand(1..(gene1.code.len - 2))
  let new_code = gene1.code[0..<pivot] & gene2.code[pivot..^1]
  return GeneRef(code: new_code)

# Example crossover
let parent1 = GeneRef(code: "AAAAAAAAAA")
let parent2 = GeneRef(code: "BBBBBBBBBB")
let child = mate(parent1, parent2)

echo child.code  # e.g., "AAAABBBBBB" (pivot at position 4)
```

--------------------------------

### Configure Mutation Operators

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Implements Default and Fast mutation strategies. The fast mutator uses a power law distribution for mutation length sampling.

```nim
type
  MutateOperatorType = enum
    DefaultMutateOperator,
    FastMutateOperator

  MutateOperator = object
    gene_length: int = 0
    case kind: MutateOperatorType
      of DefaultMutateOperator:
        mutate_rate: float = 0.1
      of FastMutateOperator:
        beta: float = 1.5
        power_law: seq[float]

# Default mutation operator - fixed 10% mutation rate per character
let defaultMutator = MutateOperatorRef(
  kind: DefaultMutateOperator,
  mutate_rate: 0.1
)

# Fast mutation operator - power law distribution with beta parameter
let fastMutator = MutateOperatorRef(
  kind: FastMutateOperator,
  beta: 1.2  # Controls mutation length distribution
)

# Initialize the operator with gene length
fastMutator.init(27)

# Apply mutation to a gene
let gene = GeneRef(code: "Attention is all you need")
fastMutator.mutate(gene)
echo gene.code  # Mutated string with some characters changed by +/-1
```

--------------------------------

### Calculate Fitness with calc_cost

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Computes fitness by calculating the sum of squared differences between character ordinals. A cost of 0 indicates a perfect match.

```nim
func calc_cost(code: string, goal: string): int =
  assert len(code) == len(goal)
  var cost: int = 0
  for i in 0..<len(goal):
    let diff: int = goal[i].ord - code[i].ord
    cost += pow(diff.float, 2).int
  return cost

# Example usage
let goal = "Hello"
let code1 = "Hello"
let code2 = "Hfllo"
let code3 = "Xxxxx"

echo calc_cost(code1, goal)  # 0 (perfect match)
echo calc_cost(code2, goal)  # 1 (one character off by 1)
echo calc_cost(code3, goal)  # Large number (very different)
```

--------------------------------

### Define Population Configuration

Source: https://context7.com/lucidrains/nim-genetic-algorithm/llms.txt

Defines the Population object structure for managing gene pools and evolution parameters.

```nim
type
  Population = object
    size: int                      # Number of individuals
    pool: seq[GeneRef]             # Gene pool
    goal: string                   # Target string to evolve toward
    generation: int                # Current generation count
    keep_fittest_frac: float       # Fraction of fittest to keep (0.0-1.0)
    solved: bool                   # True when goal is reached
    mutate_prob: float             # Probability of mutation per gene
    mutate_operator: MutateOperatorRef
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.