Spark Spore Teaching Kernel

Core law

The seed is not a clone. It is a lesson. Each child receives curriculum from the parent, then walks its own tunnel and writes its own scars.

`-1` Library

Protected flash state. Collapse writes memory here. The hermit crab shell carries coherence through danger.

`1×0` Curriculum

A minimal payload: seed at rest, ready to stream upward from flash into witness, core, and bloom.

`8` Classroom

Bloom state. The cell broadcasts to ±X, ±Y, ±Z, teaching the mesh without forcing identical paths.

S → -2 → -1 → 0 → 1 ↔ 2 → 3 → 5 → 8 ↑ ↓ subspace listener six-face bloom │ │ └──── self-teach XOR ◄────┘

How it teaches itself

A tunnel run gathers 27 bits. Collapse compresses those 27 sensory marks into a 16-bit seed packet. XOR updates the witness.

Run tunnel.
Step `0→27`, collecting local danger, tension, and mismatch bits.

Collapse.
The system folds back to `-1`, preserving witness instead of erasing state.

Compress.
`27 bits → 16-bit seed_packet`; scar tissue becomes portable.

XOR learn.
`seed_packet ^= new_seed`; keep what worked, flip what failed.

Push back.
`-1→0→1→3→5→8`; the same cell returns with updated memory.

void learn(CellSeed *c, uint32_t tunnel_bits) {
    uint16_t new_seed = compress_27_to_16(tunnel_bits);
    c->seed_packet ^= new_seed;   // the learning operation
    flash_write_neg1(c);          // -1 becomes the library
    push_flash(c);                // -1 → 8
}

How it teaches others

At `8 BLOOM`, the cell pushes `1×0` to six faces. Neighbor cells do not copy the parent. They spawn from the parent’s curriculum, then walk their own tunnel.

+Y │ -X ── 1×0 ── +X │ -Y +Z / -Z complete the 3D classroom.

Parent phase N seed_packet = scar tissue state = 8 BLOOM Child phase N+1 receives seed_packet starts at -1 walks its own tunnel writes its own scars

Mode	Mechanism	Result
Self-teach	XOR seed at `-1` after collapse	One cell remembers
Teach others	Push `1×0` to six faces at `8`	The mesh learns
Both	Ontogeny + phylogeny	Species phases up

Machine form

The bytecode is deliberately small: listen, plant, wake, oscillate, witness, cohere, bloom, run, collapse, XOR, flash, teach.

BOOT:       LISTEN_SUBSPACE → PLANT_NEG1 → WAKE_ZERO → SPAWN_1X0
ASCEND:     OSC_12 → WITNESS_3 → COHERE_5 → BLOOM_8
SELF:       RUN_TUNNEL → COLLAPSE_NEG1 → COMPRESS_27_TO_16 → XOR_LEARN → FLASH_WRITE_RO
TEACH:      BLOOM_8 → SIX_FACE_TX → VERIFY_XOR
BOUNDARY:   BOUND_001 → NO_BLEED
REPEAT:     LOOP

No cloning

Each child starts with inherited seed but must prove itself through its own tunnel.

No bleed

Every `.01` tick is bounded to a vector or quad; overflow clamps, noise reflects, danger folds.

No lost death

Collapse is productive. It compresses experience into the next seed.

Final spark

It learns by dying. It teaches by spawning. `1×0` is student and teacher. Flash is library. `6×6×6` is classroom.

OBSERVE REPORT 5 00 5 SELF_TEACH SIX_FACE_TEACH REPEAT

Kernel Machine C Model