A Copy With One Number Changed

// internal/gene/copy.go
// StreamMutate is the stream every mutation in this world draws from,
// and the one number this file is allowed to spend. It is its own
// stream and not a corner of an existing one, because a stream drawn a
// different number of times is a different world: the founding takes
// its cells off stream 12 and its weights off stream 14, and both of
// them have to read the same numbers in the same order whether anything
// in this valley ever makes a child or not.
const StreamMutate = 16

// Mutations opens the generator every mutation of one run draws from.
func Mutations(seed uint64) *rand.Rand {
	return rand.New(rand.NewPCG(seed, StreamMutate))
}

// Rates is how wrong a copy is allowed to be: the two chances a gene
// moves at all, and how far one step may carry it when it does.
//
// Replace and Perturb are read off one draw as bands of the same
// number, not as two separate coins. A draw under Replace throws the
// gene away and writes a new one anywhere in its range. A draw under
// Perturb and not under Replace nudges the gene it already has.
// Everything else leaves the gene alone. So Perturb is the whole of
// what moves, Replace is the part of that which starts over, and the
// two rates are stated the way they are read.
//
// Step is a share of the gene's own range and not a share of the gene's
// own value, which is the difference between a nudge that means the
// same thing everywhere and a nudge that gets timid near zero. Five
// percent of a body factor's range is 0.1875 either way; five percent
// of a weight's is 0.4000; five percent of a temperament gene's is
// 0.0500.
type Rates struct {
	Replace float64
	Perturb float64
	Step    float64
}

// Usual is what every child in this valley is copied at.
var Usual = Rates{Replace: 0.01, Perturb: 0.09, Step: 0.05}

$ go run ./cmd/copy -mode rates
copy: one pass over a genome of 395 numbers, two draws a gene

  the first draw decides, and it is one number read as three bands

  first draw             the gene         the second draw becomes
  under 0.01             starts over      anywhere in the whole range
  0.01 to under 0.09     is nudged        a step of at most 5 percent of the range
  0.09 and over          is left alone    nothing, and is drawn anyway

  block     genes        low       high        range    one nudge
  BODY         10     0.2500     4.0000       3.7500       0.1875
  MIND        378    -4.0000     4.0000       8.0000       0.4000
  TEMPER        3     0.0000     1.0000       1.0000       0.0500
  LOOK          4     0.0000     1.0000       1.0000       0.0500
    Sight       1     0.5000     2.0000       1.5000       0.0750

  395 genes x 2 draws = 790 numbers off stream 16, every copy, whatever moves
  genes expected to move: 395 x 0.09 = 35.55, of which 395 x 0.01 = 3.95 start over

Look at the one nudge column, because it is doing something the code never says out loud. A nudge is five percent of the gene's range, so the operator hands out a different-sized step to each block without knowing what any block is for. A body factor runs over 3.7500 and gets a step of up to 0.1875. A weight runs over 8.0000 and gets 0.4000. A temperament gene runs over 1.0000 and gets 0.0500. Sight, which carries half the leash the other nine body genes carry because a wider line of sight is arithmetic the phase has to pay for every tick, gets 0.0750: half the step, for free, out of the same line of code. Had the nudge been five percent of the gene's value instead, a gene sitting near zero would barely move at all and a gene sitting near four would move in strides, and a temperament gene that ever reached 0.0000 would be stuck there for ever.

// internal/gene/copy.go, continued
// Moves is what one pass over one genome came to: the numbers it took
// off the stream, and the genes that ended up somewhere else. Draws is
// there to be checked rather than to be read, and the thing to check is
// that it is twice the length of the genome every single time.
type Moves struct {
	Draws     int
	Replaced  int
	Perturbed int
}

// Moved is the genes this pass put somewhere else.
func (m Moves) Moved() int { return m.Replaced + m.Perturbed }

// Mutate walks a genome gene by gene in block order and moves the ones
// the stream says to move.
//
// Two draws a gene, always. The first decides what happens to the gene
// and the second says where it goes, and the second is taken off the
// stream whether or not anything is done with it. That is the whole of
// the discipline, and it is worth being plain about why a pass cannot
// be written the obvious way instead: draw the first number, and only
// reach for a second when the first says the gene is moving. That
// version is shorter, it draws a little over half as many numbers,
// and it makes a run that cannot be replayed, because how many it
// spends on a genome depends on what the numbers said. Every draw after
// the first gene that moves lands at a different place in the sequence.
//
// The clamp is not here. Genome.Put holds every number it is given
// inside that gene's own range, so a perturbation that would walk a
// body factor past four stops at four and a replacement can only ever
// name a number the range already contains.
func (r Rates) Mutate(g *Genome, s *rand.Rand) Moves {
	var m Moves
	for i, n := 0, g.Len(); i < n; i++ {
		what, where := s.Float64(), s.Float64()
		m.Draws += 2
		sp := g.Span(i)
		switch {
		case what < r.Replace:
			g.Put(i, sp.Lo+where*sp.Wide())
			m.Replaced++
		case what < r.Perturb:
			g.Put(i, g.At(i)+(where*2-1)*r.Step*sp.Wide())
			m.Perturbed++
		}
	}
	return m
}

// Child is one parent's genome copied and then copied wrong: a deep
// copy the parent shares nothing with, put through one mutation pass.
// The parent is not touched, which is the whole reason the copy happens
// before the pass and not after it.
func (r Rates) Child(parent *Genome, s *rand.Rand) (*Genome, Moves) {
	g := parent.Copy()
	return g, r.Mutate(g, s)
}

Two things this listing does not do are as load-bearing as the loop. It does not clamp, because Genome.Put holds every number it is handed inside that gene's own range before it writes it, so a nudge that would carry a body factor past four stops at four and there is no road into a genome that skips the check. And Child copies before it mutates, never after, so the parent that made the child is exactly the parent it was before the child existed. Getting that backwards produces a lineage where every ancestor quietly becomes its own descendant, and nothing about it looks wrong until somebody prints a family tree.

// internal/gene/copy.go, continued
// Apart is how far two genomes have got from each other, gene by gene:
// the largest gap anywhere in the flat walk, and which gene it is at.
// It is a plain largest-difference and not a distance with weights in
// it, because at this point in the valley nothing has any business
// deciding that one gene matters more than another.
func Apart(a, b *Genome) (at int, gap float64) {
	at = -1
	for i, n := 0, a.Len(); i < n; i++ {
		d := a.At(i) - b.At(i)
		if d < 0 {
			d = -d
		}
		if d > gap {
			at, gap = i, d
		}
	}
	return at, gap
}

$ go run ./cmd/copy -mode once
copy: one pass over the identity genome, seed 5, stream 16

  genes walked                      395
  numbers taken off the stream      790
  genes replaced outright             3
  genes nudged                       34
  genes left where they were        358

  block     genes    moved    share
  BODY         10        1    10.0%
  MIND        378       35     9.3%
  TEMPER        3        1    33.3%
  LOOK          4        0     0.0%

  every gene outside the MIND block that ended up somewhere else:

       i block    gene                    was         is   moved by
       0 BODY     Bulk                 1.0000     1.0747     0.0747
     390 TEMPER   tameness             0.5000     0.4997    -0.0003

  the gene that moved furthest is 71, weight 61 in MIND, by 3.9256

  the row this child is stamped out of:

     i gene          factor      the row      stamped
     0 Bulk          1.0747      40.0000      42.9896
     1 Full          1.0000     400.0000     400.0000
     2 Basal         1.0000       0.0040       0.0040
     3 Work          1.0000       0.6000       0.6000
     4 Bite          1.0000       0.2500       0.2500
     5 Convert       1.0000       4.0000       4.0000
     6 Reach         1.0000       1.0000       1.0000
     7 Sight         1.0000      12.0000      12.0000
     8 Top           1.0000       0.4500       0.4500
     9 Swing         1.0000       0.0833       0.0833

Thirty-seven genes of three hundred and ninety-five ended up somewhere else, which is nine and a bit percent, and the block shares are 10.0, 9.3, 33.3 and 0.0 percent. The last two are what a rate of nine percent looks like when it is only rolled three or four times: one gene of three is a third, zero genes of four is nothing, and neither says anything about the operator. The one body gene that moved is Bulk, nudged from 1.0000 to 1.0747, which stamps a body of 42.9896 grams instead of 40.0000. One temperament gene moved by three ten-thousandths. Nothing in this valley reads a temperament gene, and it moved anyway, because the operator has no idea which genes anything reads.

// cmd/copy/main.go
// thrifty is the operator as it is tempting to write it: the second
// draw taken only when the first one says a gene is moving. It is here
// to be run and not to be shipped.
func thrifty(r gene.Rates, g *gene.Genome, s *rand.Rand) gene.Moves {
	var m gene.Moves
	for i, n := 0, g.Len(); i < n; i++ {
		what := s.Float64()
		m.Draws++
		sp := g.Span(i)
		switch {
		case what < r.Replace:
			g.Put(i, sp.Lo+s.Float64()*sp.Wide())
			m.Draws++
			m.Replaced++
		case what < r.Perturb:
			g.Put(i, g.At(i)+(s.Float64()*2-1)*r.Step*sp.Wide())
			m.Draws++
			m.Perturbed++
		}
	}
	return m
}

$ go run ./cmd/copy -mode count
copy: what a pass costs the stream, at four settings of the same operator

  rates                             draws    moved 2 x genes
  replace 0.00, perturb 0.00          790        0      790
  replace 0.01, perturb 0.09          790       37      790
  replace 0.00, perturb 1.00          790      395      790
  replace 1.00, perturb 1.00          790      395      790

  three children in a row off one stream, made two ways

  child        fixed    thrifty   and the two of them
  1              790        441   differ most at gene 71, by 3.9256
  2              790        421   differ most at gene 71, by 4.0381
  3              790        441   differ most at gene 71, by 4.0381
  total         2370       1303

  the fixed rule spent 2370 numbers, the thrifty one 1303
  every child after the first is a different child, on the same seed

The top table is the promise. Rates that move nothing at all, the rates this valley actually uses, rates that nudge every gene, and rates that replace every gene: four operators with nothing in common except the length of the genome, and every one of them takes 790 numbers. A run that ships a change to the mutation rates does not have to think about what that does to the stream, because it does nothing to the stream.

// internal/beast/move.go
// Coast is how far this body still travels after the legs stop pushing,
// in cells. A tick of legs may change a velocity by no more than one
// Ramp's worth of the top speed, so a body asked to stop sheds that
// much a tick and covers whatever speed is left over each time, until
// there is none left to shed. It is worked out at the fastest this
// creature may be asked to go this tick, because that is the speed a
// step it is allowed to take can leave it carrying.
func (b *Beast) Coast() float64 {
	d := b.Kind.Top / Ramp
	if d <= 0 {
		return 0
	}
	far := 0.0
	for v := b.Pace() - d; v > 0; v -= d {
		far += v
	}
	return far
}

// internal/beast/act.go
// ground refuses a step the valley will not carry. It tests the ground
// the step covers and not the cell underfoot, because the cell
// underfoot has already been walked on.
func ground(b *Beast, v *View) error {
	if _, no := b.Blocked(v); no {
		return ErrNoGround
	}
	return nil
}

// Along is the cell d cells along the heading from where the body is
// standing.
func (b *Beast) Along(d float64) sim.Coord {
	p := b.Pos.Scale(1.0 / terra.Tile)
	return sim.Coord{
		X: int(math.Floor(p.X + math.Cos(b.Face)*d)),
		Y: int(math.Floor(p.Y + math.Sin(b.Face)*d)),
	}
}

// Ahead is the first cell of a step: one cell along the heading from
// where the body is standing.
func (b *Beast) Ahead() sim.Coord { return b.Along(1) }

// Blocked is the first cell of this creature's step that the valley
// will not carry, and whether there is one.
//
// A step is not one cell. A tick of legs cannot stop a body dead, so
// the ground a step commits a creature to is everything the body is
// still crossing when the legs have finished with it: b.Coast(), and
// never less than the single cell this rule looked at for as long as
// every animal had the same legs. A body that can stop inside a cell is
// a body the old arithmetic was right about, and every creature stamped
// out of the founding row coasts 0.6750 of a cell.
//
// The walk goes out a cell at a time and stops at the first cell it
// does not like, so a refusal names the cell the creature would have
// run into rather than the far end of a step it never gets to take.
// Nothing here allocates: the ranking walk asks five or six times a
// tick, and the loop is over a count of cells and not a slice of them.
func (b *Beast) Blocked(v *View) (sim.Coord, bool) {
	far := 1.0
	if !b.Adrift {
		if coast := b.Coast(); coast > far {
			far = coast
		}
	}
	for d := 1.0; ; d++ {
		if d > far {
			d = far
		}
		c := b.Along(d)
		if !v.Valley.Bed.In(c) || v.Valley.Bed.Kind(c) == sim.Water {
			return c, true
		}
		if d >= far {
			return c, false
		}
	}
}

Along is the old Ahead with a distance on it, and Ahead is now that function asked for one cell, which is the same arithmetic the old line did: multiplying by exactly 1.0 hands a float64 straight back. So for any creature whose coast is under a cell, Blocked looks at b.Along(1), finds it is at or past the end of the walk, and returns. One cell, one comparison, the same answer the old rule gave, for every cell of the valley in every heading. Every creature stamped out of the founding row coasts 0.6750 of a cell, so the repaired check and the old one are the same check for every animal this book has printed a run about, and that is a fact about the arithmetic rather than a hope about the seeds. The refusal itself got sharper for free: Blocked hands back the cell it stopped on, so the *Refusal the log carries names the cell the creature would have run into and not the first cell of a step it never got to take. errors.Is(err, beast.ErrNoGround) is the same question it always was.

// internal/beast/act.go, continued
// Underfoot is the cell of the valley this body is over: the cell it is
// standing on, or, for a body that has been carried past the last cell
// there is, the rim cell it is lying against.
//
// A position is allowed off the grid, because a body carries momentum
// no tick of legs can cancel and the rim is one cell wide. A body is
// not allowed to be nowhere. Everything this world writes onto the
// ground under a creature comes through here, and the ground under a
// creature is always ground the valley has.
func (b *Beast) Underfoot(bed *terra.Bed) sim.Coord {
	c := b.Cell()
	if b.Adrift {
		return c
	}
	switch {
	case c.X < 0:
		c.X = 0
	case c.X >= bed.W:
		c.X = bed.W - 1
	}
	switch {
	case c.Y < 0:
		c.Y = 0
	case c.Y >= bed.H:
		c.Y = bed.H - 1
	}
	return c
}

// internal/beast/roster.go — inside Roster.Phase
		if t.Left <= 0 {
			b.Dead = true
			c := Carcass{Who: b.ID, Name: b.Name, At: b.Underfoot(v.Bed),
				Grams: b.Kind.Bulk, Tick: v.Now}
			died = append(died, c)
			r.gone = append(r.gone, home)

One expression changed in the phase: the carcass is written at b.Underfoot(v.Bed) instead of at b.Cell(). For every body standing on the grid those are the same cell and the same bits, so this cannot move a run in which nothing ever left the valley. It can only ever act on a body the step rule had already failed to hold, which is the narrowest thing a repair can be and still be a repair.

// internal/beast/body.go — inside type Beast struct
	// Adrift is the ground rules as they were written while every
	// animal in the world had the same legs: the step check looking one
	// cell along the heading and no further, and a body allowed to be
	// nowhere at all. It is kept behind a flag so what those two cost a
	// valley of unequal creatures can be run instead of described, and
	// it is false in every creature this book ships.
	Adrift bool

$ go run ./cmd/copy -mode valley
copy: 12x8 valley, tick 901, year 1 summer, 12 plants standing at 1517.5 grams

  19 creatures founded on stream 12, a brain apiece off stream 14,
  and every genome put through 24 mutation passes off stream 16

  the five fastest of them, in cells a tick at a sprint:

        id        Top    the row coast, cells
         5     1.7613     0.4500       2.6420
        16     1.4938     0.4500       2.2407
         8     1.1887     0.4500       1.7831
        12     0.4977     0.4500       0.7465
         3     0.4854     0.4500       0.7281

                                               this run
  ticks run                                        6750
  creatures struck off                               19
  creatures still walking                             0
  creature-ticks spent past the last cell              0
  grams of carcass buried off the grid         0.000000
  grams in                                 44970.601626
  grams out                                44970.601626

  the two ledgers differ by -8.076e-10, which is the last bits of the adding

Same seed, same nineteen founders, same twenty-four passes, same three fast animals with the same coasts. No creature-ticks past the last cell now instead of one, no grams buried off the grid instead of forty, and the two ledgers differ by -8.076e-10, which is what tens of thousands of additions taken in two orders cost. The grams total moved, from 44687.958166 to 44970.601626, and it moved because three creatures out of nineteen are now refused steps they used to be allowed, so they graze different plants and the valley grows a slightly different amount of tissue. That is the repair doing its job. A run whose books do not close has no claim on any of its other numbers either, so there was nothing there to preserve.