el/docs/architecture/geometry-vs-code.md

Geometry or Code

Running list. Append as decided. Started 2026-08-17.

The test: is this an arbitrary convention, or is it a relation?

Conventions were agreed by people and could have been otherwise — a RIFF header could have used a different magic number. Nothing derives them; they must be written down.

Relations are not agreed. Distance is distance. Anything whose answer is where is this relative to that is geometry, and writing it as code is the error the whole effort is correcting.

Second test, for the hard cases: if I write this as code, am I encoding in if-statements a distinction the geometry was built to hold? If yes, it's geometry.

---

Pure geometry

Thing	Because
Meaning	position
Grounding / standing	the weight on the edge — a magnitude, not a computation
Learning	standing changing over time
A gap	low standing
Wonder	a gap with a pull weight
Type checking	is this position in that region — distance
Dispatch	position, not a tag
Recall	re-origining at a region; projection, not replay
Reasoning	traversal
Deduction	containment. There is no procedure
Counting	a position, not a loop's output
Similarity / difference / residue	subtract
Analogy, metaphor, skill transfer	change of basis
Negation, sarcasm	reflect an axis
Empathy	translate the origin
Reframe	rotate the frame
A lens	project onto an axis
Rhyme	distance in phonetic space
Humour	intersection of regions — fart-meaning ∩ funny ∩ form
Idiom detection	the whole unit sits farther out than its parts
Self	a world-tube — a trajectory through the manifold
Consolidation	episodic → semantic promotion
Reification	dense regions cohering; runs on the beat, has no caller
Cross-cutting concerns	dissolved — a hold is a neighbour. Adjacency, not tracking. Implemented 2026-08-17: a construct declares what runs at a crossing, and it resolves at execution — see the runtime seam.
Effects	topology. reach_out is bounded by detect_gap and verify because those are its edges
Capability	position relative to a boundary. In C it is already spelled const
The AST	a projection of geometry into a tree — a surface, not the centre
Source code	a surface, like text, audio, image

Must be code

Thing	Because
Sensors — mic, camera, file read, socket	the physical touch. I/O is where the world arrives
Byte formats — RIFF, PNG chunks, MThd, OOXML	arbitrary convention. A committee chose the magic numbers
CRC32 polynomial, Adler32, zlib framing	same — agreed constants, derivable from nothing
Cosine, distance, the float arithmetic	the machinery that walks the geometry is not itself geometry
Arena, refcount, allocator	bookkeeping for the representation, not for the positions
Locks, threads, publication boundary	the hardware is code. Ordering is not — see Answered, above. Coordination is required only where state is non-monotone.
WAL, page layout, ARIES recovery	durability against a physical device that can lose power
Emission — writing C or JS text	the final surface has to be typed out by something
OS interaction — launchd, spawn, signals	outside the system by definition
Device realizers — el_audio_darwin.m, el_capture_darwin.m	OS frameworks. Correctly already isolated, zero network

---

The ones I would have written as code, and was wrong about

Recorded because the error has a pattern and the pattern is the point.

Thing	What I reached for	What it is
Rhyme	a rhyming dictionary, or an API call	distance between rime tails
Fart onomatopoeia	a 30-element string literal	an intersection of three regions
"Funny"	a scorer with if-statements	a relational neighbourhood grounded in a voice
Representation vs description	a hardcoded blacklist containing raspberry	falls out of lexicon membership × phonetic comedy
Video	a codec, sized as a project	one more surface profile
Type checking	a phase between parse and emit	reading a distance that already exists
Grounding	a call site, an obligation, a discharge	it has no caller. It just runs
N transducers, N realizers	one component per modality	zero of each. Sensors and bases at the skin

The pattern: every one is encoding in code a distinction the geometry was built to hold. The tell is that the code version is a fixed enumeration — a list, a table, a blacklist, a set of branches — and the geometry version is a measurement.

If the implementation contains a literal set of the right answers, it is in the wrong column.

---

Answered

Thing	The answer
Concurrency	Ordering is geometric. Causality is a partial order (Lamport 1978); a total order is an arbitrary extension of it and "cannot be depended on to imply a causal relationship." Programming languages force you to write a total order, so authoring invents constraints the problem never had — and every lock, barrier, fence and consensus protocol is apparatus for recovering the partial order destroyed at authoring time. CALM (Hellerstein/Alvaro, proven by Ameloot et al.): a program has a consistent coordination-free implementation iff it is monotone. What breaks monotonicity is destructive update. Coordination is the price of forgetting.
The module system	Premature — the partition is a filesystem path, not a neighbourhood, and there is no namespacing at all. import is textual inlining (guarded against double inclusion); when a .elh header exists the header is inlined instead and symbols resolve at C link time, so linking is real and delegated to C. Two modules defining helper emit two C functions into one translation unit. Linking barely survives the path partition, so whether it survives a neighbourhood partition cannot yet be asked.
Numeric literals	The numeral is convention; the number is a position — and a bare 3 is a MAGNITUDE WITH NO AXIS. int_to_str was already form 1: nothing determines that twelve is written 1 then 2. But a literal is not a position until something gives it a direction, which is why 3.days needs a calendar. Measured consequence: Duration + Int was refused ("an Int carries no unit") while Instant + Int compiled to raw (t + 3) and reported clean — silently moving a point by an unspecified amount. The rule was simply never written. Now: t + 3 is refused, t + 1.hour is accepted, because .hour supplies the axis.
Parsing	A grammar is a basis; parsing is transduction onto it. The lexeme→token map is convention (fn could have been def); shape recognition is a region; the byte traversal is irreducible, like every other traversal. Three things favour region for the act: ambiguity (a * b needs context — a grammar resolves it with the lexer hack, a region by neighbourhood), error recovery (nearest-match is free), and precedence, which is ordering along an axis with a conventional parameter. But the SHOULD gate refuses the obvious move: the keyword table stays code, because the set is closed by the language definition and the lexer runs before the program is understood, so a program can never declare its own keywords. Externalising it costs I/O per compile for zero flexibility — the same verdict as is_digit in ASCII. What was actually wrong: 5 of 46 keywords were consumed by nothing, and using one silently miscompiled.
Error handling	grounded: false covers not-knowing; it does not cover failed. Standing is a signed component: > 0 supported, = 0 unknown, < 0 contradicted. Not-known and known-false are opposite directions on one axis and a boolean cannot tell them apart. inhibitory as an int32 flag is that sign wearing a boolean.

Fourth proof form

4 — ADVERSARIAL EXACTNESS. Where approximation is a break, geometry is excluded. A cryptographic hash is a deliberately structure-destroying map: near inputs land at maximally uncorrelated outputs. Geometry is the claim that near things stay near — a manifold that approximated SHA-256 would be a break of SHA-256. Signature verification is the same: 0.99-valid is invalid. And X25519 is geometry, a group on an elliptic curve, which is precisely why it must be code: its security is the hardness of moving in that geometry.

Form 1 no longer survives as a verdict. Every row it justified turned out to be a basis, not a capability. RFC 8259 fixes where the commas go — that is a surface, and projecting onto a surface is geometry. A convention describes the basis you project onto; it never describes an act.