Using Dinf

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.

1. Nesting — any working term expands into its own full structure. Depth is free.
2. 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 "[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.

1. 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.

1. 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.

1. Two frames fighting? Don't adjudicate. ADJOIN.
2. 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.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: sancovp
• Source: sancovp/dinf
• License: MIT

Install and usage instructions live in the source repository linked above.