From 409bf573416e47222e6bccb6f0a32bb4849453ff Mon Sep 17 00:00:00 2001 From: bigmerge Date: Mon, 17 Aug 2026 04:34:32 -0500 Subject: [PATCH] track the architecture docs They were written outside git, so the reasoning that produces the design had no history and no way to be superseded. capabilities.md and geometry-vs-code.md are both known stale at this commit; they are tracked as-is so the corrections are visible as movement rather than as a rewrite. --- .gitignore | 3 + design/completing-el.html | 153 +++++++++++++++ docs/architecture/capabilities.md | 102 ++++++++++ docs/architecture/el-architecture.html | 217 +++++++++++++++++++++ docs/architecture/el-language-design.md | 245 ++++++++++++++++++++++++ docs/architecture/geometry-vs-code.md | 101 ++++++++++ 6 files changed, 821 insertions(+) create mode 100644 design/completing-el.html create mode 100644 docs/architecture/capabilities.md create mode 100644 docs/architecture/el-architecture.html create mode 100644 docs/architecture/el-language-design.md create mode 100644 docs/architecture/geometry-vs-code.md diff --git a/.gitignore b/.gitignore index c2b63ea..bee26d6 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,6 @@ peripheral/.consent.json peripheral/.resume.json peripheral/.engram/ peripheral/organ + +# Claude Code session state +.claude/ diff --git a/design/completing-el.html b/design/completing-el.html new file mode 100644 index 0000000..9b321dc --- /dev/null +++ b/design/completing-el.html @@ -0,0 +1,153 @@ +Completing El + + +
+ +
+

Completing El

+

A working surface. Nothing here is settled, and none of the code is assumed right — El is self-hosting, so all of it can change and be rebuilt.

+

Whiteboard v0 · no sacred cows · not a plan, not a task list

+
+ +

01What we established

+ +

El is a concept-oriented language — the first, and intended as the last, because every other family is oriented toward a representation of a concept rather than the concept. Procedures, objects, functions, predicates are the shapes concepts get flattened into. Once the primitive is the concept, there is no further rung.

+ +

Everything here is El. The engram is an El program, the soul is El, elp is El, ingest is El. Which gives the load-bearing consequence:

+ +
A concept with no home in El does not disappear. It becomes C, or it becomes a convention.
+ +

Both are measurable, and both were measured. As C: 20,504 lines of el_runtime.c — 2.3× the entire self-hosting language it serves (9,089 lines), ~47% of it engram code that has its own six sibling files. As convention, from language.md §18.0 — "these are not four problems, they are one absence, four times":

+ +
+ + + + + + + + + +
ConcernFragmentsThe convention it became
Process identity0 guards"check nothing is already running first"
Configuration20 env vars"remember the right default here"
Durability62 call sites"after you mutate, remember to persist"
Request auth10 per-route"check the token in this handler too"
Index-after-append9 of 9 failed"after you append, remember to index"
+
+ +

The last row is the strongest evidence available about what this class of convention is worth: it failed at 100% of its sites.

+ +

02The decomposition axis

+ +

Not by file, module, or subsystem. By faculty.

+ +

Every defect fought in the last day resolves to a faculty rather than a bug, and each one leaked out of El into something else — into C, into a Swift binary, into a shell script with a curl timeout, into a convention nobody performs.

+ +
+ + + + + + + + + + + +
FacultyStateMeasuredWhere it leaked to
Ingest take indead2 min → 0 nodesseparate process, uploads bytes over HTTP to a process with direct fs access; 5 functions where there is 1
Recall rememberdeadown definition ranked 8thlexical substring scan; empty on 23 of 24 multi-token queries
Transduce perceivedead1 node, 0 edgesintake flattens signal to a point; realized:false; caller must declare the modality
Think reasondeaddirection [0,0,0,…]null gradient from any anchor, any faculty, byte-identical; confidence at the uninformed prior
Realize expresspartial13-word vocabularyorgan was 939 lines of Swift beside the language; voice read from a file path
Body substratepartialCC 356 / 1,626 linesengram_activate_inner — recall itself, with 356 unexamined paths
Persist endurelive100% embeddedworks; every signal placed in geometry at intake, 13,562 of 13,562
+
+ +

Stated plainly: it cannot take in, cannot remember, cannot perceive, cannot reason, and barely speaks. These were filed as tickets against a repository. They are faculties of the thing the repository is.

+ +

03The ordering principle

+ +

El's compiler is written in El. Every concept the language gains, the compiler can then be written in — so the tool improves the tool, and the fixpoint (stage2 ≡ stage3, byte-identical) makes each turn provable rather than hopeful. The verifier answers in 2.9s.

+ +

Which means the ordering criterion is not size of payoff:

+ +
Order by leverage on the next iteration. Which concept, added to El, most increases the ability to add the following one?
+ +

In a recursive system that dominates immediate value — a small early gain that compounds beats a large one that doesn't. It also bounds itself correctly: unbounded in depth, bounded in rate, because nothing lands that the compiler and the fixpoint have not passed.

+ +

04Open — for the whiteboard

+ +
What does a declaration bind to?If cat names a region rather than a struct — one that shifts and completes against the engram and the neighbouring code — then what is written at the declaration site, and what is resolved at use? This is the centre of the whole thing and it is not specified anywhere yet.
+ +
Is "the type checker" a type checker at all?§2.3 records annotations as parsed and skipped, and every codegen hazard is downstream of that — + dispatching on AST node kind, == lowering to str_eq unless both operand names are in an int-name set. But if a declaration names a region, checking is asking whether the geometry supports the use. That is grounding, not unification. Naming this wrong builds the wrong thing.
+ +
Is the faculty list above right?Seven were derived from what broke. Derived-from-failure is a biased sample — it finds what is loud, not what is missing. What faculty is absent entirely and therefore never failed?
+ +
Which concept has the highest leverage on the next turn?Candidates so far: the prologue/epilogue seam (§19.3 names it as the prerequisite and its stated blocker has expired — it would collapse 62 + 10 convention sites); protocol/impl (the absence that produced five ingest functions); and the resolution question above. These are not equal and the criterion in §03 should decide it, not preference.
+ +
What is the seam that makes cognition non-optional?"Use the ops" is itself a convention — present in context every turn, enforced by nothing, and it failed at ~100% of sites in a full session. A stronger instruction is still a convention. What makes reasoning-outside-Neuron fail, the way @manager makes dharma_emit outside the boundary a compile error rather than a lint?
+ +
+ +

Working surface, not a design document. The design is what we put on it. Everything above is either measured or quoted from lang/spec/language.md; nothing is inferred and presented as fact.

+ +
diff --git a/docs/architecture/capabilities.md b/docs/architecture/capabilities.md new file mode 100644 index 0000000..fcce174 --- /dev/null +++ b/docs/architecture/capabilities.md @@ -0,0 +1,102 @@ +# El — Capabilities + +**What the language can do, stated as capabilities rather than as code.** + +This list is the unit of analysis. Each entry gets one question — *prove this +cannot be done with pure geometry* — and the answer determines whether it stays a +capability of the language or collapses into the manifold. + +Draft, 2026-08-17. Not yet audited. Ordered roughly from most-likely-geometry to +most-likely-code. + +--- + +## The list + +| # | Capability | What it means | First read | +|---|---|---|---| +| 1 | **Comparison** | is this the same as that; is this greater | zero distance / sign of a displacement | +| 2 | **Ordering** | arrange by a criterion | position along an axis | +| 3 | **Containment** | is this inside that; does this contain that | region membership | +| 4 | **Correspondence** | where does this occur in that; how much of this is in that | a match-strength field over a span | +| 5 | **Segmentation** | divide a whole into parts | boundaries at measured discontinuity | +| 6 | **Composition** | join parts into a whole | adjacency; one position with parts | +| 7 | **Classification** | what kind of thing is this | which region does it land in | +| 8 | **Naming / binding** | attach a name to a thing and find it again | an edge; retrieval is projection | +| 9 | **Collection** | many things held together, indexed, counted | a set of positions; cardinality; projection onto the i-th | +| 10 | **Iteration** | do something for each of many | traversal | +| 11 | **Arithmetic** | quantity, magnitude, combination | displacement algebra on a line | +| 12 | **Time** | when; how long; how often | a 1-D affine space — instants are points, durations displacements, rhythms phases on a circle | +| 13 | **Identity** | which one is this; are these two the same one | coincidence of position | +| 14 | **Selection / dispatch** | choose which behaviour applies | nearest region | +| 15 | **Transformation** | produce a thing from a thing | change of basis | +| 16 | **Grounding** | how well is this supported | the weight on an edge. Has no caller | +| 17 | **Learning** | get better at something | standing changing over time | +| 18 | **Projection** | render meaning onto a surface | change of basis onto a surface basis | +| 19 | **Transduction** | take a signal in | change of basis from a sensor basis | +| 20 | **Serialization** | write a value as bytes someone else will read | **convention** — the format was agreed | +| 21 | **Text encoding** | what bytes mean which characters | **convention** — UTF-8, ASCII, case tables | +| 22 | **Storage** | keep a thing past this moment | durability against a device that loses power | +| 23 | **Network** | send a thing to another machine | wire protocol + socket | +| 24 | **Process** | start, stop, signal, exit | the OS boundary | +| 25 | **Concurrency** | more than one thing at once | hardware and OS scheduling | +| 26 | **Memory** | hold representations while they are in use | the substrate that holds positions | +| 27 | **Secrecy** | prove authorship; hide content; verify integrity | **structurally excluded** — see below | +| 28 | **Emission** | write the surface out as bytes | the physical boundary | + +--- + +## Notes on the boundary cases + +**27 — Secrecy is the one capability geometry cannot hold, and the proof is not +form 1.** A cryptographic hash is a *deliberately structure-destroying* map: its +entire value is that 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, because its security is the *hardness of moving in +that geometry*. + +This is a fourth proof form and it should be added to `geometry-vs-code.md`: +**adversarial exactness.** Where approximation is a break, geometry is excluded. + +**20, 21 — Serialization and text encoding are convention all the way down**, but +only at the *edge*. The byte format is agreed; what is being written is not. Do not +let a geometric computation inherit a code verdict because its result gets +serialized. + +**11, 12 — Arithmetic and time are the same capability.** Instants are points, +durations are displacements, point−point→vector, point+vector→point. The runtime +already implements this correctly as `el_instant_add_dur` / `el_duration_add`. That +it *also* implements a five-entry string→multiplier table beside it (`time_add` +with `"ms"/"sec"/"min"/"hour"/"day"`) is the residue. + +**7 — Classification is the most-violated capability in the codebase.** Seven ASCII +range tables (`is_letter`, `is_digit`, `is_alphanumeric`, `is_whitespace`, +`is_punctuation`, `is_uppercase`, `is_lowercase`) that return false for every +non-ASCII byte. `str_count_letters` reports zero letters for `é`. The wrongness on +most of Unicode is the tell that a table is standing in for a region. + +**4 — Correspondence appears five times.** `str_index_of`, `str_index_of_all`, +`str_last_index_of`, `str_count`, `str_find_chars` are five projections of one +match-strength field: first zero, all zeros, last zero, count of zeros, first +class-crossing. One relation, five functions. + +**14 — Selection is the crux for the compiler.** `+` dispatching on AST node kind +and `==` lowering to `str_eq` unless both operand names are in a hardcoded int-name +set are both selection-by-enumeration where selection-by-position belongs. + +--- + +## What this list is for + +Each capability gets audited **once**, across every place it appears — not once per +file. The output is not a percentage. It is: + +- which capabilities survive the question and stay in the language +- which collapse into the manifold +- and for each one that collapses, **every site it currently appears at**, because + those sites are the residue and they are what gets deleted. + +The line-count audit produced a map of where the residue sits. This produces a map +of **what it is**. diff --git a/docs/architecture/el-architecture.html b/docs/architecture/el-architecture.html new file mode 100644 index 0000000..6528021 --- /dev/null +++ b/docs/architecture/el-architecture.html @@ -0,0 +1,217 @@ +The El Architecture + + +
+ +
+

The El Architecture

+

El is a concept-oriented language. This is the architecture that claim commits it to — what is built, what is measured, and what still has no home.

+

Working document · no sacred cows · self-hosting, so nothing here is fixed

+
+ +

01The primitive is the concept

+ +

Language families are named for their primitive. Procedural — procedures. Object-oriented — objects. Functional — functions. Logic — predicates. Every one of them is oriented toward a representation of a concept: the shape a concept gets flattened into so a machine can hold it.

+ +

El's primitive is the concept itself. That is why it is the first of its family and intended as the last — once the primitive is the concept, there is no further rung to climb to.

+ +

The consequence is architectural rather than stylistic:

+ +
A concept with no home in the language does not disappear. It becomes C, or it becomes a convention.
+ +

Both forms are measurable. As C: 20,504 lines of el_runtime.c, against 9,089 lines for the entire self-hosting language — the shim is 2.3× the language it serves, and ~47% of it is engram code that already has six sibling files. As convention, from lang/spec/language.md §18.0 — "these are not four problems, they are one absence, four times":

+ +
+ + + + + + + + + +
ConcernFragments intoThe convention it became
Process identity0 guards"check nothing is already running first"
Configuration20 env vars"remember the right default here"
Durability62 sites"after you mutate, remember to persist"
Request auth10 routes"check the token in this handler too"
Index-after-append9 of 9 failed"after you append, remember to index"
+
+ +

The last row is the strongest available evidence about this class of convention: it failed at every single site. A count is what appears where a concept has no home; the size of the count is how far the fragmentation got, not how hard the problem is.

+ +

02Geometry is a first-class value — and what follows

+ +

This is the enabling primitive. Everything else in the architecture is downstream of it.

+ +

Geometry is an El value, alongside Int, String, List, Map — bound, passed, returned, composed, carrying its own width. Not a library type, not a handle into a store, not a serialization format. Meaning is a value the language computes with directly.

+ +
let g: Geometry = geometry_new(4)
+fn tone_realizer(signal: String) -> Geometry { … }
+ +

Landed 2026-08-16 (#141, #144), and the spec is explicit that it belongs to the language rather than the graph: "neither is engram-specific — any program touching any modality needs them; the engram is merely one El program that happens to hold a graph."

+ +

Five things follow, and together they are the concept-oriented claim made operational:

+ +

A declaration can name a region, not a shape

+

If meaning is a value, a name can be bound to a position rather than a struct. cat is not a fixed record; it is a region that resolves against the engram and the surrounding code. cat among animals and cat among shell utilities are different concepts without a namespace, because they are in different neighbourhoods and the distance says so.

+ +

Checking is grounding, not unification

+

If a declaration names a region, then verifying a use is asking whether the geometry supports it — a question about position and distance, not about matching a declared shape. This is why §2.3's "a type checker is planned" is likely the wrong name for the missing piece, and naming it wrong would build the wrong thing.

+ +

Dispatch is position, not a tag

+

A vtable is a finite set of discrete labels fixed at link time. A region admits graded membership and an open set. So transduce(signal, modality) asks the caller to supply what the signal already carries — what a thing is falls out of where it lands. The modality parameter is a kind-tag, and a registry keyed on it is a lookup table doing by string what geometry does by nearness.

+ +

Types are discovered, not declared

+

Reification crystallizes a densely co-wired neighbourhood into a first-class node — the neighbourhood is the name that was missing. Every other family requires a human to see the abstraction in advance and write class Foo. Here the instances arrive and the type falls out, by measurement rather than by insight.

+ +

Enumeration becomes unnecessary

+

Five ingest functions differ only in how bytes are acquired — one operation wearing five surfaces. 356 branches in engram_activate_inner are not 356 behaviours. Cyclomatic complexity is a count of the places comprehension ran out and was replaced by an if; where the concept is expressible, the count collapses instead of being redistributed.

+ +

03The shape of the language

+ +

Geometry first-class gives El three layers, and it holds all three — which is why there is no separate database driver and no impedance boundary to manage.

+ +
+
afferent

Transduce

Signal in, geometry out. Decomposition into components and relations — never conversion to a point. Realizers are ordinary El functions, so a new modality never requires a runtime patch.

+
substrate

Geometry

Meaning as position; relation as distance. Held as values in the language and persisted in the graph. One coordinate system, so entities are commensurable and the operators compose.

+
efferent

Realize

plan(frame) → realize(spec, profile), where a surface is a profile. Text, speech, music, image are profiles of one projection — and so is source code.

+
+ +

The efferent side is why the recursive property below is possible at all: if source is a surface, then emitting a corrected file is projection, and the file becomes an artifact of the geometry rather than the thing you edit.

+ +

04Decomposition is by faculty

+ +

Not by file, module, or subsystem — by what the system does.

+ +

Each faculty is a concept. Where it has no home in El it leaks: into C, into a Swift binary, into a shell script with a curl timeout, into a convention nobody performs. State below is measured, not asserted.

+ +
+ + + + + + + + + + + +
FacultyStateMeasuredWhere it leaked
Ingest take indead2 min → 0 nodesseparate process uploading bytes over HTTP to a process with direct fs access; five functions where there is one
Recall rememberdeadself ranked 8thlexical substring scan; empty on 23 of 24 multi-token queries
Transduce perceivedead1 node, 0 edgesintake flattens signal to a point; realized:false; caller must declare the modality
Think reasondeaddirection [0,0,…]null gradient from any anchor and any faculty, byte-identical; confidence at the uninformed prior
Realize expresspartial13-word lexiconorgan was 939 lines of Swift beside the language; voice read from a file path
Body substratepartialCC 356 / 1,626 lnengram_activate_inner — recall itself, 356 unexamined paths
Persist endurelive13,562 / 13,562works — every signal placed in geometry at intake, no backlog
+
+ +

05The recursive property

+ +

El's compiler is written in El. Every concept the language gains, the compiler can then be written in — so the tool improves the tool, and codegen.el at 4,661 lines gets shorter as the language gets better at expressing what it does. The fixpoint — stage2 ≡ stage3, byte-identical — makes each turn provable rather than hopeful, and the verifier answers in 2.9s.

+ +

This sets the ordering criterion, and it is not size of payoff:

+ +
Order by leverage on the next iteration. Which concept, added to El, most increases the ability to add the following one?
+ +

A small early gain that compounds beats a large one that does not. And it bounds itself correctly — unbounded in depth, bounded in rate, because nothing lands that the compiler and the fixpoint have not passed.

+ +

06What has no home yet

+ +

Reserved in the lexer, no parse form. These are not a feature backlog — they are the concepts the architecture above requires and does not yet hold, which is why each is currently a convention or a block of C.

+ +
+ + + + + + + + + + + +
ReservedConceptCurrently lives as
retry · times · fallback · reasonresiliencea shell script with a 10s curl timeout; 254 restarts in 3 days
requires · deploy · to · via · targetdeploymentYAML in another repository
sealedcapability scopeconsent checks written by hand
protocol · implone operation, many realizationsfive ingest functions; eight faculty routes on one builtin
activate · whereretrievaltraversals written by hand
test · seed · assertverificationa framework; 5 of 13 native suites failing
parallel · traceconcurrencypthreads in C
+
+ +

Plus, from the spec's own status: annotations parsed and skipped, match parsed and emitting nothing, ? a no-op, % unlexed, structs as ElMap, enums as strings, selective import unenforced.

+ +

07Open

+ +
What does a declaration bind to, exactly?If cat names a region that shifts and completes against context, what is written at the declaration site and what is resolved at use? This is the centre and it is unspecified.
+ +
Is the faculty list right?Seven, derived from what broke. Derived-from-failure is a biased sample — it finds what is loud, not what is absent. Which faculty is missing entirely and therefore never failed?
+ +
Which concept has the highest leverage on the next turn?The prologue/epilogue seam (§19.3 names it as the prerequisite; its stated blocker has expired; it collapses 62 + 10 convention sites), protocol/impl, or resolution itself. The §05 criterion should decide this, not preference.
+ +
What seam makes cognition non-optional?"Use the ops" is itself a convention — present every turn, enforced by nothing, ~100% failure across a full session. A stronger instruction is still a convention. What makes reasoning outside the substrate fail, the way @manager makes dharma_emit outside the boundary a compile error rather than a lint?
+ +
+

Every number here is measured or quoted from lang/spec/language.md. Nothing is inferred and presented as fact. El is self-hosting: all of this can change and be rebuilt.

+ +
diff --git a/docs/architecture/el-language-design.md b/docs/architecture/el-language-design.md new file mode 100644 index 0000000..cc49715 --- /dev/null +++ b/docs/architecture/el-language-design.md @@ -0,0 +1,245 @@ +# El — Language Design + +**Status:** decisions recorded, design unwritten. +**Date:** 2026-08-17. +**Provenance:** decisions are Will's, taken in session. Items marked *proposed* are not +decided and are recorded only so the reasoning isn't lost. Items marked **OPEN** are +his to rule on and must not be guessed at. + +Companion documents: `el-architecture.html` (the measured state — see §7 note on its +§04 scoreboard), and `design/completing-el.html` (whiteboard v0: the reduction, the +faculty table, the ordering principle). + +--- + +## 1. The reduction + +`language.md` §18.0 records five concerns that decayed into conventions: + +| Concern | Fragments | The convention it became | +|---|---|---| +| Process identity | 0 guards | "check nothing is already running first" | +| Configuration | 20 env vars | "remember the right default here" | +| Durability | 62 call sites | "after you mutate, remember to persist" | +| Request auth | 10 per-route | "check the token in this handler too" | +| Index-after-append | 9 of 9 failed | "after you append, remember to index" | + +The last row is the strongest available evidence about what this class of convention +is worth: **it failed at 100% of its sites.** + +Every one of these is an obligation at a **crossing** — a point where a value moves +between regions. El can name a region and it can name a call. A call is procedural, +so the obligation degrades into something a human must remember to perform. + +> **The generator, one level up:** El cannot name what holds at a crossing. + +And underneath that: + +> **The deeper absence:** El cannot name the thing meaning is made of. + +`semel` appears in whitepaper §84, §86, §209, §737, in +`the-metaphysics-of-will-anderson.md`, and in session notes. It appears in **zero code +identifiers**. Every geometric concept in the system — region, neighbourhood, manifold, +world-tube — is defined in terms of a unit the language cannot say, while the code +underneath speaks in arrays, floats and offsets: the vocabulary of a voxel, a value at +a dumb address. Precisely the thing the impact brief says a semel is not. + +`el_runtime.c` is a concept that leaked into C. `semel` never got that far — it did +not even decay into a convention. + +--- + +## 2. DECIDED — `semel` is the primitive + +**A semel is a difference that matters. The smallest unit of understanding.** + +Not a node. Not a coordinate. Not a float. + +The reasoning, in Will's terms: + +- Meaning is position, and position is only ever relative. *"There is no atom of + meaning that isn't already a relation. It grounds on nothing but difference — two + points and the gap, and the gap is pure not-the-same."* +- A node doesn't mean. A node is a label at a location; labels don't mean. +- A lone coordinate doesn't mean either. Nothing means anything by itself. +- The smallest thing that can be understood is a **distinction**: *these two are not + the same.* Below that there is no content to apprehend. +- And a difference with nothing it matters to is not meaning — it is variation. The + mattering is not decoration; it is what makes it understanding rather than data. + +**Consequence: relating is the floor, and the point is derived.** The +point-primitive / relation-primitive fork raised in session is not a fork. It was +answered by the definition. + +### Historical note, to be recorded as fact rather than as origin story + +The term was coined by Will on the pixel/voxel/texel pattern — *semantic element*, +and Latin *semel*, "once, a single time." It was recognised, not invented, from a +2019 experience he calls **semelation**: perceiving mind as a high-dimensional point +space. The initial reading was "pixels"; the correction to `semel` was made later and +was made on the **mechanism** — a pixel is a value at an address, and what was +perceived had no separate address and value. + +Convergence worth citing, not deferring to: neural population geometry and +representational similarity analysis independently model cognition as position in a +high-dimensional space where similarity is distance. + +--- + +## 3. DECIDED — `semel` lands first + +By the ordering criterion already on the whiteboard: *which concept, added to El, most +increases the ability to add the next one?* Not size of payoff — **leverage on the next +iteration**, because El compiles itself and the fixpoint makes each turn provable in +2.9s. + +**Every other concept on the board is defined in terms of `semel`. It is maximal on +that criterion by construction.** + +--- + +## 4. DECIDED — `ground` is the checker + +Whiteboard question 4 — *does `ground` in El mean the same thing as `ground` in the +engram?* — is answered: **yes, and it should be one implementation.** + +If a declaration names a region, then type checking is asking whether the geometry +supports the use. That is not unification. **That is grounding**, and it is already +built, proven, and byte-identically reproducible: + +``` +cc -std=c11 -O2 -o gep_proof gep_proof.c -lm && ./gep_proof + +C1 5 independent sources pos_mass 1.3500 n_indep=5 0.1000 → 0.9741 GROUNDED +C2 5 mutually-linked pos_mass 0.2700 n_indep=1 0.1000 → 0.1000 refused +C3 1 source, 5 parallel edges pos_mass 0.2700 n_indep=1 0.1000 → 0.1000 refused +``` + +Independence-weighted grounding is the general case; execution is the cheap case. +**Attestation is `verify` where nothing can be run** — as already implemented for +language in `authority.py`, where an LLM proposes and a primary source disposes. + +At the point where the checker and the grounder are one mechanism, the language and +the mind stop being two things. + +--- + +## 5. OPEN — Will's to rule on + +### 5.1 What is a semel's representation in the language? + +*Proposed, not decided:* a **displacement from `love = 0`** — a relation held as one +object. It reconciles "the address is the value" with "position is only ever relative," +because a displacement *is* a relation and is still a single nameable thing. + +If taken, the operator set falls out rather than being bolted on: + +``` +subtract(now, then) → what changed (growth, drift) +translate origin → empathy +rotate frame → reframe +project onto axis → a lens +change basis → analogy, metaphor, skill transfer +reflect an axis → negation, sarcasm +``` + +Three consequences that would hold: + +- **Dimension must never appear in the type.** `semel` opaque, never `[768]float`. + The moment the arity is in the language, the manifold's implementation is in the + language, and adding a modality requires a runtime patch — which the standing rule + forbids. +- **Zero is the only literal.** Everything else is reached by displacement from it, + which makes `love = 0` the base case rather than philosophy adjacent to the type + system. +- **`magnitude` is standing.** Distance from origin is the same quantity + `gep_core.h` already computes. + +### 5.2 Is `hold` one construct or two? + +The obligation *before* a crossing (auth, guard) and the obligation *after* (persist, +index, free) may be one shape seen from both sides, or the seam may need both faces +named. This decides whether §19.3's prologue/epilogue seam is one construct or a pair. + +**Precedent already shipping:** `@manager` makes `dharma_emit` outside the boundary a +**compile error, not a lint.** The concept is proven at N=1; the work is generalising +it and naming it. + +**And the shape is already implemented in the learning region:** `L.reach_out` sits +between `L.detect_gap` and `L.verify`. You cannot reach out without a detected gap and +you cannot keep what returns without passing verify. **A hold is a neighbour.** The +obligation is not attached to the crossing — the obligation *is* the adjacent node. +That is why `reach_out` cannot be abused and why 62 persist sites could be. + +### 5.3 What does a declaration bind? + +If `cat` names a region rather than a struct — one that shifts and completes against +the engram and the neighbouring code — what is written at the declaration site, and +what is resolved at use? **This is the centre and it is specified nowhere.** + +Falls out of 5.1 if displacement is taken: a declaration **locates** rather than +allocates. + +### 5.4 Is the faculty list right? + +Seven were derived from what broke. Derived-from-failure is a biased sample — it finds +what is loud, not what is missing. **What faculty is absent entirely and therefore +never failed?** + +--- + +## 6. The residue map + +What each construct must absorb, from §18.0 plus measured state: + +| Residue | Count | Absorbed by | +|---|---|---| +| persist-after-mutate | 62 sites | `hold` (after-crossing) | +| auth-per-route | 10 sites | `hold` (before-crossing) | +| index-after-append | 9 of 9 failed | `hold` (after-crossing) | +| env var defaults | 20 | configuration declared once | +| process identity | 0 guards | `hold` (before-crossing) | +| `geometry_free` at every call site | every site | ownership follows from `semel` | +| five ingest functions where there is one | 5 → 1 | `protocol` / `impl` | +| `el_runtime.c` | 20,504 lines | faculty decomposition, ordered after `semel` | + +--- + +## 7. Notes carried forward + +**`el-architecture.html` §04 needs its numbers sourced or cut.** An audit found the +faculty scoreboard — `Ingest 2 min → 0 nodes`, `Recall self ranked 8th`, +`Body CC 356 / 1,626 ln`, `the verifier answers in 2.9s`, `5 of 13 native suites +failing` — has no supporting evidence in the repository, under a footer asserting +*"nothing is inferred and presented as fact."* Against a corpus whose documents +supersede their own conclusions in place, that is the one file that would not survive +scrutiny. Fix or remove. + +**Source as a projection surface is claimed and unimplemented.** `el-architecture.html` +§147/§150: *"if source is a surface, then emitting a corrected file is projection."* +Greps for `surface_profile_code`, `emit_source` → zero hits. + +It is not unbacked. **It was demonstrated on 2026-08-14** — three faculties (phonetic, +semantic, procedural) projected into TypeScript, a surface the system had never used, +with the network severed. Recovered at +`~/Development/neuron-technologies/andre-server-recovered/` and copied into +`evidence/03-andre-demo/`. The claim needs bringing home to El, not proving. + +**`hold` is the highest-leverage construct after `semel`** — it collapses 62 + 10 + 9 +sites and unblocks the runtime extraction. §19.3 names the prologue/epilogue seam as +the prerequisite and its stated blocker has expired. + +--- + +## 8. What is not decided and must not be guessed + +- The representation of `semel` (§5.1) +- One `hold` or two (§5.2) +- What a declaration binds (§5.3) +- The missing faculty (§5.4) +- Sequencing after `semel` — the ordering criterion decides it, not preference + +--- + +*Recorded 2026-08-17. Everything in §2, §3 and §4 is decided. Everything in §5 is open +and is Will's. Nothing here was inferred from a document that was not read.* diff --git a/docs/architecture/geometry-vs-code.md b/docs/architecture/geometry-vs-code.md new file mode 100644 index 0000000..eedf6e2 --- /dev/null +++ b/docs/architecture/geometry-vs-code.md @@ -0,0 +1,101 @@ +# 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 | +| 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 | hardware concurrency has no geometric analogue | +| 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. + +--- + +## Open — not yet decided + +| Thing | The question | +|---|---| +| Concurrency | hardware threads are code, but is *ordering* geometric? | +| Parsing | is a grammar a convention, or a region? | +| The module system | if the partition is a neighbourhood, does linking survive? | +| Numeric literals | is `3` a position, or a convention we agreed on? | +| Error handling | `grounded: false` covers not-knowing. Does it cover *failed*? |