🧵 Quilt Cell Taxonomy

The 7×6 polyformalism matrix — click any cell to see the substrate's manifestation. 80+ papers, 11 languages, 1 state hash.

Core opcodes

Adopted sub-ops

Runtime surfaces

Meta / self

	Cell	Fabric	Watch	Runtime	Fingerprint	Edge
BIND	node 𝑐 → 16-dial state	edge {c₁,c₂} → wire	tick → Δt clock	op(s,d) → s'	FNV-1a 64-bit hash	cell → neighbor
LINK	c.subscribe(λs)	graph.compose(f₂)	universal ↔ particular	dial → output bus	hash → bucket	wire → wire
EFFECT	c.set(s)	edge.fire()	tick.advance()	dial mutates	hash recompute	broadcast
VIEW	c.dials[0..15]	graph.walk()	4D slice → 3D	state → display	Q1.15 → float	neighbor.dials
TICK	c.commit(s)	graph.step()	Δt = 1 step	next(state)	hash advance	propagate
FORGET	c.discard()	prune({c})	universal ⊥ particular	GC dial	hash expire	edge delete
PROOF	c.assert(s)	invariant?	∀t : state(t)	type check	hash collision?	reachability
ROUTE	c.next(c')	shortest path	oscillation step	message bus	bucket lookup	multihop
CRDT	c.merge(s,s')	2P-Set union	converge(t)	last-write-wins	vector clock	causal
WORLD	c.observe(env)	boundary ←→ world	tick ⇄ physics	I/O port	observation log	sensor
TIME	c.at(t)	history	t parameter	scheduler	time hash	delay
5 LAWS	idempotent	composable	oscillatory	invertible	byte-exact	commutative

Click any cell above

Each cell shows how the opcode manifests in that substrate. The 5 laws (bottom row) are the algebraic properties that hold across all substrates — what makes a cell a cell, not a class.

Polyformalism at a glance

The same cell exists in 6 substrates simultaneously. They differ in:

Memory model — Python uses dicts, C uses arrays, Rust uses enums, Verilog uses registers
Tick model — Python is event-driven, Verilog is clock-driven, WASM is yield-driven
Hash algorithm — FNV-1a 64-bit is the same in all 6 (byte-exact verified)

The 5 algebraic laws

∀ c, c' : Cell  (cells)
∀ f, f' : Fabric  (fabrics)
∀ t : Tick  (ticks)
∀ s, s' : State

L1  IDEMPOTENT       c.set(s).set(s)  ≡  c.set(s)
L2  COMMUTATIVE      f.link(c₁).link(c₂)  ≡  f.link(c₂).link(c₁)
L3  OSCILLATORY      watch(t).advance()  ⇄  watch(t+1)
L4  COMPOSABLE       f₂.compose(f₁)  : Fabric
L5  INVERTIBLE       runtime.reverse(state)  →  prior state