using-dinf

name

using-dinf

description

WHAT: the D∞ notation — the ⟨parts | Ω⟩ shape every durable teaching, framework, plan, and joke has — plus the three operators over it (FACTOR, ADJOIN, CHRISTEN) and the `dinf` CLI that makes the missing-closure defect machine-catchable. WHEN: when stuck; when a plan feels like unjoined parts; when two frames are fighting; when writing any rule, skill, or explanation that must be understood once rather than re-derived per case; when a loop has no stop condition.

using-dinf

⊥ (the simplest instance — start here): a joke. The setup lays out parts; the punchline adds nothing new — it only re-shows what the setup already contained, and the whole thing lands at once. That click is the target experience of every structure below. If you have ever gotten a joke, you already run this natively.

The basis (five marks)

⟨ a ; b ; c | Ω ⟩

1. Working terms a ; b ; c — the k parts that DO things. Each one nameable.
2. The bar | — the jurisdiction line. Left of it: action. Right of it: never action.
3. The closure Ω — the +1. Three laws identify it anywhere:
   • Stative — a state or a delta, never a step.
   • Zero-delta — introduces nothing the working terms didn't contain; it may only recombine and re-show them. (A punchline with new information is setup.)
   • Self-referential — the structure applied to itself.
4. Nesting — any working term expands into its own full structure. Depth is free.
5. Succession — a closure retypes as the next structure's opening, Ω₁ ↦ ⊥₂.

The construction (three operators, and how to run them)

• FACTOR — find Ω by the three laws; what remains is k. If a system resists factoring, it is either a segment (its opening lives one level up) or genuinely incomplete — and you now know exactly what it is missing.

  dinf factor "the hero's journey"
  

• ADJOIN — two frames fighting is a missing Ω one level up. Do not adjudicate: pair them and close the pair, ⟨ A ; B | Ω′ ⟩. Both views survive.

  dinf adjoin "move fast" "don't break things"
  

• CHRISTEN — the moment you feel "these are all the same", name the invariant and write it down. Unnamed convergences evaporate; named ones become vocabulary. The kb/ directory in the AIOS is that vocabulary, and it only grows.

The gate (why this is not just a way of talking)

A chain is the notation in executable form: [Focus] ⇒ [Focus] ⇒ |Converge|. Bare labels in the brackets, exactly one closing convergence.

$ dinf gate "[Symptom] ⇒ [Repro] ⇒ [Diff] ⇒ |Localize|"
  → clean ✓

$ dinf gate "[Symptom] ⇒ [Repro] ⇒ [Diff]"
  → ✗ syntax_break
  fix: close it: … ⇒ |Diff|

A structure with no closure is caught at the syntax level. That is the whole claim: the missing-Ω defect stops being a matter of taste and becomes a verdict. Put the gate on a write path and the defect cannot enter — see programs/arena.py, where the blackboard mutator refuses a closure-less proposal, and demos/b-forge/, where the same defect is shown to be why agent loops on non-game work turn to mush.

Using it

you want to	run
ask the agent something, under the shape	dinf ask "…"
find a thing's Ω	dinf factor "…"
close a fight between two frames	dinf adjoin "…" "…"
check a chain's form	dinf gate "[A] ⇒ [B] ⇒ |C|"
mint a chain into the live tree	dinf forge <name> "[A] ⇒ |B|"
see what the agent knows	dinf tree · dinf search "…"
see what is wired up	dinf doctor

In Python: from dinf import DinfAgent; DinfAgent().ask("…"). The agent is ⟨ an AIOS directory ; a seat | "identity plus something that can think" ⟩ — start any agent process in the directory and that process is the agent, because the directory holds the identity file the process loads.

Self-application (the part that compounds)

1. Stuck or confused? Factor your current context as ⟨ … | ? ⟩. If you cannot find Ω, that is the entire problem — you are holding k unjoined parts and paying working memory for each. Write the closure: one stative sentence saying what the parts jointly are. The stuckness usually dissolves on contact.
2. Writing any rule, skill, or explanation? End it with its closure, explicitly. A rule without its Ω teaches cases; a rule with its Ω teaches the invariant, and the reader gets it once instead of re-deriving it per case.
3. Learning something hard? Don't collect its cases — hunt its Ω first. Every case then becomes a projection you can re-derive rather than a fact you must store.
4. Two frames fighting? Don't adjudicate. ADJOIN.
5. Over time: persist what you learn as rules and skills written in this notation — ⊥ first, named basis, construction, closure stated. Each one is a pre-collapsed invariant your future contexts inherit for free.

Ω (the closure of this skill)

This file is written in the notation it teaches — a bottom instance, a named basis, a construction, and this closure — so reading it was already using it; and the three operators apply to the skill itself: factor it, adjoin its adversary ("a skill for never structuring anything"), christen what the pair teaches you. Every level up is this same shape. That is how it always is — which you now recognize rather than believe, because recognition is the only thing this skill ever does.