Toy Coffee Fitness Landscape: Build a Complete Search Model

A Landscape You Can Hold in Your Head

The previous module defined the landscape as a four-component system: configuration space (X), neighborhood (N), value function (f), dynamics (D). You saw each component mapped onto protein engineering, coffee recipes, and neural networks. This module puts the framework to work: you will build a complete landscape from scratch, encode it in binary, score it by hand, define neighborhoods, and run search algorithms across it. Coffee carries the main example. Pick a system of your own to build alongside: a workout split, a recipe, a study schedule, anything you have tried to improve through repeated adjustment.

A home brewer spends months chasing a better cup, changing the roast, the grind size, the water temperature, whether to add milk, whether to grind beans fresh each morning. Some changes help. Some make it worse. For a while, the search stalls: every tweak fixes one thing while breaking another. A finer grind makes the flavor richer but introduces bitterness. Milk softens the bitterness but buries the subtle notes that made the dark roast worth drinking.

Three questions locate you on a landscape you cannot yet see:

1. What did you change last time you tried to improve it?
2. How did you know whether the change helped?
3. Have you ever been stuck where nothing you tried seemed to make it better?

"Stuck" is the lived experience of a local optimum: a configuration where every allowed one-step change makes things worse, even though a much better configuration may exist in territory you have not explored. What counts as an "allowed" change is a modeling choice this module will define precisely. For now, think of it as the kind of change you normally try: adjusting one variable at a time. The landscape framework exists to explain why you get stuck and what you can do about it.

These traps are real. They show up in coffee brewing, workout programming, drug design, neural network training. Researchers study them in full-scale systems all the time. The reason to start small: five binary variables produce 32 configurations, enough to enumerate every one, score them all, trace every path, and verify by direct inspection where the traps form and why. Real coffee involves continuous grind settings, precise temperatures, brew times, bean origins, water mineral content, pour rates. The space is too large to see whole, and every measurement carries noise. A toy makes the entire landscape visible, so you build the structural vocabulary on a system you can hold in your head, then carry it into systems where the space outgrows inspection.

Why a Toy, and Why Binary

A toy model is a deliberate simplification designed to make one mechanism visible by stripping away everything else. A wind tunnel model of a car has no seats, no stereo, no paint job. It needs to behave correctly with respect to drag. The parts it leaves out are the price of isolating the part that matters.

The toy for fitness landscapes uses binary strings: sequences of zeros and ones, where each position represents a single on/off decision. Why binary? Because it makes the combinatorial structure visible with minimal overhead. Each position has two states, written as 0 or 1. Binary strips away magnitude, continuity, and domain-specific meaning, preserving the structure this module needs: which combinations of the retained decisions exist and which configurations differ by one change. This is a modeling choice. Many real variables are continuous or ordered, and binarizing them destroys that information. The cost is worth paying here because it makes the entire space small enough to inspect.

Start with one decision: roast. A single bit encodes it: 0 for light, 1 for dark. One position, two configurations, done.

Add grind as a second position, and each recipe becomes a two-character string read left to right: 00 is light roast with coarse grind, 10 is dark roast with coarse grind, 11 is dark roast with fine grind. Two decisions, four combinations. The pattern scales to any number of positions.

The coffee example uses five:

Reading a five-bit string works the same way: go left to right, one digit per row. 11101 means position 1 is 1 (dark roast), position 2 is 1 (fine grind), position 3 is 1 (hot water), position 4 is 0 (no milk), position 5 is 1 (freshly ground).

Five binary decisions. Each one throws away information. Grind size is really a spectrum from Turkish to French press, collapsed here to two bins. Water temperature has an infinite range, split at 92 C. Brew time, water mineral content, bean origin, pour rate: all excluded entirely.

What does the encoding lose? It cannot distinguish a 91 C brew from an 80 C brew; both register as "below 92 C." If the optimal temperature is 88 C, the model cannot represent it. That is the price of making the whole space small enough to inspect, and it is the first genuine modeling decision the toy asks you to make.

Each five-bit string carries the combinatorial structure of the retained choices. The domain meaning (coffee, workouts, study habits) can be swapped without changing the structure. That is the point.

Your turn: Pick 4-5 binary decisions for the system you identified in Section 1. Write them down in a table like the one above. For each decision, name what 0 means and what 1 means. Then name at least one variable you excluded and say what you lose by excluding it.

Build the Configuration Space

The configuration space is the set of every possible combination of your binary decisions. Formally, X = \{0, 1\}^n, where n is the number of positions.

For the coffee model, n = 5, so |X| = 2^5 = 32 configurations. Here are a few of them, translated back into coffee:

00000 = Light roast, coarse grind, cool water, no milk, pre-ground
10101 = Dark roast, coarse grind, hot water, no milk, ground today
11101 = Dark roast, fine grind, hot water, no milk, ground today
01010 = Light roast, fine grind, cool water, milk, pre-ground
11111 = Dark roast, fine grind, hot water, milk, ground today

Thirty-two recipes, all of them enumerable. That is the point of a toy: the space is small enough to see whole.

Watch what happens when the space grows. Add one more decision (stirring vs. not stirring) and the space doubles to 64. Add another (filtered vs. unfiltered water) and it reaches 128. Each binary decision doubles the total:

|X| = 2^n.

At n = 5, there are 32 configurations. At n = 10, there are 2^{10} = 1{,}024. At n = 20, there are 2^{20} = 1{,}048{,}576. Twenty binary decisions, each one just an on/off choice, produce over a million possible configurations. The difficulty of search is not that any single choice is complicated; the difficulty is that choices multiply.

This is why you cannot simply try everything. Exhaustive search works at n = 5: an experimenter could brew all 32 coffees in a weekend. At n = 20, that same experimenter would need nearly 2,900 years of daily brewing. Search algorithms exist because configuration spaces outgrow enumeration fast.

Your turn: You committed to 4-5 binary decisions in the previous section. Count your configurations: if you chose 5 decisions, you have 32 candidates. Write down 4-5 of them in binary and translate each one back into plain language. You have just defined your configuration space.

Score Every Configuration by Hand

A configuration space alone is just a set of possibilities. To create a landscape, you need a value function: a rule that assigns a score to every configuration. The value function gives every configuration a height. Which configurations count as peaks depends on both the value function and the neighborhood (defined in the next section): a peak is a configuration whose score is higher than every configuration reachable by one allowed move.

Before writing any scoring code, score a deliberately chosen sample by hand. The scores below are one brewer's personal ratings, 0 to 10, for how much they enjoy each cup. The sample includes matched pairs so you can see whether a change has the same effect in different backgrounds:

Look at position 5 (fresh beans). To test whether fresh beans have an additive effect, compare matched pairs: two recipes that differ only in the fresh-beans position. Compare 10100 (score 4) with 10101 (score 7): fresh beans add 3 points in that background. Compare 11100 (score 5) with 11101 (score 8): fresh beans add 3 points in that second background. In these two matched pairs, fresh beans add the same amount each time. That suggests an approximately additive effect for those backgrounds. To claim a truly stable additive contribution, we would need the same contrast across more backgrounds.

Now look at positions 1 and 4 (roast and milk). To test for interaction, use a clean 2×2 contrast where only roast and milk change and everything else stays fixed. Pull four recipes from the table that share the same grind, temperature, and freshness (fine, hot, fresh) and differ only in roast and milk:

Without milk, switching from light to dark adds 2 points. With milk, switching from light to dark subtracts 2 points. The effect of roast changes sign depending on milk. That is epistasis: the contribution of one position depends on the state of another.

The table above revealed epistasis without any mathematical machinery. The interaction structure was already in the scoring; the toy model made it visible.

The epistasis might look like an artifact of subjective scoring. It is subjective, and that is the point: the interaction structure belongs to the scorer's preferences for this system. If those preferences were truly additive, no hand-scoring would produce interactions, because each position would contribute the same amount in every context. Additive means each improvement works alone; epistatic means improvements interfere.

The simplest value function treats each position as independent. The total score is the sum of each position's individual contribution, counted only when that position is ON.

Start with one position. Fresh beans contributed roughly 3 points in the hand-scoring above, so assign weight w_5 = 3 and write the value function as f(x) = w_5 \cdot x_5. Here x_5 is the value of position 5: either 0 or 1. When fresh beans are ON (x_5 = 1), the term contributes 3 \times 1 = 3. When OFF (x_5 = 0), it contributes 3 \times 0 = 0. The multiplication by x_5 is a switch: the weight counts when the position is ON and vanishes when it is OFF.

Add a second position. Dark roast contributes roughly 2 points, so w_1 = 2, and the function extends to two terms: f(x) = w_1 x_1 + w_5 x_5 = 2 x_1 + 3 x_5. A configuration with both ON scores 2 + 3 = 5; dark roast ON with pre-ground scores 2 + 0 = 2. Each term contributes independently.

The general form writes this pattern for all n positions:

Because each position's contribution is fixed regardless of context, the optimal recipe is straightforward: turn ON every positive-weight position and OFF every negative-weight position. If every weight is nonzero and no constraints exclude any configuration, there is one strict global optimum. There are no traps because improving any single position always improves the total. If a weight is exactly zero, both settings tie for that position, and the single peak broadens into a plateau. The structural point holds either way: no interactions means no traps.

Now add a second layer: pairwise interactions. The total score is the sum of individual contributions plus a bonus or penalty for every pair of positions that are both ON.

See this with two positions first. Dark roast contributes w_1 = 3 and milk contributes w_4 = 2 individually. Their additive baseline is f(x) = 3 x_1 + 2 x_4. To encode the interference observed in the hand-scoring, add one interaction term: f(x) = 3 x_1 + 2 x_4 + (-4) \cdot x_1 x_4. The product x_1 x_4 equals 1 only when both positions are ON; otherwise it contributes nothing. When both are ON: 3 + 2 + (-4) = 1 point total, less than either contributes alone. Each ingredient helps in isolation; together they partly cancel. The coefficient w_{1,4} = -4 is the interaction weight: it encodes the size and direction of the interference. The product x_1 x_4 is the gate that activates it.

The general form writes this structure for all positions and all pairs:

The first sum, \sum_{i} w_i x_i, is the additive baseline. The second sum adds a w_{ij} x_i x_j term for every pair (i, j). The parameter \lambda scales how strongly interactions matter relative to the individual weights.

Interactions make the landscape rugged. Ruggedness measures local unpredictability: how much the payoff of a single change varies depending on the rest of the configuration. Any epistasis creates ruggedness, because once a position's contribution depends on context, the same change can help in one background and hurt in another. As \lambda grows and interactions strengthen, the surprises get larger.

A rugged landscape can still have a single peak. Suppose interactions only change the magnitude of each position's effect: dark roast adds 3 points in one recipe and 1 point in another, always a gain. The landscape is bumpy, with uneven payoffs, yet every uphill path leads to the same summit.

Multiple peaks require reciprocal sign epistasis: two positions that each reverse the other's effect. The coffee scores demonstrate this. Roast reverses depending on milk: dark adds 2 points without milk, subtracts 2 with milk. Milk also reverses depending on roast: milk adds 1 point with light roast, subtracts 3 with dark roast. Each position negates the other. That mutual reversal creates a valley no single-step path can cross without losing score, splitting the landscape into separated peaks. Poelwijk, Tănase-Nicola, Kiviet, and Tans (2011) proved the general result: reciprocal sign epistasis between at least one pair of positions is necessary for multiple peaks to exist. A landscape with magnitude-only interactions can be arbitrarily rugged and still have one peak.

This quadratic model captures pairwise interactions. Higher-order interactions, where three or more positions affect each other simultaneously, exist in real systems; the N-K module later in this course introduces a framework for tuning that complexity.

Same configuration space, different value function, different landscape. Score the same 32 coffees by taste, and this brewer's global peak is light-roast, fine-grind, cool-water, no-milk, fresh: a delicate cold cup. The dark-roast, fine-grind, hot, no-milk, fresh recipe remains a strong local favorite, but not the best cup in the full space. Score the same configurations by affordability (higher score for cheaper cups), and the optimum shifts entirely: pre-ground light roast brewed with cool water wins. The value function is a choice about what to measure, and that choice reshapes the entire terrain.

The same principle applies within a single criterion. Two people scoring these 32 recipes by "taste" would assign different numbers, producing different peaks, different traps, and different interaction patterns over the same configuration space. Modeling both preferences would require two separate value functions: two landscapes, one per scorer. "Taste" is not a single function until you specify whose.

This structure appears in real biology. Weinreich, Delaney, DePristo, and Hartl (2006) studied five point mutations in beta-lactamase, an enzyme involved in antibiotic resistance. Because each mutation can be absent or present, the five mutations define 2^5 = 32 genotypes. The researchers scored each genotype by its resistance to the antibiotic cefotaxime: five binary positions, 32 configurations, a measured fitness value for each. The same combinatorial structure as the coffee toy. Epistasis pervaded the landscape. Some mutations that improved resistance in one genetic background reduced it in another. Because five mutations can be acquired in 5! = 120 possible orders, there are 120 direct mutational paths from the starting genotype to the five-mutation genotype. Of those 120 paths, 102 were inaccessible to strict step-by-step selection because they did not increase resistance at every step. Only 18 paths increased resistance monotonically. A five-bit landscape in nature, exhibiting the same structural traps this toy model makes visible.

Your turn: Score 10 of your own configurations on a 0-to-10 scale. As you score them, watch for interactions: does the effect of one position change depending on what another position is doing? If yes, your system has epistasis. If every position contributes roughly the same amount regardless of context, your system may be approximately additive.

Define What Counts as One Step

When the coffee experimenter tries to improve a recipe, how big is a typical change? Most experimenters change one thing at a time: switch from light to dark roast, or switch from coarse to fine grind. Rarely would someone change the roast AND the grind AND the temperature AND the milk AND the beans simultaneously.

That restraint reflects the cost structure of experimentation. Changing one variable makes attribution possible: the experimenter can see what that change did. Changing five at once makes attribution impossible: if the coffee improved, there is no way to tell which change mattered. This experimental logic is also a modeling decision: it defines the neighborhood of each configuration.

For binary strings, the simplest neighborhood is Hamming distance 1: two strings are neighbors if they differ at exactly one position. In notation, N_1(x) is the set of all configurations y whose Hamming distance from x is exactly 1, meaning they differ at one position. For a string of length n, this gives exactly n neighbors: one for each position you could flip.

Here is the one-bit neighborhood of the brewer's dark-roast local favorite, 11101 (dark, fine, hot, no milk, fresh):

Five neighbors, each reached by changing exactly one decision.

What happens when the experimenter relaxes that restraint and changes two things at once? Clean attribution is sacrificed: if the coffee improves, there is no way to tell which change mattered. The benefit is access to configurations that no single change can reach from the current position.

A wider neighborhood allows flipping one or two positions simultaneously. See this at minimal scale first. Shrink to two decisions: roast and grind. Starting at 10 (dark roast, coarse grind), the one-bit neighbors are 00 (switch roast) and 11 (switch grind). The two-bit neighbor is 01 (switch both). The full neighborhood under one-or-two-bit moves is {00, 11, 01}: every other configuration in this small space.

The formal notation writes this rule for any configuration x:

Read this as: N_2(x) is the set of all configurations y in the space X whose Hamming distance d_H(x, y) (the count of positions where they differ) is between 1 and 2. The constraint 1 \le d_H \le 2 means you can flip one position or two, but you cannot stay in place. This gives n + \binom{n}{2} neighbors. The notation \binom{n}{2}, read "n choose 2," counts the ways to pick which two positions to flip. For n = 5: 5 one-bit changes plus \binom{5}{2} = 10 two-bit changes, giving 15 neighbors total. The two-bit neighbors include moves like "switch to light roast AND add milk" or "switch to coarse grind AND use pre-ground": changes that involve two simultaneous adjustments.

Configuration 11101 scores 8 in our brewer's ratings. Under Hamming-1, every single-bit neighbor scores lower: 01101 gets 6, 10101 gets 7, 11001 gets 4, 11111 gets 5, 11100 gets 5. Then 11101 is a local peak: better than everything one step away. The search is stuck; every single change makes the coffee worse.

Under Hamming-2, 10 additional neighbors become visible. One of them, 01001 (light roast, fine grind, cool water, no milk, fresh), scores 10. That recipe requires flipping two positions simultaneously. It was invisible under one-step moves. The same configuration, the same score, the same position in the space, went from "peak" to "not a peak" because the neighborhood widened.

A peak is a configuration better than all its neighbors. Change what counts as a neighbor, and you change what counts as a peak.

Is a peak a property of the coffee system, or a property of how the experimenter chose to search?

Your turn: Look at your own scored configurations. Pick your best one. List its Hamming-1 neighbors (flip each position one at a time and translate each into plain language). Is your best configuration better than all of them? If so, it is a local peak under one-step moves. Then consider: would it survive as a peak if you could change two things at once?

The Controlled Experiment

The four-component tuple is a laboratory instrument: X for the configuration space, N for the neighborhood, f for the value function, D for the dynamics. Its power comes from one operation: change exactly one component, hold the other three fixed, observe what happens.

Experiment 1: Change the value function. Keep X (the 32 coffee configurations), keep N (one-bit moves), keep D (greedy hill-climbing). Switch f from "taste score" to "affordability" (higher score for cheaper cups). Under the taste function, the global peak was light roast, fine grind, cool water, no milk, freshly ground: a delicate cold cup. Under affordability, the peak shifts to light roast, coarse grind, cool water, no milk, pre-ground: the cheapest possible configuration. Same space, same walker, same step size; the value function alone moved the peaks.

Experiment 2: Change the neighborhood. Keep X, keep f (taste), keep D (greedy). Switch N from one-bit to two-bit moves. Some peaks that trapped the greedy walker under one-bit moves disappear, because they now have better two-bit neighbors. A wider neighborhood can remove traps and often improves greedy search in rugged landscapes, though the outcome should be measured for each case. The neighborhood changed which configurations count as traps.

Experiment 3: Change the dynamics. Keep X, keep N (one-bit), keep f (taste). Switch D from greedy hill-climbing to simulated annealing. Greedy gets stuck at the nearest peak; annealing sometimes accepts a worse recipe temporarily, crosses a shallow valley, and reaches a higher peak on the other side. The terrain is identical; the walker's willingness to take temporary losses changed the destination.

Each experiment produces one clean conclusion because only one variable moved. This ability to run controlled comparisons, where only one piece of the tuple changes, is the central methodological skill the toy builds.

Build Your Walkers

The landscape (X, N, f) defines the terrain: which configurations exist, how they connect, and how they score. The dynamics D is the search process that moves across this terrain. The coffee experimenter has options. Methodically try every single-variable change, always keeping the best? Sometimes try something unpromising, hoping it opens a path? Maintain several parallel experiments? Each search process has a character, and different characters, on the same terrain, reach different destinations.

Greedy hill-climbing. The experimenter evaluates every one-step change to the current recipe. Moves to whichever neighbor improves the score the most. Repeats until no single-step neighbor improves the score. It always stops at a local optimum under the chosen neighborhood, and that local optimum need not be global. No looking back. No accepting a worse cup. When the peak turns out to be mediocre, the search is stuck: every path to something better passes through something worse first.

Random mutation hill-climbing. The experimenter picks one random change (say, switch from fine to coarse grind). If the score improves, keep it. Otherwise, stay put and sample a different random change next step. It uses fewer evaluations per step than greedy (one neighbor instead of all n), but it may need many more steps. Because changes are sampled in random order, the search path can differ from greedy, and it sometimes lands on a different peak.

Simulated annealing. Why would the experimenter deliberately drink a bad cup of coffee? Because the current peak might be mediocre, and crossing a valley is the only route to higher ground. Early on, the experimenter accepts worse recipes: bitter, weak, or sour cups that would normally be rejected. Over time, the acceptance threshold tightens. The early tolerance lets the search cross shallow valleys: a recipe slightly worse than the current one might border a much better region. Greedy rejects every downhill step and stays trapped. Annealing, at high temperature, accepts the temporary loss and sometimes reaches a higher peak from the other side. It does not guarantee the global optimum. Deep valleys or distant peaks may remain unreachable within the cooling schedule. The advantage is structural: annealing can explore territory that greedy, by design, will never visit.

Population search. The experimenter maintains 10 recipes simultaneously. Each round, keep the 5 best, mutate each by flipping one random bit, taste all 10, repeat. The population explores multiple regions of the space at once, which helps when the landscape has several peaks of different heights scattered across the configuration space.

The landscape determines where the peaks are. The dynamics determines which peaks are reachable. A peak reachable by annealing (which can cross shallow valleys) may be unreachable by greedy hill-climbing (which cannot accept a single downhill step). The terrain stayed the same; the walker changed, and so did the destination.

Your turn: Think about how you actually search your own system. Are you a greedy optimizer, always taking the best available improvement? Do you sometimes try changes that seem worse in the short term, hoping they lead somewhere better? Do you maintain several parallel approaches? Your real search process has a dynamics, and naming it is the final piece of the tuple.

The Visualization Is a Projection

Plot the 32 coffee configurations on a chart: x-axis = number of ON features (the Hamming weight), y-axis = the brewer's taste score.

Hamming weight 0 means every position is OFF: light roast, coarse grind, cool water, no milk, pre-ground. Hamming weight 5 means everything is ON: dark roast, fine grind, hot water, milk, freshly ground. In between, Hamming weight 3 contains \binom{5}{3} = 10 different recipes: some that scored high for our brewer (dark roast, fine grind, hot water) and some that scored low (light roast, coarse grind, milk). All 10 stack in the same column.

That chart looks like a landscape. It has peaks and valleys. It is also misleading.

Two peaks that appear separated by a valley in this projection might be connected through the actual 5-dimensional configuration space. A path that flips one bit ON and another OFF at each step maintains the same Hamming weight while climbing in score. The projection collapses that entire path into a single column, making the connecting ridge invisible.

The distortion grows with n. For n = 12, the space has 4,096 configurations compressed into 13 columns. The middle column alone, Hamming weight 6, contains \binom{12}{6} = 924 configurations. Those 924 points, each with its own score, stack on top of each other. The 2D picture destroys almost all structural information.

A landscape visualization is a projection, not the landscape itself. The actual structure lives in the configuration space X, the neighborhood N, and the value function f. A two-dimensional chart cannot represent their connectivity faithfully. When you encounter a landscape visualization, ask: what dimensions were collapsed to make this picture, and what structure did the collapsing hide?

Break Your Own Model

You have a working toy landscape: a configuration space, a value function, a neighborhood, and search dynamics. You can change any one component and watch the consequences. That ability to run controlled experiments, where only one piece of the tuple changes at a time, is the central skill this module builds.

What did you leave out? The coffee model has 5 positions with 2 states each: 32 configurations total. Real coffee involves continuous grind settings (Turkish, espresso, drip, French press, and everything between), water temperatures measurable to the degree, brew times from seconds to hours, and dozens of excluded variables: bean origin, roast date, water mineral content, altitude, humidity, cup material. If the optimal cup depends on interactions between brew time and water mineral content, the model is blind to it.

Does complexity mean ruggedness? You might assume that a system with many variables produces a rugged landscape. The number of variables determines the size of the configuration space; ruggedness comes from interactions among those variables. A hundred independent variables produce an additive landscape with a single peak: large, but smooth. Five variables with strong epistasis can produce a landscape with many traps: small, but rugged. The distinction matters for strategy: additive landscapes reward persistent, methodical optimization; rugged landscapes reward exploration, restarts, and tolerance for temporary regression.

Where does the visualization mislead? The Hamming-weight plot collapsed 32 configurations into 6 columns. Actual landscape plots of real systems collapse millions of configurations into even fewer dimensions. The visualization is always a shadow of the structure.

What happens when the landscape changes? The taste function is fixed: the same recipe always gets the same score. In reality, preferences shift: strong, simple, and fast at 6 AM; nuanced, aromatic, and leisurely at 3 PM. When the value function shifts over time, the landscape becomes a seascape (Mustonen and Lässig, 2009), and peaks that existed when the search began may no longer exist when it arrives.

Which tuple component would you change first? More positions? A ternary alphabet (0, 1, 2) instead of binary? A value function trained on actual tasting data instead of hand-scored? Higher-order interactions beyond pairs? A time-varying scoring rule? Each of these extensions is the subject of a later module in this course. Mount Fuji explores what happens when the value function is purely additive. Rough Mount Fuji asks how much noise an additive signal can tolerate. N-K makes the density of interactions tunable. Seascapes introduce time-varying terrain. The toy you just built is the simplest possible instance. Everything that follows adds structure, complexity, and realism one component at a time.

The four-component tuple shows you structure by choosing what to ignore.

The structural trap that stalled the coffee recipe at an 8 is the same structural trap that stalls antibiotic drug design at a locally optimal compound, organizational restructuring at a locally efficient process, and neural network training at a locally minimal loss. The tools this module builds (controlled experiments on the tuple, identification of interaction structure, comparison of search dynamics) apply wherever adaptive agents search combinatorial spaces.