Seeds Ride the Wind
The empty annual
The annual in the calendar run dies with no child behind it, because every plant so far was placed by a person. A world cannot require that hand. A seed is paid for with standing mass, carried as a particle by the wind, held in a seed bank after landing, and allowed to germinate only when the ground can pay the seedling's first bill.
Reproduction without a price fills the map with copies that came from nowhere. This version spends grams the parent could have kept, counts the seeds blown out of reach, and lets the soil refuse a seed that lands where roots cannot live.
Two random streams are claimed by the world seed and by nothing else: stream 8 moves seeds through the air, and stream 9 decides which waiting seeds try to start. A plant added to one corner cannot shift another plant's germination draws.
Seed cost
Start with the money, because the money settles the design. A species row already carries the mass a seedling germinates at. That same number is what one seed costs to build, and saying so out of the same field is not a shortcut: a seed is a packet of tissue with a seedling's worth of tissue in it, and if the two numbers could differ, one of them would be an invention.
Four more numbers finish the row. The share of its standing mass a plant turns into seed when it seeds, how fast a seed of that kind sinks through the air, the chance a seed on the ground breaks dormancy when it is asked, and how many ticks it keeps before it is dead. Everything else about reproduction is arithmetic on numbers that were already there.
// internal/terra/species.go — the fourth block of the row
// the next generation
Spend float64 // the share of its standing mass it turns into seed
Sink float64 // cells of height a falling seed loses in a tick
Take float64 // the chance a seed on the ground tries to germinate
Viable int // ticks a seed keeps in the ground before it is dead
// Clutch is how many seeds this much standing tissue pays for: the
// share of itself the row spends, divided by what one seed costs. The
// remainder is not spent, so a plant too small to pay for one whole
// seed makes none.
func (s Species) Clutch(mass float64) int { return int(mass * s.Spend / s.Seed) }
// Ripe is the least mass that pays for one whole seed.
func (s Species) Ripe() float64 { return s.Seed / s.Spend }
// Payback is how many ticks this row needs to close nine tenths of a
// gap between its mass and its ceiling. It depends on the upkeep alone:
// a gap shrinks by that share of itself every tick, whatever opened it.
func (s Species) Payback() float64 { return math.Log(0.1) / math.Log(1-s.Upkeep) }
Ripe is a threshold nobody typed. A row that spends a fifth of itself on
seeds costing a quarter of a gram each cannot make a whole seed until it is standing at
1.25 grams, and that figure moves the moment either field moves. Thresholds that are
computed cannot drift out of agreement with the numbers they came from, and a
hand-typed one always eventually does.
Payback is the number that says whether a plant can afford any of this, and
it is do it on paper before the code runs.
Numbers first. A tree standing at 600 grams on open ground earns 3.0 energy units a tick and pays 0.005 of upkeep on every gram, so 600 is exactly where its income and its bill meet. Spend a tenth of it on seed and 540 grams are left standing, 60 grams short of the ceiling. What happens next tick is the growth arithmetic from the start of this volume: income 3.0, bill 540 × 0.005 = 2.7, so 0.3 grams go back on. The tick after that the bill is a shade higher and the gain a shade smaller.
The gap between a plant and its ceiling closes by the same fraction every tick, and that fraction is the upkeep. Write the gap g, the upkeep u, and the number of ticks t:
gap after t ticks = g × (1 − u)t
Turn it round to ask how long a given recovery takes. To close nine tenths of the gap, the surviving tenth is 0.1, so:
t = log(0.1) ÷ log(1 − u)
For the tree, log(0.1) ÷ log(0.995) = 459 ticks, which is half a season. For the herb at 0.05 of upkeep it is 45 ticks, ten times faster, and the herb is spending half of itself where the tree spends a tenth. That is the whole trade-off in one line: cheap tissue makes a plant that pays for its seeds slowly, expensive tissue makes one that pays for them at once and can never make many at a time. Notice what is missing from the formula. The size of the clutch does not appear, so how long a plant needs to recover does not depend on how much it spent, only on the row it belongs to.
The other half of the design is when. A tick number would work and would be a lie: a plant that seeds on tick 1801 because 1801 is written in the source is not keeping a calendar, it is keeping an appointment. The calendar built in the last chapter already knows when each row's leaves are up, so let the answer come from there. A row seeds on the tick its own window shuts. The annual spends everything it has as its last act; the perennials cash out as their leaves come down. Four rows reading two different signals at four different thresholds seed on four different days of the year, and not one of those days appears anywhere in the code.
$ go run ./cmd/seeds -mode row
seeds: what one clutch costs the plant that pays for it
each row at the mass it settles at alone on open ground, 12.00 of daylight
ceiling spend a seed seeds grams left with payback
moss 36.00 0.20 0.25 28 7.00 29.00 114
herb 72.00 0.50 1.00 35 35.00 37.00 45
scrub 180.00 0.25 0.50 90 45.00 135.00 287
tree 600.00 0.10 2.00 30 60.00 540.00 459
ripe at height sink ticks up light water nutrient
moss 1.25 0.07 0.50 1 0.1333 0.0024 0.0003
herb 2.00 1.58 0.40 4 1.6667 0.4500 0.1000
scrub 2.00 2.16 0.35 7 0.6667 0.0200 0.0048
tree 20.00 18.00 0.50 36 0.4000 0.0600 0.0150
cue wake opens shuts ticks up seeds on
moss warmth 0.15 6 2695 2689 2695
herb warmth 0.50 450 2251 1801 2251
scrub daylight 0.80 3406 1995 2189 1995
tree daylight 1.00 0 1801 1801 1801
Every figure in the first table is a multiplication and a division you can do in your
head, with one exception that is instructive. The herb's ceiling is 72 grams and half of
72 is 36, so its clutch should be 36 seeds; the run says 35. The ceiling is not exactly
72 in a float64, it is 71.99999999999999, because it came from 12.00
× 0.30 ÷ 0.05 and the middle step is not representable. Half of that is a
hair under 36, and int in Go truncates. This is a fair answer to an unfair
question: a plant hovering exactly at a whole number of seeds is one atom of tissue away
from the other answer either way.
The last table is the one to keep. Four rows, four seeding days, and the spread between
them is nearly a thousand ticks: the tree on the autumn equinox, the scrub a hundred
and ninety-four ticks after it, the herb two hundred and fifty-six after that, the moss
not until deep autumn. Change one
Wake threshold and the day moves with it, because the day is a reading of
the year and not a constant.
Seeds as particles
What flies is already built. The weather chapters made a particle out of a body with a birth tick and a death tick on it, gave it an emitter that draws its numbers from a seeded stream, and put the whole population in a pool that is allocated once and reused forever. Rain, fire and pollen were three filled-in copies of that one type. A seed is a fourth, plus one number none of the weathers needed.
That number is how much air is still under it. The valley is drawn from above, so there is no down on the grid to fall along: a seed's position is where it is over the map, and its height is a separate column that loses the same amount every tick. That makes the fall trivial and the lifespan meaningful. A raindrop dies of old age at a tick the emitter drew for it. A seed's death tick is its height divided by its sink rate, so how long it stays up is decided by how tall its parent got, and everything about dispersal follows from that one sentence.
// internal/terra/seed.go
// Seed is one of the particle chapter's bodies with a species written
// on it and one number the weather never needed: how much air is still
// underneath it. A raindrop dies of old age. A seed dies when it lands,
// and where it lands is the whole point.
type Seed struct {
field.Particle
Kind int // the row of Flora this came off
From sim.Coord // the cell it was released over
Up float64 // cells of air still under it
Sink float64 // cells of that it loses every tick
}
// Step flies every seed one tick and hands back the ones that touched
// down. Two forces act: the wind at the place the seed happens to be,
// read out of the field chapter 27 wrote, and the drag that keeps it
// from ever going faster than that wind. Nothing pulls it sideways
// towards the ground, because the ground is not sideways: the fall is
// the Up column, and it comes down by the same amount every tick.
func (a *Air) Step(t uint64) []Seed {
var landed []Seed
live := a.pool[:a.n]
for i := range live {
s := &live[i]
s.ApplyForce(a.Wind.At(s.Pos))
s.ApplyForce(a.Drag.Force(s.Body))
s.Step()
s.Up -= s.Sink
}
for i := 0; i < a.n; {
if a.pool[i].Up > 0 {
i++
continue
}
landed = append(landed, a.pool[i])
a.pool[i] = a.pool[a.n-1]
a.n--
}
return landed
}
Two lines carry the chapter. a.Wind.At(s.Pos) is the wind field of the
forces volume, which answers with a force for any position in the world and not only for
the cell centres it was written down at; a seed drifting between two cells feels a blend
of both. a.Drag.Force(s.Body) is the same drag that gave a falling stone a
terminal speed, and it does the same job here: a force that grows with speed until it
cancels the wind, so a seed approaches the wind's own pace and never passes it.
The retirement loop is the pool from the particle chapter, unchanged in structure and changed in meaning. There, a particle whose death tick had come was gone. Here it is handed back, because a seed that has finished flying is the only interesting thing a seed ever does.
Now measure the thing. A dispersal kernel is the answer to one question: drop a great many seeds off one plant and count where they land. Nothing about it should be guessed, because all of it can be predicted from four numbers and then checked.
$ go run ./cmd/seeds -mode kernel
seeds: 1000 tree seeds off one plant of 600.00 grams, on open ground
let go 18.00 cells up, sinking 0.50 a tick give or take three tenths of that
the wind is 0.50 east everywhere, the air is 0.25 thick
east seeds share
0 4 0.4%
1 87 8.7% ################
2 150 15.0% ###########################
3 197 19.7% ####################################
4 179 17.9% ################################
5 217 21.7% ########################################
6 102 10.2% ##################
7 56 5.6% ##########
8 8 0.8% #
mean flight 37.68 ticks, mean landing 3.844 cells east and 0.042 north
east from 0.390 to 7.969, north from -2.589 to 2.583, all 1000 landed
on paper: a ceiling of 2.00 pixels a tick, reached over 7.0 ticks,
carried for 37.68 ticks, is 61.44 pixels or 3.84 cells east
The paper line and the measured line agree to two decimal places, and the paper line is three numbers long. A wind of 0.50 against a drag of 0.25 gives a ceiling of 2.00 pixels a tick, whatever the seed weighs. A seed of two grams takes about seven ticks to get most of the way to that ceiling. Carried for 37.68 ticks, less the seven it spent getting up to speed, that is a little over 61 pixels east; a cell is sixteen pixels, so 3.84 cells. The run says 3.844.
The two ends of the histogram are the two things a kernel is for. Four seeds in a thousand come down with no easting worth the name and eight get eight cells away, from one plant, in a wind that never varied: the spread is almost all sink rate, which is drawn within three tenths either side of the row's figure, and a seed that sinks slowly is a seed that is carried longer. The north column is the other half. Nothing pushes a seed sideways here at all, and the seeds still land within two and a half cells north and south of the parent, because a seed lets go from somewhere in the crown and this crown is two and a half cells across.
$ go run ./cmd/seeds -mode reach
seeds: 1000 seeds off one grown plant of each row, on open ground
the wind is 0.50 east everywhere, the air is 0.25 thick
grams height sink ticks up own cell mean furthest north
moss 36.00 0.07 0.50 1.00 87.6% 0.125 0.624 0.499
herb 72.00 1.58 0.40 4.64 11.7% 0.306 1.896 1.528
scrub 180.00 2.16 0.35 6.88 4.7% 0.735 3.401 2.508
tree 600.00 18.00 0.50 37.68 0.1% 3.844 7.969 2.589
The sink rates in that table are all within a factor of one and a half of each other and the mean distances differ by a factor of thirty. Height does all the work, and height came out of the mass, and the mass came out of the light and the upkeep six chapters ago. Nobody decided that a moss disperses badly. Eighty-eight per cent of its seeds land on the cell they were made on because a moss stands seven hundredths of a cell tall and is in the air for one tick.
Germination refusals
Landing settles almost nothing. Four of the answers are final: a seed carried over the rim is gone from the world, a seed on rock or in the pond is tissue lying where nothing will use it, and a seed the pool had no slot for was never in the air. The fifth answer, soil, starts an argument.
The species chapter worked out two light figures for every row: the light at which a seedling stops shrinking, and the light at which it can afford the first branching of its own grammar. The first is a bad test, because a plant that is alive and permanently a single stroke of stalk is not a plant that is going to reproduce. The second is the right one, and it generalises cleanly. The bill is the upkeep on the tissue that first branching costs; the income is whatever the cell can pay, priced the way a grown plant prices it, smallest of light, water and nutrient. A seedling that cannot cover the bill does not start, and the reason it did not start is the name of whichever resource ran out.
// internal/terra/valley.go
// try is the germination gate. A seed asks four questions in order and
// stops at the first no: is this a time of year my own kind has its
// leaves up, is the cell free, do I break dormancy at all, and can the
// ground pay a seedling's first bill. The three resources are
// compared exactly the way a grown plant compares them, so the reason a
// cell says no is the name of whichever one ran out first.
func (v *Valley) try(k int, c sim.Coord, warm float64) (bool, int) {
s := Flora[k]
if up, _ := s.Awake(v.Climate, Angle(v.Now)); !up && !v.Eager {
return false, OutOfSeason
}
if v.Taken(c) {
return false, Occupied
}
if v.wake.Float64() >= s.Take {
return false, Asleep
}
p := s.Physiology()
g := v.Bed.Offer(c, p.Root, v.Sky.At(c))
e, name := p.Limit(g)
if e*warm < s.Start() {
switch name {
case "water":
return false, TooDry
case "nutrient":
return false, TooPoor
}
return false, TooDark
}
v.sprout(k, c)
v.Seed.Fate[k][Grew]++
return true, 0
}
The Eager field in the first line is the version of this gate the chapter
gets wrong below, kept behind a flag so the mistake can be run instead of described.
Past that, one Float64 off stream 9 is the only random number in the gate.
Everything else is the ledger, the bed and the sky answering questions they have been
answering since chapter 36, which is why the refusal reason can be the resource's own
name: it is the string Limit already hands back.
A no here is not a death. The seed goes into a bank, cell by cell, and is asked again on the turn of every season for as long as its row keeps its seeds viable. That is what makes the first question the question matters: a seed that lands in autumn is refused for the season and lies there until the spring its own kind wakes in.
$ go run ./cmd/seeds -mode gate
seeds: the bill a seedling has to be able to pay on the cell it lands on
upkeep on the tissue its own first branching costs, earned out of
the smallest of light, water and nutrient, times the day's warmth
bill gen 1 light of full
moss 0.0080 0.40 0.1333 1.1%
herb 0.5000 10.00 1.6667 13.9%
scrub 0.0800 10.00 0.6667 5.6%
tree 0.1000 20.00 0.4000 3.3%
under n crowns of a 600-gram tree, at midsummer: warmth 0.8536
crowns light moss herb scrub tree
0 12.0000 yes yes yes yes
1 1.7143 yes no yes yes
2 0.2449 yes no no no
3 0.0350 no no no no
under n crowns of a 600-gram tree, at the spring equinox: warmth 0.1464
crowns light moss herb scrub tree
0 12.0000 yes yes yes yes
1 1.7143 yes no no no
2 0.2449 no no no no
3 0.0350 no no no no
the least a cell can hold and still start one, at midsummer
cells light moisture nutrient
moss 4 0.1562 0.0007 0.0001
herb 6 1.9526 0.0879 0.0195
scrub 12 0.7810 0.0020 0.0005
tree 10 0.4686 0.0070 0.0018
One crown overhead already settles who gets to be there. In full midsummer the shade of a single grown tree admits a moss, a scrub and another tree, and refuses a herb, which wants nearly fourteen per cent of the valley's average daylight before it will start. Under two crowns only the moss will begin, and under three nothing will. The same table at the spring equinox is a different valley: the warmth multiplier is 0.1464 instead of 0.8536, so the cell under one crown that starts three rows at midsummer starts one of them in spring. A gate that is checked once is a gate whose answer depends on the day it was asked.
The bottom table is the moisture floor stated as a number a cell either has or does not. The herb needs 0.0879 of a unit in each of its six root cells, more than a hundred times what a moss needs, and it needs that much because it drinks 0.90 of a water unit for every unit of energy it fixes and its first branching costs ten grams. Thirst, grammar and root radius, all three of them already in the row, and none of them written down anywhere as a germination rule.
Put the whole thing in one valley and keep books on it. The volume already prints two identities every year: every gram ever manufactured is standing, lying dead, burned or rotted, and every nutrient unit the valley opened with is in a body, a pile or the soil. Seeds add two more places for a gram to be, one of which is new in kind. A gram can be in the air, and a gram can be over the rim and gone.
$ go run ./cmd/seeds -mode valley -years 6
seeds: 12x8 valley from seed 5, 44 soil cells, 12.00 light on an average day
founded in mid spring with one plant of each row, and censused
at every midsummer after that; every plant but the first four is a seed
year moss herb scrub tree released grew waiting flying standing
1 1 1 1 1 0 0 0 0 637.3
2 1 3 10 1 88 13 41 0 1531.1
3 1 5 22 4 533 36 281 0 2983.4
4 0 0 27 7 1348 50 736 0 3343.1
5 0 0 30 7 2321 59 1221 0 3132.3
6 0 0 32 6 3328 70 1518 0 2962.6
every seed this valley has released, and where it is now
released grew waiting flying off map rock pond aged no slot
moss 6 3 0 0 0 0 0 3 0
herb 67 20 15 0 0 13 10 9 0
scrub 3187 38 1496 0 370 737 287 259 0
tree 68 9 7 0 13 19 16 4 0
all 3328 70 1518 0 383 769 313 275 0
released less every column after it: 0
why the ground turned one away, counted every time it happened
out of season the cell was taken still asleep light water nutrient
moss 28 11 0 0 0 6
herb 216 102 15 0 0 12
scrub 5511 9464 93 0 0 4
tree 51 29 27 0 3 1
the books in grams the books in nutrient units
standing 2962.5924 in living tissue 224.032584
in the air 0.0000 in the air 0.000000
in the bank 777.0000 in the bank 49.980000
lying dead 0.9625 lying dead 191.522371
burned 123709.2782 in the soil 47.465045
rotted 840.0170 blown away 15.000000
blown away 211.0000 the valley opened 528.000000
ever built 128500.8501 difference -0.000000
difference 0.0000
Read the second table across the moss's row and the story is four numbers long: six seeds ever made, three of them grew, three of them lay in the ground until they were dead. A plant seven hundredths of a cell tall that spends a fifth of two and a half grams does not get many chances. The scrub's row is the same table run at a different scale, 3,187 seeds against the moss's six, and the interesting figure in it is 737 on rock: a fifth of everything the scrub has ever made came down on the rim of the valley.
The refusal table is where the shape of this particular valley shows. The two biggest columns by a wide margin are out of season and cell taken, and light and nutrient between them account for twenty-six refusals in six years. That is not the gate failing to matter. It is a valley whose plants are small enough to cast thin shade, where the binding constraint on a seed is that somebody is already standing there. A run that grows big trees would move the weight of that table onto the light column, and the column is there to be read either way.
Both differences are zero, and the second one is the one that changed. 211.0000 grams and 15.000000 nutrient units left this valley on the wind over six years, and neither column existed before this page. The chapter before this one could say flatly that matter goes round a valley while energy passes through it. That is no longer true. Seeds are the first thing in this world that can carry matter over the rim, and the books balance only because the amount that left is counted where it went.
The first version of the gate had three questions, not four. Nothing about the time of
year: a seed lands, the cell is free, it wakes, the ground can pay, so it grows. That is
the obvious design and it is what the flag -eager still runs.
$ go run ./cmd/seeds -mode valley -years 6 -eager
year moss herb scrub tree released grew waiting flying standing
1 1 1 1 1 0 0 0 0 637.3
2 1 0 12 3 88 18 36 0 1903.7
3 1 0 24 7 575 45 302 0 3285.3
4 1 0 25 10 1369 55 741 0 3138.8
5 0 0 28 8 2305 67 1219 0 2983.6
6 0 0 34 7 3349 82 1508 0 2847.1
every seed this valley has released, and where it is now
released grew waiting flying off map rock pond aged no slot
moss 5 5 0 0 0 0 0 0 0
herb 25 14 0 0 0 6 1 4 0
scrub 3232 50 1499 0 366 730 304 283 0
tree 87 13 9 0 13 19 27 6 0
The census column for the herb reads 1, 0, 0, 0, 0, 0. The seed ledger on the same run says fourteen herbs germinated. Both numbers are correct and they cannot both be describing a valley that has herbs in it.
The clue is the two columns beside it: waiting 0, aged 4. Fourteen of the twenty-five herb seeds germinated and only four ever spent a season lying in the ground, so the gate was saying yes on the tick the seed landed nearly every time it was asked. Now put that beside the seeding rule. A row seeds on the tick its own window shuts, the herb's window shuts at 2251, and its seeds are in the air for four ticks. Every herb seed this world has ever made comes down around tick 2255, with the herb's own season over.
The rest is the tick order, which the last chapter set out and this one did not revisit. Germination happens in the middle of a tick; the death sweep happens at the end of it; and the death sweep kills an annual whose window has shut. So each of those fourteen herbs germinated in autumn, stood for the remainder of one tick, and was swept. The ledger counted the germination because a germination is what happened.
The fix is the first question in the gate, and it costs one line. The general lesson is about counters and not about plants. A counter that goes up when a thing starts is not evidence that the thing exists. Fourteen herbs germinated is true, and it was the wrong quantity to be watching: the honest column was the population, and the column that explained it was the empty one nobody thinks to look at. When two ledgers disagree with the world, the one that is counting events is usually the one that is lying to you, and a zero in an unexpected place is where the lie starts.
Tick 5597 seed burst
None of this needs a picture to be correct and all of it is easier to believe with one. The client has been drawing the valley since the second volume and drawing plants with a turtle since the third; a seed in flight is one lit pixel at a position the simulation already holds. The bench prints the cells as characters as well, which is the form that survives being pasted into a log.
$ go run ./cmd/seeds -mode frame -at 1996,2000,4501
seeds: 12x8 valley from seed 5, drawn 192 by 128 pixels
. soil ~ water # rock * seed in the air m h s t a plant standing
tick 1996, autumn, daylight 0.7987, 4 standing at 354.6 grams, 66 seeds up
moss 1 herb 1 scrub 1 tree 1, 2 waiting in the ground
############
#m..h......#
#..........#
#.~~~~~*****
#.~~~~~*****
#...~~~**s**
#.t.~...****
#######****#
frame 5e62ad4407405a100672a78c9ab7f7d084f43d42b9095fe1f7480047bc2355cd
tick 2000, autumn, daylight 0.7948, 4 standing at 354.2 grams, 26 seeds up
moss 1 herb 1 scrub 1 tree 1, 31 waiting in the ground
############
#m..h......#
#..........#
#.~~~~~*****
#.~~~~~~*.**
#...~~~~*s**
#.t.~...**.*
#######*#*##
frame c40e6a21b7b796411fd5a757c5dfb66db1e391b67762df5cdeb29a8e9a61c176
tick 4501, summer, daylight 1.6000, 15 standing at 1531.1 grams, 0 seeds up
moss 1 herb 3 scrub 10 tree 1, 41 waiting in the ground
############
#m..h......#
#..hh......#
#.~~~~~..ss#
#.~~~~~~sss#
#...~~~~sss#
#.t.~....ss#
############
frame d80a69e70932e916d0f284cbf5637e4e7839b67d8bbe171e61bff748e5bb868d
The figure below is a later tick. Save that second autumn with its own capture command:
go run ./cmd/seeds -mode frame -at 5597 -shot assets/frames/seed-burst.pngSixty-six seeds leave one scrub on tick 1995 and cover the whole east side of the map by 1996, which is what a crown two and a half cells across looks like from above. Four ticks later, forty of them are down and the bank has gone from two seeds to thirty-one; the ones still up have moved a cell east, and two of them are over the rock at the bottom of the map, which is two seeds about to become litter. Then skip to the following midsummer. Nine scrubs are standing on the cells the shower covered, two herbs stand beside their parent, and the two plants on the west side are exactly where they were.
Compare the 4501 map against the 1996 one cell by cell: every one of the nine new scrubs is standing where a star was. The two new herbs are not, because they came out of a burst of their own two hundred and fifty-six ticks later. That is the claim this chapter is actually making, and it is checkable by eye.
assets/frames/seed-burst.png: tick 5597, the second autumn of the run,
with eleven scrubs letting go at once and 331 seeds in the air. The pale drift running
out past the eastern rim is the one way matter leaves this valley: 383 seeds go that way
over the six years of the run.
One frame digest is needs pointing out. The map at tick 1996 and the map at tick 2000 hold the same four plants at almost the same masses, and the two digests have nothing in common, because sixty-six pixels moved. A picture hash over a valley with weather in it is not a test that the plants are right; it is a test that nothing in the whole pipeline, from the seed's position to the last rounding in the line routine, has moved since the last run.
Three refusals
The pattern under this page is a pipeline where every stage is allowed to say no, and where saying no is a routing decision rather than a deletion. A seed leaves the parent, the air moves it, the ground judges it, and at each of those points it either continues or goes somewhere specific and countable. There is nowhere for it to stop being. That is why the ledger can close: the identity at the bottom of the run is not a check bolted onto the design, it is the design written out.
The second idea is that one no is different from the others. Failing the light bill is temporary, because light is a property of the day and the day changes; landing in the pond is not. Separating those two turned a mechanism that would have been a coin flip into a memory: the bank holds the valley's unspent options, and a species that keeps its seeds viable for three years is a species that can lose three years in a row and still be here. Any simulation with a stochastic gate in it should ask the same question about its failures, because the answer decides whether the system has a memory at all.
The third is that almost nothing here is a new number. The distance a seed travels is its parent's height over its sink rate, and the height came out of the mass. The clutch is the mass times a share. The germination bill is the upkeep on a generation of the same grammar that draws the plant. Four fields were added to the species row and the rest of the chapter is arithmetic on fields that were already there, which is the return on having put every number in one block two chapters ago.
Look at the six-year census once more without the seed columns. The scrub goes 1, 10, 22, 27, 30, 32 on a valley with 44 cells of soil in it, and the moss and the herb, both present in years two and three, are gone by year four. Nothing was tuned to produce that. The scrub has the cheapest tissue of the four, a root that reaches three cells, and ninety seeds a year to spend, and the arithmetic did the rest. Whether a valley that fills up with one species is a working world or a broken one is a question about what happens next, and this run is only six years long.
Reproduction checkpoint
- Given a row's spend share, seed mass and ceiling, you can work out its clutch, the grams it is left standing with, and the mass below which it cannot make one seed at all.
- turn an upkeep into a payback time with one logarithm, and say why the size of the clutch does not appear in that formula.
- Handed a plant's height and sink rate, plus the wind and the drag, you can predict the mean landing distance in cells and check it against a measured histogram.
- state the germination bill for a row in three currencies, and read off the crown table which rows can start under one, two and three canopies at midsummer and at the equinox.
- Given a seed ledger, you can name every column a released seed can be in, and say which of them are final and which one loops.
- Shown a run whose germination counter climbs while its population stays at zero, I go looking for the tick order before go looking for the arithmetic.
Exercise 1 — halve the tree's sink rate. Before running
anything, predict what halving it does to the tree's flight time and to its mean
landing distance, then check with
go run ./cmd/seeds -mode kernel -sink 0.25.
Flight time is height over sink, so halving the sink doubles it, from 37.68 ticks to about 75. The distance is not doubled, because the seven-tick start-up is paid once either way: 2.00 × (75 − 7) = 136 pixels, or 8.5 cells against 3.84.
$ go run ./cmd/seeds -mode kernel -sink 0.25 | tail -9
12 57 5.7% #############
13 36 3.6% ########
14 14 1.4% ###
mean flight 74.86 ticks, mean landing 8.484 cells east and 0.042 north
east from 3.871 to 14.344, north from -2.589 to 2.584, all 1000 landed
on paper: a ceiling of 2.00 pixels a tick, reached over 7.0 ticks,
carried for 74.86 ticks, is 135.71 pixels or 8.48 cells east
Now hold that against the valley, which is twelve cells wide with a rock rim around it. A mean of 8.484 cells east and a furthest of 14.344 puts most of a tree's clutch over the edge of the world, and the off-map column of the seed ledger is where that shows up. Dispersal that is excellent on an open plain can be fatal in a small valley.
Exercise 2 — make the herb's seeds cheaper. Halve the herb's seed mass to 0.50 and predict three things: its clutch, its germination bill in light, and whether more herbs end up standing.
The clutch doubles, because the same spend share buys twice as many seeds at half the price: 70 instead of 35. The germination bill in light does not move at all, which is the surprise. That bill is the upkeep on the tissue the first branching costs, and the first branching of the herb's grammar costs ten grams whatever the seed weighed; the seed mass never enters it. What does move is the seedling's own first tick, since it now germinates holding half as much tissue and therefore pays half as much upkeep, and the ripe threshold, which halves to 1.00 grams. So: twice as many seeds, the same gate, a cheaper start. Run it and watch the bank rather than the census, because the count that changes first is the one waiting in the ground.
Exercise 3 — take the seed bank away. Set every row's
Viable to 900, one season, and predict which of the four rows notices
first. Then run
go run ./cmd/seeds -mode valley -years 6 -viable 900.
Every row seeds on the tick its own window shuts, so every seed in this valley is born out of season and every one of them has to wait for a seasonal stir that falls inside its own row's window. For a herb landing around tick 2255 the next such stir is tick 4500, some 2,245 ticks later; for a moss landing at 2696 it is the same stir, 1,804 ticks later. Nine hundred ticks of viability does not reach either. The answer to which row notices first is all of them.
$ go run ./cmd/seeds -mode valley -years 6 -viable 900
year moss herb scrub tree released grew waiting flying standing
1 1 1 1 1 0 0 0 0 637.3
2 0 0 1 1 88 0 0 0 550.8
3 0 0 1 1 164 0 0 0 542.1
4 0 0 1 1 240 0 0 0 532.2
5 0 0 1 1 316 0 0 0 524.8
6 0 0 1 1 392 0 0 0 513.7
every seed this valley has released, and where it is now
released grew waiting flying off map rock pond aged no slot
moss 2 0 0 0 0 0 0 2 0
herb 10 0 0 0 0 4 0 6 0
scrub 330 0 0 0 1 114 7 208 0
tree 50 0 0 0 10 15 10 15 0
all 392 0 0 0 11 133 17 231 0
released less every column after it: 0
Three hundred and ninety-two seeds, not one germination in six years, and 231 of them aged out in the ground. The two plants left standing at the end are two of the four that were put there by hand. What this exercise is really measuring is the gap between a row's seeding day and the next day it is allowed to wake on, and that gap is a number nobody chose: it is the distance around the rim between two thresholds on two different readings of the year.
The four rows can now feed themselves, drink, keep a calendar, die and start again somewhere else, and the six-year run above took about half a second to produce. Six years is barely a test of a tree, let alone of an ecology; the tree needs 459 ticks to earn back one clutch and lives on ground the run never got round to exhausting. The next thing to do with a valley that plants itself is to take the pacing off and leave it running for as long as it will hold together, printing one census a year, and find out what the numbers do over two hundred of them.