Genetic algorithms: population, crossover, mutation and selection on a backpack for a hike

Genome and fitness, tournament selection, one-point crossover, mutation and elitism, the schema theorem and premature convergence — on a knapsack problem with a known optimum, from the tent to FunSearch and AlphaEvolve.

14 minutes Matěj Žalmánek 2026-10-15

Series AI basics Part 27 of 52

1. Map of artificial intelligence: what is what and how it all fits together
2. A brief history of artificial intelligence: from Turing to language models
3. Data, model, training, inference: the basic terms on a single example
4. How to read mathematical notation: symbols, indices, sums and quantifiers
5. Sets and relations: the building blocks of definitions in AI
6. Functions and mappings: why every AI model is a function
7. Logic and proofs: the rules AI reasons by
8. Graphs and trees: the structure that both search and neural networks stand on
9. Linear algebra for machine learning: vectors, matrices and why AI mostly multiplies
10. Derivatives, the gradient and the chain rule: how a model finds out which way to learn
11. Gradient descent: how a model learns
12. What probability is: from rolling dice to the Kolmogorov axioms
13. Conditional probability and Bayes’ theorem: how to update your estimate when you learn something new
14. Random variables and the cumulative distribution function: one function that tells you everything about a distribution
15. Probability density and probability mass functions: why a continuous variable has zero probability at a point
16. Expected value, variance and covariance: where a distribution lies, how wide it is and what goes with what
17. Overview of probability distributions: Bernoulli, binomial, Poisson, uniform, normal and exponential
18. Law of large numbers and central limit theorem: why averages behave so predictably
19. Statistics and parameter estimation: maximum likelihood, MAP and confidence intervals
20. Information theory: entropy, cross-entropy and KL divergence — where loss functions come from
21. State-space search: BFS, DFS, UCS and A* with animations
22. Games and adversaries: minimax, alpha-beta pruning and Monte Carlo tree search
23. Constraint satisfaction: backtracking, constraint propagation and AC-3 on sudoku and a map of Czech regions
24. Logic and knowledge systems: forward and backward chaining, resolution and expert systems
25. Planning: STRIPS, the blocks world, heuristics from relaxation and planning in AI agents
26. Local search and simulated annealing: a travelling salesman through the Czech regional capitals
27. Genetic algorithms: population, crossover, mutation and selection on a backpack for a hike
28. Evolution strategies and genetic programming: from the one-fifth rule to Kepler’s law
29. Ant colony optimization: how a pheromone trail finds a short path
30. Particle swarm optimisation: inertia, personal experience and the swarm’s experience
31. Neuroevolution: evolving the weights and shape of neural networks, and the NEAT algorithm
32. Fuzzy sets and membership functions: how to write down “somewhat warm”
33. Fuzzy logic and probability: why “somewhat warm” does not mean “probably warm”
34. Fuzzy logic: t-norms, implications and IF–THEN rules
35. Fuzzy control: Mamdani and Sugeno from a fan to a pole on a cart
36. Fuzzy clustering: the fuzzy c-means algorithm and points between clusters
37. Neuro-fuzzy systems (ANFIS): fuzzy rules that learn from data
38. Markov chains: the transition matrix, the stationary distribution and PageRank
39. Hidden Markov models: the Viterbi algorithm and the dishonest casino
40. Bayesian networks: why the grass is wet and what it means for the sprinkler
41. The Kalman filter: how to estimate where a car is and how fast it goes from imprecise measurements
42. Types of machine learning: supervised, unsupervised, semi-supervised and more
43. Prompts, context and RAG: how to give a model the right information
44. Variational autoencoders (VAE): new images from a continuous latent space
45. Generative adversarial networks (GAN): the forger versus the detective
46. Diffusion models: how pure noise becomes an image
47. Markov decision processes: states, actions, rewards and the Bellman equations
48. Q-learning and DQN: learning the value of actions, from a table to a neural network
49. Policy gradient and PPO: learning the policy directly
50. How an AI agent works: a language model in a loop with tools
51. Programming with AI agents: the task, tests and review
52. Evaluating and securing AI systems: how to measure and how to keep watch

Full series syllabus 52 of 83 topics published

Nature has no engineer, and yet it produced the eye, the wing and the brain. Three things were enough: individuals differ from one another, they pass their traits on to their offspring, and the fitter ones have more offspring. In the 1970s John Holland of the University of Michigan showed that the same three things work in a computer too — as a general method for finding good solutions to problems we do not know how to solve cleverly. A genetic algorithm needs no gradient and no formula; all it needs is to be able to say which of two solutions is better.

It follows on from the part Local search and simulated annealing. Annealing improved a single solution; a genetic algorithm improves a whole population of them at once.

1. The problem: a backpack for a hike

You are getting ready for a hike of several days. At home you have 24 things — a tent, a sleeping bag, a stove, a camera, a book… — and each of them weighs something and is good for something. The backpack may weigh at most 10 kg. What should you take so that the usefulness is as large as possible?

Definition — the (0/1) knapsack problem

Let n ∈ ℕ, n ≥ 1, be the number of items, w₁, …, w_n > 0 their weights, u₁, …, u_n > 0 their values and W > 0 the capacity of the backpack. We write a selection of items as a vector x = (x₁, …, x_n) ∈ {0, 1}ⁿ, where x_i = 1 if and only if we take the i-th item. A selection x is feasible if and only if ∑_i=1ⁿ w_ix_i ≤ W. The (0/1) knapsack problem is the problem of finding

x* ∈ argmax { ∑_i=1ⁿ u_ix_i : x ∈ {0, 1}ⁿ,  ∑_i=1ⁿ w_ix_i ≤ W }.

So we look for a feasible selection with the largest total value; the “0/1” in the name means that each item can be taken only whole and at most once.

For integer weights the optimum can be computed exactly by dynamic programming — with all 24 items and a capacity of 1,000 decagrams (1 dag = 10 g) it takes 24,000 steps. The best backpack has 727 points of value and weighs 9.9 kg; the extra food, the camera, the book, the sandals and the sunscreen stay at home. Thanks to that we will see exactly how close evolution gets. A genetic algorithm, however, is useful mainly where no such exact method exists.

Dynamic programming fills in a table T[i][c] — the best value that can be reached using only the first i items when they may weigh at most c. Every cell is computed from the row above it:

T[i][c] = max( T[i − 1][c] , T[i − 1][c − w_i] + u_i )

T[i][c]

the best value from the first i items with capacity c; the cell T[n][W] is the answer to the whole problem

T[i − 1][c]

the option “I leave the i-th item” — then the best is whatever could be put together from the previous items with the same capacity

T[i − 1][c − w_i]

the option “I take it” — the item takes up w_i, so only c − w_i is left for the rest; the best use of the remainder is already in the table (allowed only for c ≥ w_i)

u_i

the value of the item we packed in that second option

Example — the table for four items and a capacity of 50 dag

A headlamp (10 dag, 25 points), a knife (10 dag, 18), a stove (40 dag, 30) and a sleeping mat (50 dag, 45). All the weights are multiples of ten, so columns in steps of 10 dag are enough:

items	c = 0	10	20	30	40	50
none	0	0	0	0	0	0
+ headlamp	0	25	25	25	25	25
+ knife	0	25	43	43	43	43
+ stove	0	25	43	43	43	55
+ sleeping mat	0	25	43	43	43	55

Knife, c = 20: T[2][20] = max(T[1][20], T[1][10] + 18) = max(25, 25 + 18) = 43

Stove, c = 40: T[3][40] = max(T[2][40], T[2][0] + 30) = max(43, 0 + 30) = 43 — the stove is not worth it

Stove, c = 50: T[3][50] = max(T[2][50], T[2][10] + 30) = max(43, 25 + 30) = 55 — the stove and the headlamp

Sleeping mat, c = 50: T[4][50] = max(T[3][50], T[3][0] + 45) = max(55, 0 + 45) = 55

(Colours as in the formula above.)

The greedy strategy would take the items by value per decagram: the headlamp (2.5 points/dag), the knife (1.8), and then neither the sleeping mat (0.9) nor the stove (0.75) would fit into the remaining 30 dag — only 43 points. In the large problem with 24 items the greedy strategy ends at 702 points: it fills the backpack with small things and there is no room left for the tent (220 dag).

def batoh(w, u, W):                       # w, u: weights and values, W: capacity
    T = [0] * (W + 1)                     # the row for “no item”
    for i in range(len(w)):
        for c in range(W, w[i] - 1, -1):  # backwards: T[c − w[i]] is still from row i − 1
            T[c] = max(T[c], T[c - w[i]] + u[i])
    return T[W]                           # n · W steps: 24 · 1000 = 24,000

2. Individual, genome and fitness

Definition — genome, population, fitness

Let a knapsack problem with n items, weights w_i and capacity W in decagrams and values u_i (i = 1, …, n; here n = 24) be given.

1. A genome (chromosome) is an encoded solution; for the backpack it is a string x = (x₁, …, x_n) ∈ {0, 1}ⁿ. Its components x_i — one bit per item — are called genes.
2. A population of size μ ∈ ℕ is a μ-tuple of genomes P = (x⁽¹⁾, …, x^(μ)), x^(j) ∈ {0, 1}ⁿ; the same genome may appear in it several times (the order does not matter, so it is a multiset with μ elements). The elements of the population are called individuals.
3. Fitness is a function F : {0, 1}ⁿ → ℝ that the algorithm maximizes. For the backpack we define it with a penalty for overloading: F(x) = ∑_i=1ⁿ u_ix_i,   if ∑_i=1ⁿ w_ix_i ≤ W, F(x) = ∑_i=1ⁿ u_ix_i − 3 · (∑_i=1ⁿ w_ix_i − W),   otherwise.

For a feasible backpack the fitness thus equals its value, and for every decagram over the capacity 3 points are subtracted.

F(x) = ∑ u_ix_i − 3 · max(0, ∑ w_ix_i − W)

F(x)

the fitness of backpack x — the single number by which selection compares individuals

∑ u_ix_i

the value of the packed items (x_i = 1 counts the item, 0 leaves it out) — what we really want to maximize

3

the price of one decagram over the limit — it is greater than the best ratio of value to weight (the headlamp, 2.5 points/dag), so packing anything into an already overloaded backpack always lowers its fitness

max(0, ∑ w_ix_i − W)

the overload in decagrams; the max with zero makes sure that a backpack that fits gets no penalty and a lighter backpack is not favoured

Example — the fitness of two backpacks

Optimum: value 727, weight 990 dag ≤ 1,000  ⇒  F = 727 − 3 · 0 = 727

Optimum + camera (80 dag, 20 points): value 747, weight 1,070 dag  ⇒  F = 747 − 3 · 70 = 537

(Colours as in the formula above.)

The camera adds 20 points, but the overload of 70 dag costs 210 — selection reliably pushes such a backpack aside.

3. Selection

Definition — tournament and roulette-wheel selection

Let P = (x⁽¹⁾, …, x^(μ)) be a population of size μ and F : {0, 1}ⁿ → ℝ the fitness. Selection is a random procedure that returns one individual (a parent) from P:

1. Tournament selection of size k ∈ ℕ, k ≥ 1: draw indices i₁, …, i_k ∈ {1, …, μ} independently and uniformly (with replacement, the same index may come up several times) and return the individual x^(i*), where i* ∈ argmax_{j ∈ {i1, …, ik}} F(x^(j)) (on a tie in fitness, any of the best).
2. Roulette-wheel selection (assumes F(x^(j)) > 0 for all j): return the individual x⁽ⁱ⁾, i ∈ {1, …, μ}, with probability P(x⁽ⁱ⁾ selected) = F(x⁽ⁱ⁾)/∑_j=1^μ F(x^(j)).

Selection pressure is a qualitative notion: how strongly selection favours fitter individuals. It can be measured, for example, by the ratio of the expected number of selections of the best and of an average individual (see the example below); for a tournament it grows with k.

How strong a tournament is can be computed exactly. Our program draws k individuals with replacement (the same individual can get into the tournament twice). Let us sort the population from the best (i = 1) to the worst (i = μ):

P(i-th wins) = (μ − i + 1)^k − (μ − i)^k/μ^k

P(i-th wins)

the chance that it is exactly the i-th best individual that becomes a parent

(μ − i + 1)^k

the number of tournaments in which nobody is better than the i-th — all k draws fall on it or on worse ones

(μ − i)^k

from these we subtract the tournaments in which the i-th is not present at all — those would be won by someone worse; the difference is the tournaments where the i-th is the best one present

μ^k

the number of all possible tournaments (k draws, each out of μ individuals) — dividing by it gives a probability

Example — a tournament of three among 40 backpacks

μ^k = 40³ = 64,000. Each generation selects 38 parents (two places are taken by the elite individuals); colours as in the formula above:

the best: 40³ − 39³/64,000 = 64,000 − 59,319/64,000 ≈ 7.31%,   expected 38 · 0.0731 ≈ 2.78 selections

the 20th best: 21³ − 20³/64,000 = 9,261 − 8,000/64,000 ≈ 1.97%,   expected ≈ 0.75 selections

the worst: 1³ − 0³/64,000 ≈ 0.0016%,   expected ≈ 0.0006 selections

An average individual gets 38/40 = 0.95 selections, the best almost three times as many. In general, for a large population the best one gets roughly k times more than the average — that is why selection pressure grows with k.

4. Crossover and mutation

Definition — one-point crossover

Let n ≥ 2, let a = (a₁, …, a_n) and b = (b₁, …, b_n) ∈ {0, 1}ⁿ be the genomes of the parents and p_c ∈ [0, 1] the crossover probability. One-point crossover creates two offspring as follows:

1. With probability 1 − p_c no crossover takes place and the offspring are copies of the parents a and b.
2. Otherwise draw a crossover point c ∈ {1, …, n − 1} uniformly, and the offspring are a′ = (a₁, …, a_c, b_c+1, …, b_n),   b′ = (b₁, …, b_c, a_c+1, …, a_n).

The offspring thus take the first c genes from one parent and the remaining n − c from the other. Other variants are two-point crossover (two points, the section between them is swapped) and uniform crossover, where for every i = 1, …, n independently, with probability 1/2, a′_i = a_i, b′_i = b_i, and otherwise a′_i = b_i, b′_i = a_i.

Definition — bit-flip mutation

Let x = (x₁, …, x_n) ∈ {0, 1}ⁿ be a genome and p_m ∈ [0, 1] the mutation probability. Bit-flip mutation creates a genome x′ ∈ {0, 1}ⁿ so that for every i = 1, …, n, independently of the other genes,

x′_i = 1 − x_i   with probability p_m,   x′_i = x_i   with probability 1 − p_m.

Each gene is thus flipped (0 ↔ 1) with probability p_m. Usually p_m = 1/n is chosen, so on average n · p_m = 1 gene per individual is flipped.

Example — how many genes mutation flips

The number of flipped genes has a binomial distribution: P(j genes) = (n choose j) · p_m^j · (1 − p_m)^n−j. For n = 24 and p_m = 1/24:

expected number: n · p_m = 24 · 1/24 = 1

no change: (23/24)²⁴ ≈ 0.360   (for large n it approaches 1/e ≈ 0.368)

exactly one gene: 24 · 1/24 · (23/24)²³ ≈ 0.376

So roughly a third of the offspring stay unchanged, a third differ in one gene and the rest in two or more.

The parents are the two best backpacks of the initial population (423 and 398 points), and the cut is after the twelfth item. Neither offspring is better than the better parent — they have 403 and 418 points. Crossover does not guarantee an improvement; it only offers new combinations, and selection then decides which survive. In the first offspring, mutation packed a water filter (15 dag, 32 points), and it suddenly has 435 points — more than both parents.

Example — recomputing the crossover from the figure

Value adds up gene by gene, so it is enough to add up the value of the beginning (items 1–12) and of the end (items 13–24) separately:

parent 1: 310 + 113 = 423,   parent 2: 305 + 93 = 398

offspring 1 = beginning of parent 1 + end of parent 2: 310 + 93 = 403

offspring 2 = beginning of parent 2 + end of parent 1: 305 + 113 = 418

mutation packs the water filter: 403 + 32 = 435

Parent 1 is better in both halves (310 > 305 and 113 > 93), so with this cut no offspring can beat it — crossover has nothing to build a better whole from. The improvement only came with mutation.

5. The whole algorithm

Algorithm — genetic algorithm

Input: genome length n ≥ 2, fitness F : {0, 1}ⁿ → ℝ, population size μ ∈ ℕ, number of elite individuals e ∈ {0, …, μ − 1}, tournament size k ≥ 1, crossover probability p_c ∈ [0, 1], mutation probability p_m ∈ [0, 1] and number of generations G ∈ ℕ. Output: the fittest individual of the last generation; for e ≥ 1 it is also the fittest individual the algorithm has ever evaluated.

1. Create a random initial population P₀ of μ individuals (in our case each gene has the value 1 with probability 0.3), evaluate them with F and set t ← 0.
2. If t = G, stop and return the individual of P_t with the highest fitness.
3. Copy the e fittest individuals of P_t into the new generation P_t+1 unchanged (elitism).
4. While P_t+1 has fewer than μ individuals: select two parents from P_t by a tournament of size k, cross them over by one-point crossover with probability p_c, mutate both offspring by bit-flip mutation with p_m and add them to P_t+1; if in the end there is one individual over μ, discard it.
5. Evaluate the individuals of P_t+1, set t ← t + 1 and continue with step 2.

The algorithm stops in step 2 after exactly G generations.

import random

def evoluce(zdatnost, n, velikost=40, generaci=60, p_krizeni=0.9, elita=2):
    pop = [[int(random.random() < 0.3) for _ in range(n)] for _ in range(velikost)]
    for _ in range(generaci):
        pop.sort(key=zdatnost, reverse=True)
        dalsi = [g[:] for g in pop[:elita]]            # elitism
        while len(dalsi) < velikost:
            a, b = turnaj(pop, zdatnost), turnaj(pop, zdatnost)
            if random.random() < p_krizeni:
                bod = random.randrange(1, n)
                a, b = a[:bod] + b[bod:], b[:bod] + a[bod:]
            dalsi += [mutuj(a), mutuj(b)]
        pop = dalsi[:velikost]
    return max(pop, key=zdatnost)

def turnaj(pop, zdatnost, k=3):
    return max(random.choices(pop, k=k), key=zdatnost)   # k draws with replacement

def mutuj(g):
    return [1 - x if random.random() < 1 / len(g) else x for x in g]

We measure the cost of the algorithm by the number of fitness evaluations — in real problems (simulations, measurements) that is the most expensive step. The initial population is evaluated and then every generation: μ + G · μ = 40 + 60 · 40 = 2,440 evaluations for μ = 40 individuals and G = 60 generations. The elite individuals are evaluated again even though they have not changed; a smarter program would remember their fitness.

6. The evolution of a backpack

Let us run the algorithm: 40 backpacks, 60 generations, a tournament of three, crossover with probability 0.9, mutation 1/24 and two elite individuals. The figure shows the population in generations 0, 5, 15, 30 and 60 — each row is one backpack, each column one item, and at the top the optimum for comparison:

At the start the population is varied and the backpacks are rather half-empty: each item got into them with probability 0.3, so they weigh around four kilos (the expected weight is 0.3 · ∑ w_i = 0.3 · 12.75 kg ≈ 3.8 kg). The best has 423 points, the average 231. After five generations 36 of the 40 backpacks carry the tent, 35 the water bottle, and the best backpack has 634 points. Around the fifteenth generation the population hits the capacity — 12 backpacks are overloaded — and starts learning what to sacrifice: the extra food and the sandals have almost disappeared, but the camera is still carried by 39 backpacks. The algorithm first finds the optimum, 727 points, in generation 26; by generation 30 the camera is left in only one backpack. The population never merges into a single solution, though — mutation keeps trying small deviations.

To get there the algorithm evaluated 2,440 backpacks — not quite two hundredths of a percent of all 16,777,216 possibilities. Random search with the same number of attempts did not find the optimum even once in a hundred repetitions and ended at 574 points on average.

Example — why random search does not find the optimum

A random backpack takes each item independently with probability 0.3. The optimum contains 19 items and leaves out 5, so

P(random backpack = optimum) = 0.3¹⁹ · 0.7⁵ ≈ 1.16 · 10⁻¹⁰ · 0.168 ≈ 1.95 · 10⁻¹¹

expected number of hits in 2,440 attempts: 2,440 · 1.95 · 10⁻¹¹ ≈ 4.8 · 10⁻⁸

Even if the draw were uniform (each item with probability 1/2), the chance would be one in 16,777,216 per attempt. A genetic algorithm does not draw the optimum all at once — it assembles it piece by piece from backpacks that are already good.

7. What crossover is for and what mutation is for

The orange line in the chart is the same run with mutation switched off. After eleven generations it gets stuck at 573 points and does not move any more. Why, a comparison of a hundred runs with different seeds shows:

Without mutation the population loses its diversity: when a gene is not in any individual, crossover cannot produce it, and on top of that selection quickly pushes out everything but the best. This is called premature convergence. Without crossover the algorithm works — it is really a population of hill climbers with selection — but it is slower. Crossover helps to put together good pieces that arose in different individuals.

Theorem — Holland’s schema theorem

Let n ≥ 2. A schema is a string H = (H₁, …, H_n) ∈ {0, 1, ∗}ⁿ, where ∗ means “anything”. A genome x ∈ {0, 1}ⁿ matches the schema H if and only if x_i = H_i for all i with H_i ≠ ∗. The positions i with H_i ≠ ∗ are fixed; assume at least one exists. Define

1. the order o(H) = |{i : H_i ≠ ∗}| — the number of fixed positions,
2. the defining length δ(H) = max{i : H_i ≠ ∗} − min{i : H_i ≠ ∗} — the distance between the first and the last fixed position.

Let a genetic algorithm with population size μ and positive fitness F > 0 form each whole new generation by roulette-wheel selection, one-point crossover with probability p_c and bit-flip mutation with probability p_m (without elitism). Let m(H, t) be the number of individuals of generation t that match H, and if m(H, t) > 0, let F(H) be their average fitness and F̄ the average fitness of the whole generation t. Then for the expected number in the next generation (given generation t)

E[m(H, t + 1)] ≥ m(H, t) · F(H)/F̄ · [1 − p_c · δ(H)/n − 1 − o(H) · p_m].

In words: selection multiplies the number of carriers of the schema by the ratio of their fitness to the average, and crossover and mutation subtract at most the losses shown.

E[m(H, t + 1)] ≥ m(H, t) · F(H)/F̄ · [1 − p_c · δ(H)/n − 1 − o(H) · p_m]

m(H, t)

how many individuals carry the building block now — the next generation starts from them, which is why it is multiplied by this

F(H)/F̄

how much fitter than average the carriers of the schema are — the roulette wheel gives them proportionally more offspring; above 1 the schema multiplies, below 1 it dies out

p_c · δ(H)/n − 1

the chance (an upper bound) that crossover cuts the schema: crossover happens with p_c and the cut point falls between the fixed positions with probability δ(H)/n − 1 — that is why long schemata are a problem

o(H) · p_m

the chance (an upper bound) that mutation flips one of the o(H) fixed positions — that is why high-order schemata are a problem

Example — a short and a long schema on the backpack

The square bracket for the settings of our run (p_c = 0.9, n = 24, p_m = 1/24). Both schemata have order 2; colours as in the formula above:

“the tent and the sleeping bag” (genes 1 and 2, δ = 1): 1 − 0.9 · 1/23 − 2 · 1/24 ≈ 1 − 0.039 − 0.083 = 0.878

“the tent and spare socks” (genes 1 and 24, δ = 23): 1 − 0.9 · 23/23 − 2 · 1/24 ≈ 1 − 0.9 − 0.083 = 0.017

For the short schema it is enough for its carriers to be 14% fitter than average (1/0.878 ≈ 1.14), and according to the theorem it already spreads. The long schema would have to be sixty times fitter — the theorem promises essentially nothing about it. Our algorithm uses a tournament, not a roulette wheel, so only the square bracket applies to it; the first two factors would be computed differently.

8. Genetic algorithms in practice

• Designing shapes. The antenna of NASA’s ST5 satellites (launched in 2006) was designed by an evolutionary algorithm: an oddly twisted piece of wire that would not have occurred to an engineer, but met the specification at least as well as a hand-designed antenna (and in later experiments even better).
• Timetables and logistics. Timetables, shift plans or warehouse layouts — problems with many constraints, where fitness can be computed but an exact algorithm would run for ages.
• Machine learning. Evolution tunes the hyperparameters of models and, in neuroevolution, which has its own part in the syllabus, even the weights and architectures of neural networks.
• Evolution with language models. Systems such as FunSearch (2023) and AlphaEvolve (2025) from Google DeepMind maintain a population of programs and use as mutation a language model that modifies a program. Selection is provided by automatic evaluation. This way new mathematical constructions and faster algorithms have been found.

9. Summary

• A genetic algorithm improves a whole population of solutions: by selecting the fit ones, by crossover and by mutation.
• Fitness is the only thing it needs to know about the problem; violated constraints can be handled with a penalty.
• Tournament selection keeps up the selection pressure, and elitism does not allow the best solution to be lost.
• On a backpack with 16.7 million possibilities it found the optimum in 88 out of 100 runs after evaluating 2,440 backpacks; random search with the same budget not even once.
• Mutation supplies diversity — without it the population converges prematurely. Crossover assembles good building blocks and speeds evolution up.

Want to get your hands on it? Have an AI agent write a genetic algorithm for your own backpack for a hike — and then try switching off mutation, enlarging the tournament or shrinking the population, and watch what happens to the diversity.

Do you see it differently? Write to support@coden-app.com.