Multiply, Add, Decide

// internal/mind/neuron.go
// Package mind is the arithmetic a creature decides with. Nothing in
// here knows what a plant is, what a tick is, or which end of the
// valley it is standing in: everything takes a row of numbers and hands
// back a number, so the same weights fed the same senses answer the
// same way on every machine that runs them.
package mind

// Neuron is one decision written down as numbers: a weight for every
// input it reads, and a bias added to the total before anything looks
// at it. The weights say how much each input counts and which way it
// pushes. The bias says what the total is when every input is zero,
// which is the only thing the weights cannot say.
type Neuron struct {
	W []float64 // one weight per input, in the order the inputs arrive
	B float64   // added to the total, whatever the inputs are
}

// Sum multiplies each input by its own weight, adds the products
// together, and adds the bias. It reads exactly as many inputs as it
// has weights: a longer row is read up to len(n.W) and no further, and
// a shorter one is a wiring mistake that panics on the index instead of
// quietly deciding on numbers that are not there.
func (n Neuron) Sum(in []float64) float64 {
	z := n.B
	for i, w := range n.W {
		z += w * in[i]
	}
	return z
}

// Step is the oldest decision there is: 1 when the total is above zero,
// 0 when it is not. Zero itself counts as not above, so a neuron with
// nothing to go on answers no.
func Step(z float64) float64 {
	if z > 0 {
		return 1
	}
	return 0
}

Three small decisions in that file are what keep it standing when the inputs number twenty-four. The weights are a slice and not two named fields, so the same type serves a neuron reading two numbers and one reading twenty-four without a line changing. The bias sits outside that slice because it multiplies nothing: giving it a weight would mean inventing an input that is always 1, which works and reads like a trick. And Sum returns the total instead of the answer, with Step standing apart as its own function. The total is the arithmetic; the decision is a policy about the arithmetic, and they will not stay married for long.

// cmd/neuron/main.go — the bench: no world, no tick, one neuron

// The two numbers from the valley's opening creature row this bench
// needs. They are here to turn cells and energy units into the 0-to-1
// numbers a sense is scaled to before any weight touches it.
const (
	sight = 12.0  // cells a vision ray runs before it reports the cap
	full  = 400.0 // energy units the store holds when it is full
)

// moment is one situation in the valley written in the units it is
// measured in: how many cells off the nearest plant the eye ray found
// is, and how much energy is in the store. A ray that met nothing
// reports the cap, so "nothing seen" is the moment whose cells are
// sight.
type moment struct {
	name  string
	cells float64
	store float64
}

var six = []moment{
	{"3 cells, store 96", 3, 96},
	{"3 cells, store 400", 3, 400},
	{"11 cells, store 96", 11, 96},
	{"nothing, store 40", sight, 40},
	{"6 cells, store 96", 6, 96},
	{"6 cells, store 80", 6, 80},
}

// senses scales a moment into the two numbers the neuron reads: the
// distance as a share of how far the eye reaches, and the store as a
// share of full.
func senses(m moment) []float64 { return []float64{m.cells / sight, m.store / full} }

// answer reads the step decision back out as a word.
func answer(z float64) string {
	if mind.Step(z) == 1 {
		return "yes"
	}
	return "no"
}

func table(n mind.Neuron, ms []moment) {
	fmt.Printf("\n  %-19s %8s %8s %10s %10s %10s %7s\n",
		"the situation", "dist", "share", "w*dist", "w*share", "total", "answer")
	for _, m := range ms {
		in := senses(m)
		z := n.Sum(in)
		fmt.Printf("  %-19s %8.4f %8.4f %10.4f %10.4f %10.4f %7s\n",
			m.name, in[0], in[1], n.W[0]*in[0], n.W[1]*in[1], z, answer(z))
	}
}

$ go run ./cmd/neuron
one neuron: -1.5000 on the distance, -2.0000 on the store, bias 1.2000
  a ray runs 12 cells before it reports the cap, and a full store holds 400 units

  the situation           dist    share     w*dist    w*share      total  answer
  3 cells, store 96     0.2500   0.2400    -0.3750    -0.4800     0.3450     yes
  3 cells, store 400    0.2500   1.0000    -0.3750    -2.0000    -1.1750      no
  11 cells, store 96    0.9167   0.2400    -1.3750    -0.4800    -0.6550      no
  nothing, store 40     1.0000   0.1000    -1.5000    -0.2000    -0.5000      no
  6 cells, store 96     0.5000   0.2400    -0.7500    -0.4800    -0.0300      no
  6 cells, store 80     0.5000   0.2000    -0.7500    -0.4000     0.0500     yes

Every figure in the first row is one you already worked: 0.2500, 0.2400, −0.3750, −0.4800, 0.3450. The fourth row is the one to sit with. A ray that met nothing reports the cap, which is the same 1.0000 a plant sitting exactly twelve cells out would report, so "nothing met" and "something hopelessly far away" are the same reading and get the same answer. That is the eye admitting that beyond twelve cells it has nothing to say, and a decision built on it inherits the admission.

// cmd/neuron/main.go

// scan walks the store one whole energy unit at a time and reports the
// last store this neuron still says yes to and the first it says no to,
// without consulting the arithmetic that predicts either of them.
func scan(n mind.Neuron, d float64) (string, string) {
	yes, no := "none", "none"
	for s := 0; s <= int(full); s++ {
		if mind.Step(n.Sum([]float64{d, float64(s) / full})) == 1 {
			yes = fmt.Sprintf("%d", s)
			continue
		}
		if no == "none" {
			no = fmt.Sprintf("%d", s)
		}
	}
	return yes, no
}

// line is the boundary: for each distance, the store at which the total
// crosses zero, worked out from the weights and then found by walking.
func line(n mind.Neuron) {
	fmt.Printf("\n  %6s %8s %11s %10s %10s\n",
		"cells", "dist", "predicted", "last yes", "first no")
	for c := 0.0; c <= sight; c += 2 {
		d := c / sight
		yes, no := scan(n, d)
		fmt.Printf("  %6.2f %8.4f %11.4f %10s %10s\n",
			c, d, -full*(n.W[0]*d+n.B)/n.W[1], yes, no)
	}
	fmt.Printf("  the boundary reaches an empty store at %.4f cells\n", -n.B/n.W[0]*sight)
}

$ go run ./cmd/neuron -mode line
one neuron: -1.5000 on the distance, -2.0000 on the store, bias 1.2000
  a ray runs 12 cells before it reports the cap, and a full store holds 400 units

   cells     dist   predicted   last yes   first no
    0.00   0.0000    240.0000        239        240
    2.00   0.1667    190.0000        189        190
    4.00   0.3333    140.0000        139        140
    6.00   0.5000     90.0000         89         90
    8.00   0.6667     40.0000         39         40
   10.00   0.8333    -10.0000       none          0
   12.00   1.0000    -60.0000       none          0
  the boundary reaches an empty store at 9.6000 cells

The predicted column is the interlude's division, done once per row from the three weights. The two columns beside it never see that division: they walk the store from 0 to 400 one unit at a time and report where the answer actually changed. They agree on all five rows where the boundary lands inside a store a creature can have, and they agree in the exact way the arithmetic said they would, with the last yes one unit under the prediction and the first no sitting on it, because the boundary itself totals 0.0000 and 0.0000 is not above zero. The rows drop by exactly 50 units of store for every 2 cells of distance, which is the 240 − 25 × cells worked out on paper.

The last two rows are the interesting failure of the prediction, and it is not a failure of the arithmetic. At ten cells the predicted turnover is a store of −10.0000, and no creature can hold −10 energy units, so the boundary has left the range of situations that can happen: last yes reads none and the first store to say no is 0. Everything past 9.6 cells is outside this neuron's world.

// cmd/neuron/main.go

// The two entries of the sensor row this neuron listens to. The row is
// nine rays as a distance and a code each, then four gradient numbers,
// then the store's share of full and the speed's share of top, so the
// ray straight ahead is the fifth pair and its distance is entry 8.
const (
	rayDist = 8
	storeAt = 22
)

// wide spreads a two-weight neuron across the whole sensor row: the two
// weights land on the entries they were written for and the other
// twenty-two are zero, which is how a neuron says it is not listening.
func wide(n mind.Neuron) mind.Neuron {
	w := make([]float64, 24)
	w[rayDist] = n.W[0]
	w[storeAt] = n.W[1]
	return mind.Neuron{W: w, B: n.B}
}

// spread writes one moment into a full sensor row. Every entry the
// neuron is not listening to gets the same filler, so running it again
// with a different filler is a direct test of whether it listened.
func spread(m moment, fill float64) []float64 {
	in := make([]float64, 24)
	for i := range in {
		in[i] = fill
	}
	in[rayDist] = m.cells / sight
	in[storeAt] = m.store / full
	return in
}

$ go run ./cmd/neuron -mode row
one neuron: -1.5000 on the distance, -2.0000 on the store, bias 1.2000
  a ray runs 12 cells before it reports the cap, and a full store holds 400 units

  one sensor row, every entry this neuron ignores set to 0.50
    entry      0     1     2     3     4     5     6     7     8     9    10    11
    value   0.50  0.50  0.50  0.50  0.50  0.50  0.50  0.50  0.25  0.50  0.50  0.50
    entry     12    13    14    15    16    17    18    19    20    21    22    23
    value   0.50  0.50  0.50  0.50  0.50  0.50  0.50  0.50  0.50  0.50  0.24  0.50
  twenty-four weights, 22 of them zero
    entry      0     1     2     3     4     5     6     7     8     9    10    11
    weight  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00 -1.50  0.00  0.00  0.00
    entry     12    13    14    15    16    17    18    19    20    21    22    23
    weight  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00 -2.00  0.00

  the situation         two wide   row wide  answer
  3 cells, store 96       0.3450     0.3450     yes
  3 cells, store 400     -1.1750    -1.1750      no
  11 cells, store 96     -0.6550    -0.6550      no
  nothing, store 40      -0.5000    -0.5000      no
  6 cells, store 96      -0.0300    -0.0300      no
  6 cells, store 80       0.0500     0.0500     yes

Six totals in the row wide column, six identical totals in the two wide column beside it, and the twenty-four-weight neuron did twenty-two more multiplications to arrive at the same place. Run it again with -fill -0.9 and every ignored entry in the printed row flips to −0.90 while all six totals stay at 0.3450, −1.1750, −0.6550, −0.5000, −0.0300 and 0.0500. That is the test that catches the break: if any of those numbers had moved, one of the twenty-two zeros would not have been a zero.