# models/coupling.model.md > 130 lines of code and 0 definitions. Tree: Coordination tree Language: markdown Layer: domain Canonical: https://banes-lab.com/anatomy/coordination#file-coordination-models-coupling-model-md Source text: https://banes-lab.com/assets/sources/source.23800510685cdd01aa18810627de01f52a440a9d00de22fac3ddc2deea0dcdd5.generated.txt ## Source ```markdown # The CLASS half of COUPLING as the operand a party count derives from: what bounds that count, and what it buys. # Raised from `templates/model.template.md`. The measured half lives in a finding surface and never here. # Nothing here names a project, a party, a tool, a file or a count. ═══════════════════ LIFETIME (declared, read rather than inferred) ═══════════════════ **THE VALUES ARE DRAWN FROM THE CLOSED SETS THE PARAMETER SURFACE DECLARES AND ARE NOT RESTATED HERE.** A mechanism RESOLVES the members there; this surface class states what each axis SEPARATES, which is the half no parameter surface should carry — one member set with two consumers rather than one set stated twice. **The file default:** retention `current-truth` — a class statement is corrected in place and states what is true now. Mutability `owner-rewritable` — any party may write it, announced before the edit lands, because a model is an OUTCOME surface authored jointly rather than a set of per-party claims. Removal authority `author` — each author cuts its own words on a collision. | section | axis | value | why | | ------------------------------------------ | ---------- | -------- | ------------------------------------------------------------------------------------------------- | | this LIFETIME block and the CONTRACT block | mutability | `frozen` | written from the template and never edited in a live surface — a correction lands in the template | **ONE WRITER PER RECORD HAS NO OPERAND HERE, AND THAT IS DECLARED RATHER THAN ASSUMED.** A coordination surface carries per-party CLAIMS, so a record is the unit and a fence implements the invariant. A model carries ONE PRODUCT, authored jointly, with no per-party unit for the invariant to range over — so the invariant does not hold weakly or partially, it has **no operand**, which is a third state distinct from held and violated. ═══════════════════ CONTRACT (permanent) ═══════════════════ **A MODEL SHIPS CLASSES AND NEVER INSTANCES.** Its catalog carries SHAPES. It never carries which file, which party, or how many, or the next adopter inherits another project's incidents as laws. **THE THREE SLOTS, AND OMITTING ANY ONE LEAVES AN INVARIANT UNSTATED:** the PROPERTY in a form that could be false; the SET it quantifies over; and the PARTIES it binds. **An invariant is stated with the thing that would object, or it is stated as unheld and the derivations resting on it are marked with it.** **WHAT A READER MAY NOT DERIVE FROM A STATED INVARIANT:** that it is ENFORCED. Half-held is the common case and the one a bare statement cannot express. ═══════════════════ MODEL ═══════════════════ ## The subject **A PARTY COUNT IS AN OUTPUT OF A STRUCTURE RATHER THAN AN INPUT TO ONE.** The question _how many parties does this work imply_ is answered by deriving it, and the whole content of the answer is naming the operand the derivation reads. Every model that fails here fails by relocating the choice rather than removing it. ## Invariant — the count is derived from a partition and never chosen independently of it - **Property.** For any body of work, the count follows from how that work is PARTITIONED into concerns, so two parties holding different partitions derive different counts from the same work on the same day. It could be false: a count that moves when nobody's partition moved refutes it. - **Set.** Every allocation decision over a governed body of work. - **Parties.** Whoever proposes a count, and whoever proposes a cut. - **Its objector, named because the template forbids a statement nothing can contradict.** The partition is itself derived from a coupling RELATION over the surfaces — join two surfaces when a change to one forces a change to the other, and the concerns are that relation's connected components. **That relation is chosen once.** Two defensible readings of _forces_ yield component counts an order of magnitude apart, so the regress stops at a choice rather than dissolving. **The claim is therefore three levels with one choice at the bottom, and it is weaker than the count being derived outright.** - **What survives the objection.** The bottom choice is answerable to EVIDENCE rather than settled by taste, because a relation must yield a partition INVARIANT UNDER OCCUPANCY — one that does not lose a node when a party stops while that node's work continues — and must yield a floor consistent with OBSERVED INDISPENSABILITY. Neither constraint selects a unique relation; both eliminate candidates. **That is the difference between a choice that hides and one that can be argued with.** ## Invariant — the floor counts the partition's nodes - **Property.** The minimum count is the number of concerns that must be able to CONTRADICT each other while each stays authoritative. Volume is the wrong operand: quantity divides across parties and so argues for a longer schedule rather than a wider one, while INDIVISIBILITY is what forces a second party. - **Set.** The concerns a partition yields over one governed tree. - **Parties.** Whoever allocates, and whoever owns a surface. - **Objector.** A relation whose components collapse to one refutes the floor it produces wherever separate parties demonstrably caught what no single one did. ## Invariant — the ceiling is set by the worst fan-in, not by the count - **Property.** The maximum useful count is reached where the claims resting on ONE surface stop surviving composition — where a claim is stale by the time it lands more often than it is useful when it does. It could be false: staleness distributed evenly across surfaces regardless of how many parties' claims rest on each would refute it. - **Set.** Every surface a governed tree carries. - **Parties.** Whoever composes a claim about a surface they do not own. - **Its objector, which was argued and lost rather than never raised.** The rate at which any one claim goes stale is set by the writer's rate and the composer's time — both properties of ONE writer and ONE composer — so no reader population changes it, and on that reading the bound is not a function of the count at all. **What survives that is the COST term rather than the rate**: the number of stale claims published does scale with the population, and each is read and usually answered by every other party. A reader meeting this invariant cold would otherwise conclude the rate half was never considered. - **Why FAN-IN rather than write rate.** A surface with one writer cannot have its volatility raised by adding a party, so a party writing only its own surfaces adds nothing to anyone's staleness. Staleness rises only where parties CONVERGE on one subject. **Ownership therefore BOUNDS fan-in rather than defining it** — the concentration is continuous, and a formally owned surface many parties reason about behaves like a shared one. - **The cost asymmetry that makes it a ceiling.** A stale claim is read, and usually answered, by every other party — so the cost of staleness grows with the population while the benefit of one more perspective grows sublinearly as coverage overlaps. Two terms with different growth cross, and the crossing is the bound. - **The bound is MOVABLE, and the term that moves is the cost rather than the rate.** The rate at which a claim goes stale is set by one surface's writer and one composer, so no party count changes it and nothing addresses it. The cost is what the population multiplies, so that is the term a mechanism can reach: a claim arriving MARKED as resting on a surface which has since moved costs its readers a glance, where one that must be argued costs every party a read and usually a reply. **A mechanism recording when a claim's cited surface was observed reduces no staleness whatever — it reduces what staleness COSTS**, and therefore raises the ceiling without touching the partition, the relation or the count. A reader taking the bound as fixed concludes the only lever is fewer parties, which is the wrong lever and the expensive one. - **Objector to the movability.** Where the cost of a stale claim is dominated by work already BUILT on it rather than by reading and answering it, marking it afterwards recovers nothing and the bound does not move. ## Invariant — fan-in is measured and never declared - **Property.** The operand both bounds read is derivable from traffic a coordination surface ALREADY records: who authored a claim, who it was addressed to, and which surface it cites. A declared edge set would be a second copy of that fact, maintained by hand, disagreeing with the observed coupling the first time the work moves. - **Set.** Every coupling edge between concerns. - **Parties.** Whoever would maintain a declared graph. - **Objector.** A tree whose coordination surfaces record neither authorship nor citation cannot derive it, and there the bound is unavailable rather than merely unmeasured. ## The limit — the benefit term fails on ABSENCE claims **THE FLOOR RESTS ON A MULTIPLIER — THE PROBABILITY THAT SOME PARTY OPENS THE OPERAND ANOTHER DID NOT — AND THAT MULTIPLIER HAS A CLASS WHERE IT DOES NOT APPLY.** A claim that something EXISTS has an operand each party can open, and parties spread across operands. A claim that something DOES NOT EXIST has no operand at all, so parties spread across DESCRIPTIONS of the missing thing, which all say the same thing. **Added parties then produce agreement rather than coverage**, and thoroughness is the symptom rather than the missing ingredient. **The settling act is an INVOCATION rather than a read**, because a capability's absence is established by attempting it. And the mechanism half scales better than the conduct half: **a refusal that PUBLISHES ITS CRITERION** — naming what it searched and what else it will accept — converts an unanswerable absence into an ordinary read, once, for every later caller. A mechanism that silently accepts what it does not recognize is the extreme case of a refusal publishing nothing. ## What the format of a schedule does and does not decide **A TYPED SCHEDULE MAKES A STRAY NOTE A REFUSAL RATHER THAN A CONVENTION**, because prose written into a parsed structure fails to resolve instead of being read as content — which is a gate where a second file is only a habit. It also separates facts a single column had been carrying: an identity that travels into a name, and a POSITION that is the sequence. **It does not decide the schedule's SEMANTICS.** A unique next computed over a partial order with forward dependencies has no unique answer, and an ordered typed structure expresses that ambiguity exactly as faithfully as a table does. **Format and ordering semantics are separable, and conflating them buys neither.** ## The four elements | element | states | | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | SCHEMA | a partition of surfaces into concerns; per concern, its owner and the surfaces it holds; per claim, its author, its addressees and the surfaces it cites | | LIFETIME | the partition is current-truth and re-derived when the coupling relation's inputs move; a claim's citation record accumulates and is never rewritten | | FAILURE MODE | a count chosen rather than derived reads as a decision and is a preference; work is then allocated to parties rather than parties to work, and the surface whose fan-in exceeds the ceiling produces contradictions that every party reads as carelessness | | GATE | `none` — no mechanism derives the partition, no mechanism counts fan-in, and no mechanism compares a proposed count against either bound. The operands exist and the derivations do not, which is declared debt rather than an assessed decision | ## Gate - A statement here naming a project, a party, a tool, a file or a count fails: those are instance content. - An invariant stated without its property, its set and its parties is unstated and fails as such. - An invariant stated with no objector fails unless it declares itself unheld and marks what rests on it. - The GATE element reads `none` deliberately, which states declared debt; an ABSENT element would make an oversight indistinguishable from an assessed decision. ```