Unified dense medium — think in media, not “shorter English”

You wanted all of: new symbolic medium · vision as codec · research packing math · BPE war.

This is one stack. Not playbook slogans.

0. Wrong vs right mental model

Image insight (real): a vision patch grid is a fixed budget of channels over a 2D lattice.

Position carries meaning; many “facts” share one frame; no grammar tax.

Your research insight (real): attention output \(A(q)\) lives near a low-\(r_\Sigma\) set; a small cover (anchors) replaces the full key list; \(A_0\) = winner-only often enough.

Unified law:

Dense media = low-dimensional chart of the *thing that affects the next decision*

             + fixed lattice / codebook

             + stream of indices (not essays)

1. Four layers of one codec (all options)

┌─────────────────────────────────────────────────────────┐

│ L4  VISION FRAME (optional)                             │

│     raster / diagram of the lattice — multimodal path   │

├─────────────────────────────────────────────────────────┤

│ L3  BPE SURFACE                                         │

│     strings chosen so each cell is ~1 model token       │

├─────────────────────────────────────────────────────────┤

│ L2  LATTICE MEDIUM  «semantic image»                    │

│     H×W grid of glyphs from closed alphabet             │

├─────────────────────────────────────────────────────────┤

│ L1  MANIFOLD PACK (your maths)                          │

│     anchors / A0 / paid novelty / hybrid window         │

└─────────────────────────────────────────────────────────┘

Everything above sits on L1 math. L2 is the image-like symbolic form. L3 makes tokenizers not sabotage you. L4 is when vision wins.

2. L1 — Manifold pack (from your findings)

Object to store: not history text, not full K — the cover of decision-relevant state.

Encode algorithm (no train)

inputs:  stream of events e_t (user, tool, model)

params:  K_max anchors, W local window, ε similarity



state:

  anchors A[1..k]   # prototype facts (strings or slots)

  assign  π[t]      # which anchor event t maps to

  local   L[-W:]    # exact recent events

  paid    Ξ         # count of true novelty



on event e:

  if e in local window need: append to L; done



  # A0 / winner: if e is retrieval/tool cloud → keep only best claim

  if e is multi-hit: e ← WIN(e)   # single best row/claim



  # paid novelty (split test): does e change decisions?

  if exists anchor a with sim(e,a) ≥ 1-ε AND same decision class:

      π[e] = a                    # ABSORB — no new token budget

  else:

      spawn or refine anchor      # PAID

      Ξ += 1

      if |A| > K_max: merge closest pair (collapse)



emit_for_prompt:

  LOCAL = L

  COVER = A[1..k]                 # r* prototypes, not full stream

  Δ     = changes since last emit

Why this is “image thinking”:

an image doesn’t list every photon history — it stores a field on a grid.

Cover \(A\) is the field’s palette + occupancy. Full chat is the photon list.

Research map:

3. L2 — Lattice medium = semantic image made of glyphs

Stop thinking “document.” Think frame.

Geometry

        c0  c1  c2  c3  c4  c5  c6  c7

     ┌───────────────────────────────

  r0 │ G  | ·  | ·  | ·  | ·  | ·  | ·  | ·     goal row

  r1 │ F  | a3 | a1 | ·  | ·  | ·  | ·  | ·     fact slots (anchor ids)

  r2 │ D  | d2 | ·  | ·  | ·  | ·  | ·  | ·     decisions

  r3 │ O  | o1 | ·  | ·  | ·  | ·  | ·  | ·     open

  r4 │ N  | n4 | n1 | ·  | ·  | ·  | ·  | ·     plan ops

  r5 │ X  | x1 | ·  | ·  | ·  | ·  | ·  | ·     constraints

  r6 │ R  | #c91 ·  | ·  | ·  | ·  | ·  | ·     external refs

  r7 │ Δ  | +F | -O | ·  | ·  | ·  | ·  | ·     patches

• Fixed H×W → fixed max token budget (image-like).
• Empty = · single cheap glyph.
• Cell content = symbol from closed alphabet (below), not English clause.
• Position is address — like pixels; no “the fact is…” tax.

Alphabet \(\Sigma\) (closed — models already parse this)

ROLE:  G F D O N X R Δ ·

OPS:   + - ~ > = ? ! @ #

IDS:   a0..aZ  d0..  n0..  x0..   (anchors)

REF:   #hex or #c91

ENUM:  ok fail tx auth mig pci ...  (domain pack, ≤64 words)

SEP:   | / ,

Full meaning lives in PALETTE (prefix, cached once):

PALETTE v1

a1=users_table_postgres_tx

a3=auth_blocked_oauth_redirect

d2=idempotency_key_header

n1=write_migration

n4=verify_sig

x1=no_raw_pan

#c91=doc:pci_checklist

Frame stream (what each call pays):

G|ship_bill

F|a3|a1|·|·|·|·|·

D|d2|·|·|·|·|·|·

O|·|·|·|·|·|·|·

N|n4|n1|·|·|·|·|·

X|x1|·|·|·|·|·|·

R|#c91|·|·|·|·|·|·

Δ|+F|·|·|·|·|·|·

That is an image: 8×8 occupancy of meaning, palette outside like a color table.

Compare English (~90+ tokens of story) → frame (~40–60 atoms, many single-token glyphs).

4. L3 — BPE war (make the lattice cheap under real tokenizers)

LLMs don’t see characters; they see BPE pieces.

Dense medium dies if oauth_redirect becomes 4 tokens every cell.

Rules for surface form

1. Palette values may be long (paid once in cached prefix).
2. Frame cells only use:

• single ASCII letters/digits: G F D a1 n4 · + #
• short enums in tokenizer’s frequent set: ok fail tx

1. Prefer ids that tokenize as 1 piece: a1 d2 n4 not anchor_1.
2. Avoid spaces inside cells; use | row structure models already know from tables/code.
3. Measure with the real tokenizer you pay for:

# sketch

def cost(s, encode): return len(encode(s))

# optimize palette ids to minimize sum cost(frame_i)

BPE-mining trick (hours, no train)

• Take your last 1k agent traces.
• Find repeated 2–5 word phrases.
• Assign each a code a# that is one token in that model’s vocab if possible (· ✓ → sometimes 1 token — test).
• Prefix = dictionary; stream = indices only.

→ Same as image palette + indexed pixels.

5. L4 — Vision as codec (when the lattice should become a real image)

When vision wins

Protocol

1. STATE lives as lattice (L2) always in the orchestrator.

2. If spatial: RENDER(lattice|ui) → PNG.

3. One vision call: "read frame → fill lattice cells only".

4. Store lattice thereafter; DO NOT re-send PNG every turn.

5. Re-render only when paid novelty changes layout.

That’s image efficiency done right:

image = burst encode of a field; lattice = cheap working memory.

Optional radical path (research-y): render the H×W glyph grid as a monospace bitmap and feed vision — some pixel-LMs treat pages as images to beat tokenization. Only worth A/B on your model.

6. One encode pipeline (all layers)

event

  → L1 pack (WIN, absorb/paid, hybrid window, K_max anchors)

  → L2 write cells on H×W lattice (indices into palette)

  → L3 stringify with BPE-cheap glyphs

  → prompt = cached(PALETTE+schema) + FRAME + optional LOCAL

  → if spatial need: L4 render FRAME/UI → vision once → back to L2

  → model outputs Δ cells only (not essays)

  → apply Δ; if |cells| overload → reencode (metamorphosis collapse)

Model system rule (one sentence):

You only see PALETTE+FRAME; answer by emitting Δ rows; never narrative memory.

7. Worked example (same facts)

Prose (bad medium):

“We decided to use Postgres for the users table because we need transactions. Auth is still blocked on the OAuth redirect URI. Next step is to write the migration. Constraint: do not store raw card numbers.”

L1 pack:

anchors: a1=pg+tx users, a3=oauth blocked, d2=…, n1=migration, x1=no pan

paid Ξ small; no debate stored.

L2+L3 frame:

PALETTE: a1=pg_users_tx a3=oauth_block n1=mig x1=no_pan

FRAME:

G|bill

F|a1|a3

N|n1

X|x1

L4: only if this were a DB schema diagram screenshot — then extract to same FRAME.

8. What “magic” is allowed here

The induction-motor move: relation = “field on a lattice + small palette + paid updates”,

not “rename summary as Quantum Context.”

9. Build order (weekend → real)

Kill bar: ≥25% tokens_in on multi-turn and ≤10% quality drop.

If fail: K_max / W / alphabet wrong — not “idea wrong.”

10. One sentence

Stop storing language. Store a small indexed field (palette + lattice) of the low-dimensional cover of what changes decisions — text glyphs when symbolic, pixels when spatial, BPE-cheap either way.

That is all four options as one medium.