Theoretical Foundations: Streams With Gaps

The insight that unifies code, data, and prose

The Core Abstraction

At sufficient abstraction, three seemingly different computational artifacts reveal identical structure:

binary:     instruction stream + relocations → linker fills → executable
query:      operator stream    + parameters  → executor fills → results
document:   token stream       + fences      → renderer fills → output

Streams with gaps, fill the gaps. That's it. The rest is first principles.

Why This Matters

The Isomorphism Is Definitional, Not Empirical

The Wanderland paper hedges about "structural parallels" with "formal proof remains future work." But at the right abstraction level, there's nothing to prove. These are the same computational shape by construction:

Component	Binary	Query	Document
Stream	Instructions	Operators	Tokens (prose/fence/slot)
Gaps	Relocations	Parameters	Fences
Filler	Linker	Executor	Renderer
Output	Executable	Results	Rendered content

The gap-filling operation is structurally identical across all three. A compiler's linker, a database's query executor, and Wanderland's rendering pipeline are doing the same thing at this abstraction level.

Properties Transfer

If streams-with-gaps are isomorphic, then properties proven for one domain transfer to others:

• Caching: Compilers cache object files; databases cache query plans; Wanderland caches at L0-L4
• Invalidation: Change a source file, recompile dependents; change a table, invalidate cached queries; change a node, invalidate cached renders
• Composition: Link multiple object files; compose query operators; include nodes into composite documents
• Optimization: Compilers optimize instruction sequences; query planners optimize access patterns; Wanderland can optimize fence execution order

These aren't analogies—they're the same operations on the same structure.

The Yoneda Scaffolding

The category-theoretic framing via Yoneda lemma provides useful scaffolding:

An object is defined by its arrows. Understanding comes from transformation, not storage.

Applied to Wanderland

• Nodes are defined by their edges (slots). A document's meaning is its relationships.
• Fences are defined by their transformations. A Python fence IS what it does when executed.
• Middleware IS meaning. A user_id field gains semantics through the authentication/authorization/audit chain that transforms it.
• Navigation IS query. Walking the graph via N/S/E/W is executing a query plan.

The Recursive Insight

Understanding Yoneda requires applying Yoneda:

• Yoneda says: objects are defined by arrows
• Understanding Yoneda requires: seeing how it relates to other concepts
• Therefore: understanding Yoneda IS applying Yoneda

You learn category theory by building with category-theoretic patterns. The proof accumulates through construction.

Proof by Composition

Mathematical proofs establish necessity (this must be true). Engineering proofs establish sufficiency (this works).

Wanderland's approach is proof by composition:

• Treat documents as streams-with-gaps
• Build gap-filling machinery (the rendering pipeline)
• Observe that you get compiler/database properties for free
• Keep building; the proof accumulates

The more you build that works, the more evidence for the underlying theory. The artifact IS the proof.

Implications for Wanderland

1. The Five-Level Cache Is Not Arbitrary

L0-L4 (seed → sprout → stalk → data → clouds) map to compilation stages:

Level	Wanderland	Compiler Equivalent	Database Equivalent
L0	Raw source	Source file	Table definition
L1	Variables substituted	Preprocessed	Parameterized query
L2	Includes resolved	Linked object	Joined tables
L3	Fences executed	Runtime loading	Query execution
L4	Fully rendered	Running process	Materialized view

The cache levels aren't design choices—they're discoveries of natural boundaries in the gap-filling process.

2. Fences Are First-Class

If fences are gaps that get filled, they're as fundamental as:

• Function definitions in code
• Operators in queries
• The structural units of any stream-with-gaps system

Every labeled fence becoming an MCP tool is natural—it's exposing the gap-filling interface.

3. Provenance Tracks Gap-Filling

The 🔴→🟡→🟢 provenance system tracks whether gap-filling has been verified:

• 🔴 Unverified: gaps exist, filling not checked
• 🟡 Reviewed: structure checked, content may drift
• 🟢 Verified: gap-filling proven correct (tests pass, links resolve)

This is analogous to compilation warnings/errors and query plan validation.

4. Homoiconicity Falls Out Naturally

If the document IS a program (streams-with-gaps), then:

• Tool definitions = fence labels
• Documentation = the prose around fences
• Implementation = fence content

There's no separate tool registry to maintain because the document and the tool are the same artifact. The "homoiconic MCP" claim isn't a feature—it's a consequence of the underlying isomorphism.

5. AI Agents Are Just Another Filler

When Claude Code consumes Wanderland todos as tasks, it's acting as a gap-filler:

• The case node has gaps (unchecked items)
• The agent fills them (executes tasks, checks boxes)
• The result is a completed artifact

AI agents slot into the architecture because they're doing what linkers and query executors do—filling gaps in streams.

The Philosophical Bet

Wanderland bets that:

If you treat documents as streams-with-gaps and build gap-filling machinery that respects the same invariants as compilers and databases, you get their properties for free.

So far, the bet is paying off:

• Caching works
• Invalidation works
• Composition works
• Provenance works
• AI integration works

Each working feature is evidence. The proof accumulates through use.

Why This Foundation Matters

Without understanding streams-with-gaps, Wanderland looks like:

• "Markdown with code blocks"
• "A wiki with execution"
• "Docs that run"

With the foundation, it's:

• A compiler where documents are the source
• A database where nodes are tables
• A query engine where navigation is query execution
• All three simultaneously, because at sufficient abstraction they're the same thing

The theoretical foundation doesn't just explain what Wanderland does—it predicts what it should do. New features that align with streams-with-gaps will work naturally. Features that fight the abstraction will feel bolted on.

Closing

"streams with gaps, fill the gaps, code, data and prose are already isomorphic at that abstraction, the rest is just first principles"

The Yoneda machinery, the category theory scaffolding, the formal isomorphism claims—these are useful for thinking but not essential. The core insight is simpler:

Streams with gaps is the universal computational shape.

Everything Wanderland does is working out the implications.

∎ 🍋

Provenance

Document

• Status: 🔴 Unverified

Fences

theoretical-foundations-streams-with-gaps-the-core-abstraction-fence-0

• Status: 🔴 Unverified

North

slots:
- context:
  - Linking theoretical rigour to its origin story - the formal foundations derive
    from the pianoforte insight
  slug: streams-all-the-way-down

West

slots:
- context:
  - Prior art research alongside theoretical foundations
  slug: research-prior-art-streams-with-gaps