Who Can Breed With Whom

Compatibility before crossover

The last chapter left animals in The Hollow carrying links that other animals in the same valley had never held. A child of two such parents can inherit a wiring that works like neither parent. Reduce the difference between two genomes to one number, and allow a child together only inside 3.00.

The number counts wiring one genome has that the other has never held, distance between settings where both are wired the same way, and distance between the ten body factors. Above 3.00 the two creatures may still live beside each other; they do not breed together.

Crossover became useful because two lineages can hold different discoveries. Structural mutation makes the same mechanism dangerous: two useful wirings can produce a child whose inherited pieces no longer agree on what signal a node carries.

Compatibility is measured before the mate roll chooses among candidates. That keeps the roster rule local: a creature searches the same box six cells across, then filters out candidates whose genomes are too far away.

The page defines the distance, sorts the valley into species by representatives, and runs two hundred years with one kind of animal at the start. Species become a guard on breeding, not a label painted on after the fact.

Genome distance

Four things can differ between two genomes and each of them has to be counted in its own currency before any of them can be added to the others.

Links one of them has and the other has never held. A link carries a number minted against the pair of nodes it joined, so two links are the same link when they carry the same number and are strangers otherwise. Sort both genomes' links by that number and walk the two lists side by side: where the numbers agree the link is matched, and where one list has a number the other does not, the link belongs to one of them alone. Those unmatched links split into two kinds. Past the highest number the other genome holds, the other genome has nothing to say at all: it was never handed a number that high, so the link arrived after the two lines parted. Those are the excess links. Inside that range the other genome was alive and being minted numbers at the time and did not take this one up, and those are the disjoint links.

Settings where they are wired the same. Over the matched links, the mean gap between the two weights. Two controllers wired identically and set differently are one machine at two settings, so this counts for less than a difference in the wiring itself.

Bodies. The mean gap over the ten body factors. This one counts for as much as a link, because a body factor is what an animal weighs, how big a mouthful it takes and what a gram of it costs to keep, and two creatures whose bodies have parted make a child priced like neither of them.

// internal/gene/kinds.go

// Sorting is the rule that decides which two creatures are near enough
// each other to have a child together: the four weights the
// compatibility distance is added up out of, the threshold two genomes
// have to be inside, and whether any of it is switched on at all.
//
// It is off at the zero value, so a pool that leaves it alone breeds the
// way a pool always bred and sorts nothing into anything.
type Sorting struct {
	// On is whether this valley sorts its creatures at all.
	On bool

	// The four weights, in the order the distance adds them.
	Excess   float64
	Disjoint float64
	Weight   float64
	Body     float64

	// Far is the threshold. Two creatures inside it may breed; two
	// outside it may not, and a child that is outside it from every
	// species alive opens one of its own.
	Far float64

	// Drifting is the representative rule as it is tempting to write
	// it: a species held by whichever member joined it last instead of
	// by the one that opened it. It is kept behind a flag so what a
	// moving representative does to a species can be run instead of
	// described, and it is false in every valley this book ships.
	Drifting bool
}

// Sorted is the rule every run in this book breeds under.
var Sorted = Sorting{On: true, Excess: 1.0, Disjoint: 1.0, Weight: 0.4, Body: 1.0, Far: 3.00}

// Small is the link count under which the excess and disjoint counts
// are left undivided.
//
// The two structural terms of the distance are counts of genes divided
// by how many genes the larger of the two wirings holds, so that a
// difference of ten links between two graphs of five hundred is not read
// as the same difference as ten links between two graphs of twelve.
// Under about twenty links that division stops being a fairness
// correction and becomes an eraser: one disjoint gene between two
// six-link wirings is a sixth of the whole controller, and dividing it
// by six calls it 0.17 when it ought to weigh a whole gene. So under
// this count the divisor is one and the counts are used as they stand.
//
// Nothing in this valley reaches it. A founding wiring here is a
// hundred and forty-four links and the operators only ever add, so the
// smallest graph any run of this book builds is seven times this
// number. The clause is here because the distance is written down once
// and used wherever a graph is, and a graph small enough to need it is a
// graph somebody will build one day on a bench.
const Small = 20

// internal/gene/kinds.go

// Terms is what one comparison of two genomes came to: the counts the
// distance is built out of and the number itself. It is handed back
// whole rather than as one float64 because every one of the four terms
// is a different kind of difference, and a run that prints only the
// total cannot say which of them moved.
type Terms struct {
	Same     int     // links both genomes carry, matched by the number on them
	Excess   int     // links past the last number the other one holds
	Disjoint int     // links inside that range the other one does not hold
	Links    int     // N: the larger link count, or 1 while both are under Small
	Weights  float64 // the mean gap between the weights of matched links
	Bodies   float64 // the mean gap over the ten body factors
	D        float64 // the four terms added up
}

	// Past this number one of the two has nothing to say, because it was
	// never handed a number that high. An unmatched link beyond it is
	// excess: wiring that arrived after the two lines parted. Inside it
	// the link is disjoint: wiring one line took up and the other, alive
	// at the time, did not.
	last := 0
	if len(xs) > 0 && len(ys) > 0 {
		last = xs[len(xs)-1].Innov
		if n := ys[len(ys)-1].Innov; n < last {
			last = n
		}
	}
	count := func(innov int) {
		if innov > last {
			t.Excess++
		} else {
			t.Disjoint++
		}
	}
	i, j := 0, 0
	for i < len(xs) && j < len(ys) {
		switch {
		case xs[i].Innov == ys[j].Innov:
			t.Same++
			t.Weights += abs(xs[i].W - ys[j].W)
			i, j = i+1, j+1
		case xs[i].Innov < ys[j].Innov:
			count(xs[i].Innov)
			i++
		default:
			count(ys[j].Innov)
			j++
		}
	}

$ go run ./cmd/kinds -mode pair | head -30
kinds: the distance between two genomes, term by term

  d = 1.0 x E/N + 1.0 x D/N + 0.4 x Wbar + 1.0 x Bbar, and the threshold is 3.00
  E and D are excess and disjoint link genes, N the larger link count,
  Wbar the mean gap between matched weights and Bbar the mean gap over the ten body factors

  two founders of one valley: 144 links each, every number minted at the same founding
  the two genomes                 E      D      N      Wbar      Bbar         d  may breed
  a founder and itself            0      0    144    0.0000    0.0000    0.0000  yes
  two founders                    0      0    144    0.1056    0.0000    0.0422  yes

  one lineage copied 2000 times off stream 16, with stream 19 growing its wiring
  the two genomes                 E      D      N      Wbar      Bbar         d  may breed
  a parent and its child          0      0    144    0.0452    0.0000    0.0181  yes
  a founder and birth 100         1      0    145    1.6094    0.6113    1.2620  yes
  a founder and birth 500        29     11    162    1.9918    1.1862    2.2299  yes
  a founder and birth 2000      124     21    247    2.0932    1.1587    2.5830  yes

  and the other founder's line, the same length, grown on other ticks
  the two genomes                 E      D      N      Wbar      Bbar         d  may breed
  the two at birth 1              0      0    144    0.1903    0.0075    0.0836  yes
  the two at birth 500           38     51    171    2.5674    1.4448    2.9923  yes
  the two at birth 2000         140    169    260    2.8481    0.9774    3.3051  no

  the last of those, added up in the open
    excess          140 links / 260  x 1.0 = 0.5385
    disjoint        169 links / 260  x 1.0 = 0.6500
    weights          99 matched, mean gap 2.8481 x 0.4 = 1.1392
    bodies           10 factors, mean gap 0.9774 x 1.0 = 0.9774
    d                                            3.3051

Species representatives

The mate rule the birth chapter built has two conditions in it. A creature looks inside a box six cells across, takes everybody in it that is over the breeding threshold, and one number off stream 18 picks among them; nothing in it has ever looked at what a neighbour is. Here is a third condition, and it is the only line anywhere in this pass that reads a genome.

// internal/gene/birth.go — inside Pool.suitor
		if !Ready(o) {
			continue
		}
		// The third condition, and the only one that reads a genome.
		// Two creatures whose wirings and bodies have drifted past the
		// threshold would make a child that inherits half of each and
		// works like neither, so past that distance they are not
		// candidates for one another. The comparison costs no number:
		// it is arithmetic over two genomes, and nothing about it can
		// move a stream.
		if p.Kinds.On {
			over++
			if !p.Kinds.inside(mine, p.genes[o.ID], mineAt, p.rank(o.ID)) {
				continue
			}
		}
		p.near = append(p.near, o)
		p.order = append(p.order, j)

Refusing a mate is half the job. The other half is the list of species itself, and it turns on one question that has a wrong answer everybody reaches for first: what is a species, in a program? It is not the set of its members, because the set changes every time something is born or dies and there would be nothing to compare a newcomer against. It is one creature, and everything within 3.00 of that creature's genome.

// internal/gene/kinds.go

// Folk is one species: the number it was given, the creature holding it,
// the ticks it opened and closed on, and where it came from.
//
// A species is held by a representative and is nothing more than that
// creature's genome plus the threshold. The first member holds it for as
// long as it lives; when that animal dies the earliest-born member still
// inside the threshold of it takes it over. Holding a species by its
// oldest member and not its newest is the whole of what stops a species
// walking: a list whose yardstick is replaced every time somebody joins
// can carry two animals at either end of it that are nothing like each
// other.
type Folk struct {
	No     int          // its number, and no species ever carries it twice
	Rep    sim.EntityID // the creature holding it now
	First  sim.EntityID // the creature that opened it
	From   int          // the species that creature was born into, 0 for a founding one
	Opened int          // the tick it opened on
	Closed int          // the tick its last member died on, 0 while it stands
	Born   int          // creatures ever sorted into it
	Live   int          // creatures standing in it right now
	Most   int          // the most that ever stood in it at once
	Turns  int          // times it changed hands
	Gap    float64      // how far the creature that opened it was from the nearest species then
}

// sort puts one creature into a species: the first open one whose
// representative it is inside the threshold of, walked in the order the
// numbers were handed out, and a new species of its own when there is no
// such one.
//
// Walking the list in number order rather than trying the parent's
// species first is what makes the answer a fact about the list and not
// about who asked. Two creatures with identical genomes sorted on the
// same tick land in the same species whatever their parents were doing.
func (p *Pool) sort(id sim.EntityID, tick int) int {
	g, ok := p.genes[id]
	if !ok {
		return 0
	}
	mine := p.rank(id)
	nearest := -1.0
	for _, f := range p.Folk {
		if !f.Open() {
			continue
		}
		rep, held := p.genes[f.Rep]
		if !held {
			continue
		}
		d := p.Kinds.terms(g, rep, mine, p.rank(f.Rep)).D
		if nearest < 0 || d < nearest {
			nearest = d
		}
		if d > p.Kinds.Far {
			continue
		}
		f.Born++
		p.kind[id] = f.No
		if p.Kinds.Drifting {
			f.Rep = id
			f.Turns++
		}
		return f.No
	}
	f := &Folk{No: len(p.Folk) + 1, Rep: id, First: id, Opened: tick, Born: 1, Gap: nearest}
	if k, ok := p.kin[id]; ok && k.Parent != 0 {
		f.From = p.kind[k.Parent]
	}
	p.Folk = append(p.Folk, f)
	p.kind[id] = f.No
	p.Opened++
	return f.No
}

$ go test -count=1 ./internal/gene/ -run 'AGenomeIsNoDistance|ExcessIsCounted|TheDivisorIsOne|ASpeciesOutlives|SortingSpendsNo' -v
=== RUN   TestAGenomeIsNoDistanceFromItself
--- PASS: TestAGenomeIsNoDistanceFromItself (0.00s)
=== RUN   TestExcessIsCountedPastTheOtherGenomesLastNumber
--- PASS: TestExcessIsCountedPastTheOtherGenomesLastNumber (0.00s)
=== RUN   TestTheDivisorIsOneWhileBothWiringsAreSmall
--- PASS: TestTheDivisorIsOneWhileBothWiringsAreSmall (0.00s)
=== RUN   TestASpeciesOutlivesTheCreatureThatHeldIt
--- PASS: TestASpeciesOutlivesTheCreatureThatHeldIt (0.00s)
=== RUN   TestSortingSpendsNoNumbers
--- PASS: TestSortingSpendsNoNumbers (0.02s)
PASS
ok  	theworld/internal/gene	0.019s

Before the valley, the smaller question: how far does one line actually walk? The bench grows a single lineage off one founder, six thousand births of copy, mutate and grow, and measures each stop against the genome it started as.

$ go run ./cmd/kinds -mode drift -births 6000
kinds: one lineage walking away from the genome it started as

  d = 1.0 x E/N + 1.0 x D/N + 0.4 x Wbar + 1.0 x Bbar, and the threshold is 3.00
  6000 births, one link in twenty and one node in fifty, off streams 16 and 19

    birth   links  hidden      E      D      N      Wbar      Bbar         d  may breed
        0     144       0      0      0    144    0.0000    0.0000    0.0000  yes
      600     172      14     41     13    172    1.9514    1.2697    2.3642  yes
     1200     212      27     88     20    212    1.8694    1.5404    2.7975  yes
     1800     239      32    116     21    239    2.1315    0.9794    2.4052  yes
     2400     266      32    143     21    266    2.0820    0.6691    2.1184  yes
     3000     300      32    177     21    300    2.0952    0.9642    2.4623  yes
     3600     321      32    198     21    321    2.0424    1.0667    2.5659  yes
     4200     342      32    219     21    342    1.9029    0.9807    2.4436  yes
     4800     367      32    244     21    367    2.0325    0.8573    2.3923  yes
     5400     387      32    264     21    387    1.8387    1.1683    2.6402  yes
     6000     409      32    286     21    409    2.0107    1.1184    2.6733  yes

  the first birth of this line outside the threshold from the founder
    birth 2196, at 3.0001: E 134, D 21, N 257, Wbar 2.2000, Bbar 1.5170

The distance is not a ratchet, and that is the finding in this run. It climbs to 2.7975 by birth 1,200, falls back to 2.1184 by birth 2,400, and is still wandering between 2.39 and 2.67 four thousand births after that. The reason is in the columns. D stops at 21 once the graph reaches its ceiling of thirty-two hidden nodes and never moves again; E climbs from 116 to 286 over the same stretch, but N climbs with it, so the two structural terms together climb from 0.57 to 0.75 over the six thousand births and are still climbing slowly at the last row of them. The weight term hovers near 2.0 times 0.4, because the mutation pass is as likely to move a weight back as onwards. What is left moving is the body block, ten numbers taking a random walk between their clamps, and it is the body block that decides whether any particular birth is inside the threshold or outside it.

So a line does cross. Birth 2,196 of this one is 3.0001 from the founder, over the line by one ten thousandth, and it is the first of six thousand births that gets there. Something has to happen to it.

$ go run ./cmd/kinds -mode chain -births 4000
kinds: one lineage of 4000 births sorted into species, held by the member that opened it

  d = 1.0 x E/N + 1.0 x D/N + 0.4 x Wbar + 1.0 x Bbar, and the threshold is 3.00
  every birth is the one before it copied, mutated and grown, and is sorted
  the moment it exists against the species standing at the time

    kind   opened  held by  members        gap     widest    pairs out
       1        0        0     3956          -     3.9005       824997
       2     2196     2196       41     3.0001     2.9810            0
       3     3675     3675        4     3.0050     0.0840            0

  3 species out of one line of 4000 births
  opened is the birth the species opened at, gap how far that birth was
  from the nearest species standing then, and pairs out how many pairs of
  one species are further apart than the 3.00 the threshold allows

// internal/gene/kinds.go — inside type Sorting struct
	// Drifting is the representative rule as it is tempting to write
	// it: a species held by whichever member joined it last instead of
	// by the one that opened it. It is kept behind a flag so what a
	// moving representative does to a species can be run instead of
	// described, and it is false in every valley this book ships.
	Drifting bool

$ go run ./cmd/kinds -mode chain -births 4000 -drifting
kinds: one lineage of 4000 births sorted into species, held by whoever joined it last

  d = 1.0 x E/N + 1.0 x D/N + 0.4 x Wbar + 1.0 x Bbar, and the threshold is 3.00
  every birth is the one before it copied, mutated and grown, and is sorted
  the moment it exists against the species standing at the time

    kind   opened  held by  members        gap     widest    pairs out
       1        0     4000     4001          -     3.9005       847423

  1 species out of one line of 4000 births
  opened is the birth the species opened at, gap how far that birth was
  from the nearest species standing then, and pairs out how many pairs of
  one species are further apart than the 3.00 the threshold allows

The 200-year species run

Now the valley, on the ground the senses chapter built and ran: sixteen by twelve cells, the rim cracked into pockets and walled so nothing leaves, the room rule on, twenty-five animals founded on stream 12 with a hundred and forty-four links apiece, the eight ground channels switched on and billed for. Every child sorted the moment it is born, every mate filtered by the threshold, and two hundred years of it.

$ go run ./cmd/kinds -mode herd -years 200 -every 20
kinds: 16x12 valley, tick 901, year 1 summer, 90 plants standing at 4654.1 grams

  25 creatures founded on stream 12, all of them species 1
  d = 1.0 x E/N + 1.0 x D/N + 0.4 x Wbar + 1.0 x Bbar, and the threshold is 3.00
  a cell of ground carries one body: yes.  the ground speaks: yes
  births with two parents when there is one to be had: 0.75 of them
  a species is held by its earliest-born member: yes

   year   alive     born   kinds   opened    shut     apart    widest
      2       9       14       1        1       0    0.1019    0.1657
      3       8       32       1        1       0    0.1806    0.3276
      4      19       53       1        1       0    0.1585    0.3764
      5      15       74       1        1       0    0.1917    0.5958
     21     333     1091       1        1       0    0.4083    0.8814
     41     333     1696       1        1       0    0.4352    0.8814
     61     336     1718       1        1       0    0.4365    0.8814
     81     335     1718       1        1       0    0.4368    0.8814
    101     336     1720       1        1       0    0.4370    0.8814
    121     337     1722       1        1       0    0.4375    0.8814
    141     336     1724       1        1       0    0.4380    0.8814
    161     336     1724       1        1       0    0.4380    0.8814
    181     336     1724       1        1       0    0.4380    0.8814
    201     336     1725       1        1       0    0.4382    0.8814

  25 founded, 1725 born, 1414 struck off, 336 still walking after 719550 ticks
  154473 creatures were asked for a child: 1725 made one, 17317 could not pay for it
  1540 births found a mate in reach and 185 found nobody at all

  every species this valley opened, and the tick it opened on
     no      tick    year   out of    first    born   most  turns       gap
      1       901       1        -        1    1750    377     13         -

  the 1 species still standing at the end, and 0 closed
     no   living  held by    opened      Bulk     links
      1      336      105       901    0.3685     145.0

  what the threshold was asked, and what it did
    creatures asked for a child                            154473
    of those, ones with a neighbour over the price         151479
    and of those, ones left with somebody to breed with    151479
    asks the threshold refused every neighbour of               0
    births that ended up with one parent                      185
    species opened, closed, and left standing                   1 0 1
    species that changed hands, and lost their holder          13 0

  the two genomes this valley ever held furthest apart, alive or dead
    genomes it made in all                                  1750
    the widest distance between any two of them            1.4647
    which two they were                                       126 1642
    the threshold two creatures have to cross to part         3.00
    generations the deepest creature stood from a founder       50

  the ground: 172 cells a root can live in, 48 of them pockets cracked into the rim
   kind in a crack    on soil
      1         92        244

  ground                cells        grams       a cell
  pockets in the rim       48          0.0          0.0
  open soil               124       2213.9         17.9

  living neighbours within 6 cells, counted once at the end, and how many
  of them are inside the compatibility threshold
  standing           creatures    mean near  mean inside
  in a crack               92       130.43       130.43
  on open soil            244       186.66       186.66

  719550 ticks in 7m12.095s, 1665 ticks a second (measured here; yours will differ)

The kinds column reads 1 on the second year and 1 on the two hundred and first, and on every row in between. One species, opened on tick 901 when the first founder was stood up, holding all 1,750 genomes this valley ever made, still standing at the close and never once split. The creature holding it changed thirteen times as one holder after another died and the species was handed to the earliest-born survivor, which is the one part of the register that got any exercise at all. Seven and a quarter minutes of an eight-core Ryzen 7 3700X went into that one row; the 719,550 ticks are the world and the minutes are the desk, which is what the label at the foot of the run is warning about.

The threshold block says the rest. A hundred and fifty-four thousand creatures were asked for a child; a hundred and fifty-one thousand of them had somebody in reach who was over the price of one; and the number of those the threshold refused every neighbour of is nought. Not a small number. Not one in ten thousand. In two centuries of a valley this rule never once said no to anybody. Everything the last four pages built ran on every one of those asks and changed nothing whatever: the mate every creature took, the child it made and the tick it died on are what they were in the valley that had no threshold in it.

That is the chapter's result and it deserves a straight explanation rather than a shrug. The two blocks underneath contain it. Over two centuries this valley made 1,750 genomes, and the widest distance between any two of them, living or dead, is 1.4647 of the 3.00 the threshold asks for. The deepest creature it ever produced stood fifty generations from a founder. The bench at the top of this page needed about two thousand two hundred births of one unbroken line before that line reached 3.00 from its own ancestor. Fifty against two thousand two hundred. This valley is not close to speciating; it is a fortieth of the way there.

Read the born column to see why fifty generations is all it managed. By the sixty-first year 1,718 animals had been born. By the two hundred and first, 1,725. Seven births in a hundred and forty years. The room rule fills a hundred and ninety-two cells of ground and then a birth has to wait for a cell to come free, and a cell comes free when somebody dies, and in a valley where three hundred and thirty-six well-fed animals are standing on a fixed larder almost nobody does. Two centuries of this ground is about forty years of history followed by a hundred and sixty years of the same three hundred and thirty-six creatures standing still: 1,696 of the run's 1,725 births are in by the forty-first year and twenty-nine arrive in the hundred and sixty after it. Generations are what drive two genomes apart, and after year forty this valley has almost stopped having any.

The widest column says the same thing from the other side, and says it more sharply than anything else in the run: 0.8814 in the twenty-first year, and 0.8814 in the two hundred and first. The two most distant animals alive in this valley have been exactly as distant as each other for a hundred and eighty years. Nothing is drifting. There is one gene pool, everybody in it can breed with everybody else, three births in four are crossings whenever there is anybody to cross with, and crossing is a mixer: it pulls the population back together at least as fast as mutation pushes it apart. That last clause is measurable, and the bench measures it on the one pair on this page that is outside the threshold.

$ go run ./cmd/kinds -mode pair | tail -9
  a child of that pair, every gene the crossing could award awarded
  the two genomes                 E      D      N      Wbar      Bbar         d  may breed
  the two parents               140    169    260    2.8481    0.9774    3.3051  no
  the child and the first         0      0    247    0.5093    0.4178    0.6215  yes
  the child and the second      140    169    260    1.5774    0.5597    2.3791  yes
  with the unmatched links from the parent of record
  the child and the first       140    169    260    1.2707    0.4178    2.1145  yes
  the child and the second        0      0    260    0.6006    0.5597    0.7999  yes
  with the unmatched links from the other parent

Two parents 3.3051 apart, too far to have this child at all under the rule this chapter built, and every child of them is comfortably inside the threshold of both. Taking the unmatched links from the parent of record puts the child 0.6215 from that parent and 2.3791 from the other; taking them from the other side puts it 2.1145 and 0.7999. The two structural terms collapse to nothing on whichever side gave the wiring, because the child holds exactly that parent's links, and the weight term roughly halves on both sides because each matched weight came off a coin. One crossing pulls a pair most of the way back together. A valley in which 1,540 of 1,725 births had a second parent in reach, with every animal in reach of every other, is a valley that cannot come apart.

Rim pockets and breeding cost

There is no shared score in this valley to protect a young lineage with. A new arrangement of wiring is judged against the whole population from the tick it appears, by the only judge there is, which is whether the animal carrying it can put the price of a child in its store. The thing that is supposed to give a new lineage room to be tested is the ground itself: the terrarium volume cracked the rocky rim into pockets a narrow root can hold in, and an animal in one of those is competing with what is in the pocket rather than with the whole valley. The last three blocks of the run are that claim, measured.

What it buys is real and it is small. A creature standing in a pocket has 130.43 other animals within six cells of it; a creature on open soil has 186.66, and on both counts every one of those neighbours is inside the compatibility threshold. Sheltering in the rim means meeting a third fewer of the valley than standing in the middle of it. Ninety-two of the three hundred and thirty-six survivors are doing exactly that.

What it charges is on the line above. The forty-eight pockets carry 0.0 grams of standing tissue between them at the close of the run, against 2,213.9 grams on the hundred and twenty-four cells of open soil. A pocket is a crack in rock holding a quarter of a cell of soil, so it grows a quarter of the food when it grows any, and after two centuries of animals standing on it, it grows none. The shelter and the hunger are the same fact: what thins the crowd is that there is nothing there to bring a crowd.

Two more charges belong on the page, and neither is measured because neither is measurable in a valley holding one species. A refuge has no opinion about what it is sheltering, so it keeps a lineage that is going nowhere alive exactly as well as it keeps a promising one; a shared score at least knows what it is protecting and from what. And a refuge cannot be set: it is a fact about the terrain the world generator handed out, so a run on a map whose rim came out smooth has no refuges at all and no dial anywhere to give it any. What this page can say for the pockets is that they thin the crowd by a third and starve whoever uses them. What it cannot say is that they protected anything, because in two centuries nothing here needed protecting.

One honest sentence about the seed, and then the general point. This is one run, on one ground, from one founding, and a different map with a longer rim or a wider gap between its feeding grounds would give a different answer. But the direction of the answer is not about this seed. Six cells is the distance a creature looks for a mate, and this valley is sixteen cells across; a box thirteen cells on a side laid anywhere on that ground covers most of it. Every animal here can reach every other animal, and a population where everybody can reach everybody is one population by definition, however long you run it.

Why species protect crossings

Strip the valley out and there are three separate things on this page, and only two of them did any work.

A distance turns a comparison into a number, and the units have to be beaten flat first. Four kinds of difference went in: two counts of genes, a mean gap between weights and a mean gap between body factors. Counts of genes were divided by how many genes there were, so that ten differences in five hundred is not the same reading as ten in twelve. Weight gaps were multiplied down, because a dial that has moved is a smaller change than a wire that is missing. What comes out is one number, and everything after it is a comparison against a threshold. That pattern is older than this book and it turns up anywhere two structured things have to be told apart: normalise each kind of difference in its own currency, weight the currencies against each other on purpose and in the open, then add.

A boundary has to be anchored to something that stopped moving. The register holds a species as one genome and a radius. That genome belongs to a creature that may be dead, and when the species changes hands it goes to the earliest-born survivor and not the newest arrival, and the failure above is what the other choice costs. A rule that re-reads its reference point from the thing it is measuring measures nothing, and it will not tell you: it returns confident answers for ever, and a line of four thousand copies comes back as one happy family.

A threshold is a ruler and not a mechanism. This is what the two centuries taught, and it is the part to carry away. Building a compatibility distance and setting it at 3.00 does not make species any more than owning a tape measure makes a building. Two populations become two species when they stop breeding with each other, and they stop breeding with each other because something keeps them apart long enough for drift to do its work: a mountain, a river, a difference in season, a mate box smaller than the ground. The threshold is what notices afterwards. Put it in a valley where every animal can walk to every other animal in a few days and it will notice, correctly and for ever, that there is one kind of animal here.

What this valley is missing is distance, not a rule. A run that wants two kinds of animal in it needs ground wide enough that a six-cell mate box is a small part of it, or a population that turns over often enough for fifty generations to become two thousand, and the honest state of this book is that a ground that wide costs more ticks than a two hundred year run can afford at the pace this one runs at. The machinery is built, it is exact, the arithmetic is pinned by five tests, and it is waiting for a world big enough to need it.

Every genome in that two-century run is still sitting in the pool at the end of it, 1,750 of them, and every one of the 1,414 animals struck off left its genome behind. That is a run's whole history held in one process on one machine, readable only for as long as the program is alive and gone the moment it stops. The next thing this valley needs is a place to put it that survives the run.